| 1 | # (c) Roland van Laar 2006
|
---|
| 2 |
|
---|
| 3 | from django.db import models
|
---|
| 4 | from django.http import HttpResponse, HttpResponseRedirect
|
---|
| 5 | from django.template import Context, loader
|
---|
| 6 | from django.shortcuts import render_to_response
|
---|
| 7 | from django.core.urlresolvers import reverse, NoReverseMatch
|
---|
| 8 | from django.forms.formsets import formset_factory
|
---|
| 9 | from django import forms
|
---|
| 10 | from socket import gethostname
|
---|
| 11 |
|
---|
| 12 | from exodus.models import *
|
---|
| 13 | from exodus.wllogic import free_masterip, newSSIDName, addInterlinkIP, \
|
---|
| 14 | freeInterlinkIP, freePublicAPIP
|
---|
| 15 |
|
---|
| 16 | from exodus.utils import pdebug
|
---|
| 17 |
|
---|
| 18 | class GenericHandler(object):
|
---|
| 19 | """Conventions used: type has to to the same name as the dependency
|
---|
| 20 | object, delet template is named delete<type>.html
|
---|
| 21 | """
|
---|
| 22 | def __init__(self, request, mode):
|
---|
| 23 | pdebug(100, "Function: GenericHandler.__init__")
|
---|
| 24 | # Strip 'Handler' of name
|
---|
| 25 | type = self.__class__.__name__[:-7:]
|
---|
| 26 | formClass = eval(type + 'Form')
|
---|
| 27 |
|
---|
| 28 | self.object = eval('self.' + type[0].lower() + type[1::])
|
---|
| 29 | self.title = self.object._meta.verbose_name
|
---|
| 30 | self.request = request
|
---|
| 31 | self.mode = mode
|
---|
| 32 | self.is_changed = {}
|
---|
| 33 |
|
---|
| 34 | if request.POST.has_key('cancel'):
|
---|
| 35 | pdebug(100, "Action cancel")
|
---|
| 36 | self.form_action = 'cancel'
|
---|
| 37 | # Allow overriding cancel call, in particular with regards to the
|
---|
| 38 | # response call
|
---|
| 39 | self._cancel()
|
---|
| 40 | elif request.POST.has_key('proceed'):
|
---|
| 41 | pdebug(100, "Action proceed")
|
---|
| 42 | self.form_action = 'proceed'
|
---|
| 43 |
|
---|
| 44 | # Delete does not require a valid form
|
---|
| 45 | if mode == 'delete':
|
---|
| 46 | self._delete()
|
---|
| 47 | else:
|
---|
| 48 | # First checking whether form is valid, then add/edit actions
|
---|
| 49 | self.form = formClass(request.POST, instance=self.object)
|
---|
| 50 | try:
|
---|
| 51 | if self.form.is_valid():
|
---|
| 52 | pdebug(100, "Form valid")
|
---|
| 53 | # Set response on forehand, to allow override \
|
---|
| 54 | # in procedure
|
---|
| 55 | try:
|
---|
| 56 | self.response = HttpResponseRedirect(reverse( \
|
---|
| 57 | 'exodus.views.viewNode', args=[self.node.name]))
|
---|
| 58 | except (AttributeError, NoReverseMatch):
|
---|
| 59 | self.response = HttpResponseRedirect(reverse( \
|
---|
| 60 | 'exodus.views.viewNodelist'))
|
---|
| 61 |
|
---|
| 62 | #Checking whether data did change
|
---|
| 63 | _oldInstance = dict(self.object.as_list())
|
---|
| 64 | _instance = dict(self.form.save(commit=False).as_list())
|
---|
| 65 | for key,value in _instance.items():
|
---|
| 66 | if value != _oldInstance[key]:
|
---|
| 67 | pdebug(100, "Key %s changed value '%s' -> '%s'"\
|
---|
| 68 | % (key, _oldInstance[key], value))
|
---|
| 69 | self.is_changed[key] = value
|
---|
| 70 |
|
---|
| 71 | # Call override procedure
|
---|
| 72 | if mode == 'add':
|
---|
| 73 | self._add()
|
---|
| 74 | elif mode == 'edit':
|
---|
| 75 | self._edit()
|
---|
| 76 | else:
|
---|
| 77 | raise ValueError, 'Mode "%s" not defined' % mode
|
---|
| 78 | else:
|
---|
| 79 | raise ValueError, 'Form error, please edit and resubmit'
|
---|
| 80 | except ValueError, message:
|
---|
| 81 | self.response = render_to_response('genericForm.html', {
|
---|
| 82 | 'form': self.form, 'message' : message,
|
---|
| 83 | 'title' : self.title, 'mode' : mode,
|
---|
| 84 | 'type' : type, 'object': self.object,
|
---|
| 85 | 'delInclude' : "delete" + type.capitalize() + ".html",
|
---|
| 86 | 'addInclude' : "add" + type.capitalize() + ".html",
|
---|
| 87 | 'editInclude' : "edit" + type.capitalize() + ".html" })
|
---|
| 88 | else:
|
---|
| 89 | message = 'Please edit and submit'
|
---|
| 90 |
|
---|
| 91 | # Dirty? hack to allow initial form to be filled with date \
|
---|
| 92 | # for GET request, no errors raised
|
---|
| 93 | if request.GET and mode == 'add':
|
---|
| 94 | self.form = formClass(request.GET, instance=self.object)
|
---|
| 95 | self.form._errors = {}
|
---|
| 96 | else:
|
---|
| 97 | self.form = formClass(instance=self.object)
|
---|
| 98 |
|
---|
| 99 | self.response = render_to_response('genericForm.html', {
|
---|
| 100 | 'form': self.form, 'message' : message, 'title' : self.title,
|
---|
| 101 | 'mode' : mode, 'type' : type, 'object': self.object,
|
---|
| 102 | 'delInclude' : "delete" + type.capitalize() + ".html",
|
---|
| 103 | 'addInclude' : "add" + type.capitalize() + ".html",
|
---|
| 104 | 'editInclude' : "edit" + type.capitalize() + ".html" })
|
---|
| 105 |
|
---|
| 106 | def _add(self):
|
---|
| 107 | pdebug(100, "Function: GenericHandler._add")
|
---|
| 108 | self.form.save()
|
---|
| 109 |
|
---|
| 110 | def _edit(self):
|
---|
| 111 | pdebug(100, "Function: GenericHandler._edit")
|
---|
| 112 | self.form.save()
|
---|
| 113 |
|
---|
| 114 | def _delete(self):
|
---|
| 115 | pdebug(100, "Function: GenericHandler._delete")
|
---|
| 116 | self.object.delete()
|
---|
| 117 | self.response = HttpResponseRedirect(reverse('exodus.views.viewNode',\
|
---|
| 118 | args=[self.node.name]))
|
---|
| 119 |
|
---|
| 120 | def _cancel(self):
|
---|
| 121 | pdebug(100, "Function: GenericHandler._cancel")
|
---|
| 122 | self.response = HttpResponseRedirect(reverse('exodus.views.viewNode',\
|
---|
| 123 | args=[self.node.name]))
|
---|
| 124 | #self.response = HttpResponseRedirect(reverse('exodus.views.viewNodelist'))
|
---|
| 125 |
|
---|
| 126 | def render_to_response(self):
|
---|
| 127 | pdebug(100, "Function: GenericHandler.render_to_response")
|
---|
| 128 | return self.response
|
---|
| 129 |
|
---|
| 130 |
|
---|
| 131 | #
|
---|
| 132 | # PublicAP
|
---|
| 133 | class PublicAPForm(forms.ModelForm):
|
---|
| 134 | class Meta:
|
---|
| 135 | model = PublicAP
|
---|
| 136 | exclude = ('shortdesc', 'desc', 'ip', 'dhcpstart', 'dhcpstop')
|
---|
| 137 |
|
---|
| 138 | class PublicAPHandler(GenericHandler):
|
---|
| 139 |
|
---|
| 140 | def __init__(self, request, node, interface, publicAP, mode):
|
---|
| 141 | pdebug(100, "Function: PublicAPHandler.__init__")
|
---|
| 142 | self.node = Node.objects.get(name=node)
|
---|
| 143 | self.interface = Interface.objects.get(node=self.node, iface=interface)
|
---|
| 144 | if mode == 'add':
|
---|
| 145 | self.publicAP = PublicAP(iface=self.interface)
|
---|
| 146 | else:
|
---|
| 147 | self.publicAP = PublicAP.objects.get(iface=self.interface, \
|
---|
| 148 | pk=publicAP)
|
---|
| 149 | super(PublicAPHandler, self).__init__(request, mode)
|
---|
| 150 |
|
---|
| 151 | def _add(self):
|
---|
| 152 | pdebug(100, "Function: PublicAPHandler._add")
|
---|
| 153 | _instance = self.form.save(commit=False)
|
---|
| 154 | # Find IP range inside interface range with disired size/subnet
|
---|
| 155 | _instance.ip = freePublicAPIP(_instance.iface, _instance.netmask)
|
---|
| 156 | _instance.dhcpstart = 1
|
---|
| 157 | _instance.dhcpstop = 2
|
---|
| 158 | # If wireless generate ssid name
|
---|
| 159 | _instance.ssid = newSSIDName(_instance.iface.node, _instance.iface, \
|
---|
| 160 | 'omni')
|
---|
| 161 | _instance.save()
|
---|
| 162 |
|
---|
| 163 | def genericPublicAP(request, node, interface, publicAP, mode):
|
---|
| 164 | pdebug(100, "Function: genericPublicAP")
|
---|
| 165 | handler = PublicAPHandler(request, node, interface, publicAP, mode)
|
---|
| 166 | return handler.render_to_response()
|
---|
| 167 |
|
---|
| 168 | #
|
---|
| 169 | # Interface
|
---|
| 170 | class InterfaceForm(forms.ModelForm):
|
---|
| 171 | class Meta:
|
---|
| 172 | model = Interface
|
---|
| 173 | exclude = ( 'ip', 'ssid', 'mode', 'channel', 'shortdesc', \
|
---|
| 174 | 'netmask' )
|
---|
| 175 |
|
---|
| 176 | class InterfaceHandler(GenericHandler):
|
---|
| 177 | def __init__(self, request, node, interface, mode):
|
---|
| 178 | pdebug(100, "Function: InterfaceHandler.__init__")
|
---|
| 179 | self.node = Node.objects.get(name=node)
|
---|
| 180 | if mode == 'add':
|
---|
| 181 | self.interface = Interface(node=self.node)
|
---|
| 182 | else:
|
---|
| 183 | self.interface = Interface.objects.get(node=self.node, \
|
---|
| 184 | iface=interface)
|
---|
| 185 | super(InterfaceHandler, self).__init__(request, mode)
|
---|
| 186 |
|
---|
| 187 | def _add(self):
|
---|
| 188 | pdebug(100, "Function: InterfaceHandler._add")
|
---|
| 189 | self._saveInterface()
|
---|
| 190 |
|
---|
| 191 | def _edit(self):
|
---|
| 192 | pdebug(100, "Function: InterfaceHandler._edit")
|
---|
| 193 | self._saveInterface()
|
---|
| 194 |
|
---|
| 195 | def _saveInterface(self):
|
---|
| 196 | pdebug(100, "Function: InterfaceHandler._saveInterface")
|
---|
| 197 | _instance = self.form.save(commit=False)
|
---|
| 198 | if _instance.link and (_instance.type != _instance.link.type):
|
---|
| 199 | raise ValueError,'Type of local and remote interface needs to match'
|
---|
| 200 | if str(_instance.type) != "eth":
|
---|
| 201 | _instance.ssid = newSSIDName(_instance.node, _instance.iface, \
|
---|
| 202 | 'unused')
|
---|
| 203 | _instance.channel = '1'
|
---|
| 204 | _instance.mode = 1 # set to master
|
---|
| 205 |
|
---|
| 206 | # Only change IP if changes in interface link/mask or new of course :-)
|
---|
| 207 | if self.mode == 'add' or self.is_changed.has_key('link') or \
|
---|
| 208 | self.is_changed.has_key('netmask'):
|
---|
| 209 | if not _instance.link:
|
---|
| 210 | _instance.ip = freeInterlinkIP(_instance)
|
---|
| 211 | else:
|
---|
| 212 | _instance.ip = addInterlinkIP(_instance.link)
|
---|
| 213 |
|
---|
| 214 | # XXX: Change in netmask requires full range of netmask changes \
|
---|
| 215 | # on slaves
|
---|
| 216 | _instance.save()
|
---|
| 217 | #Dirty to hack to get reference to self working
|
---|
| 218 | if not _instance.link:
|
---|
| 219 | _instance.link = _instance
|
---|
| 220 | _instance.save()
|
---|
| 221 |
|
---|
| 222 | def genericInterface(request, node, interface, mode):
|
---|
| 223 | pdebug(100, "Function: genericInterface")
|
---|
| 224 | handler = InterfaceHandler(request, node, interface, mode)
|
---|
| 225 | return handler.render_to_response()
|
---|
| 226 |
|
---|
| 227 | #
|
---|
| 228 | # Node
|
---|
| 229 | class NodeForm(forms.ModelForm):
|
---|
| 230 | class Meta:
|
---|
| 231 | model = Node
|
---|
| 232 | exclude = ( 'masterip' )
|
---|
| 233 |
|
---|
| 234 | class NodeHandler(GenericHandler):
|
---|
| 235 | def __init__(self, request, node, mode):
|
---|
| 236 | pdebug(100, "Function: NodeHandler.__init__")
|
---|
| 237 | if mode == 'add':
|
---|
| 238 | self.node = Node()
|
---|
| 239 | else:
|
---|
| 240 | self.node = Node.objects.get(name=node)
|
---|
| 241 | super(NodeHandler, self).__init__(request, mode)
|
---|
| 242 |
|
---|
| 243 | def _add(self):
|
---|
| 244 | pdebug(100, "Function: NodeHandler._add")
|
---|
| 245 | # input a valid master ip into new_data
|
---|
| 246 | _instance = self.form.save(commit=False)
|
---|
| 247 | _instance.masterip = free_masterip(_instance.network)
|
---|
| 248 | _instance.save()
|
---|
| 249 | self.response = HttpResponseRedirect(reverse('exodus.views.viewNode', \
|
---|
| 250 | args=[_instance.name]))
|
---|
| 251 |
|
---|
| 252 | def _delete(self):
|
---|
| 253 | pdebug(100, "Function: NodeHandler._delete")
|
---|
| 254 | for _master in Interface.objects.filter(node=self.object):
|
---|
| 255 | if _master.link == _master:
|
---|
| 256 | for _makeMaster in Interface.objects.filter(link=_master):
|
---|
| 257 | _makeMaster.link = _makeMaster
|
---|
| 258 | _makeMaster.save()
|
---|
| 259 | self.object.delete()
|
---|
| 260 | # As node is deleted, goto overview page
|
---|
| 261 | self.response = HttpResponseRedirect(reverse( \
|
---|
| 262 | 'exodus.views.viewNodelist'))
|
---|
| 263 |
|
---|
| 264 | def _cancel(self):
|
---|
| 265 | pdebug(100, "Function: NodeHandler._cancel")
|
---|
| 266 | if self.mode == 'new':
|
---|
| 267 | self.response = HttpResponseRedirect(reverse( \
|
---|
| 268 | 'exodus.views.viewNodelist'))
|
---|
| 269 | else:
|
---|
| 270 | self.response = HttpResponseRedirect(reverse( \
|
---|
| 271 | 'exodus.views.viewNode', args=[self.node.name]))
|
---|
| 272 |
|
---|
| 273 | def genericNode(request, node, mode):
|
---|
| 274 | pdebug(100, "Function: genericNode")
|
---|
| 275 | handler = NodeHandler(request, node, mode)
|
---|
| 276 | return handler.render_to_response()
|
---|
| 277 |
|
---|
| 278 | #
|
---|
| 279 | # location
|
---|
| 280 | class LocationForm(forms.ModelForm):
|
---|
| 281 | class Meta:
|
---|
| 282 | model = Location
|
---|
| 283 |
|
---|
| 284 | class LocationHandler(GenericHandler):
|
---|
| 285 | def __init__(self, request, location, mode):
|
---|
| 286 | pdebug(100, "Function: LocationHandler.__init__")
|
---|
| 287 | if mode == 'add':
|
---|
| 288 | self.location = Location()
|
---|
| 289 | else:
|
---|
| 290 | self.location = Location.objects.get(description=location)
|
---|
| 291 |
|
---|
| 292 | super(LocationHandler,self).__init__(request, mode)
|
---|
| 293 |
|
---|
| 294 | def _add(self):
|
---|
| 295 | pdebug(100, "Function: LocationHandler._add")
|
---|
| 296 | _instance = self.form.save()
|
---|
| 297 | # After adding a location, allow adding a Node with this location
|
---|
| 298 | self.response = HttpResponseRedirect( \
|
---|
| 299 | reverse('exodus.views.genericNode', args=["add", "new"]) + \
|
---|
| 300 | "?location=%i" % _instance.pk)
|
---|
| 301 |
|
---|
| 302 | def _delete(self):
|
---|
| 303 | pdebug(100, "Function: LocationHandler._delete")
|
---|
| 304 | self.object.delete()
|
---|
| 305 | self.response = HttpResponseRedirect(reverse( \
|
---|
| 306 | 'exodus.views.viewNodelist'))
|
---|
| 307 |
|
---|
| 308 | def _cancel(self):
|
---|
| 309 | pdebug(100, "Function: LocationHandler._cancel")
|
---|
| 310 | self.response = HttpResponseRedirect(reverse( \
|
---|
| 311 | 'exodus.views.viewNodelist'))
|
---|
| 312 |
|
---|
| 313 | #
|
---|
| 314 | # Views
|
---|
| 315 | def viewNode(request, node):
|
---|
| 316 | pdebug(100, "Function: viewNode")
|
---|
| 317 | node = Node.objects.get(name=node)
|
---|
| 318 | return render_to_response('viewNode.html', {'node': node})
|
---|
| 319 |
|
---|
| 320 | def viewNodelist(request):
|
---|
| 321 | pdebug(100, "Function: viewNodelist")
|
---|
| 322 | nodes = Node.objects.all()
|
---|
| 323 | configFiles = (
|
---|
| 324 | 'rc.local',
|
---|
| 325 | 'rc.node.local',
|
---|
| 326 | 'dhcpd.conf',
|
---|
| 327 | 'named.conf',
|
---|
| 328 | 'resolv.conf' )
|
---|
| 329 | return render_to_response('viewNodelist.html', {'nodes' : nodes, \
|
---|
| 330 | 'configFiles' : configFiles})
|
---|
| 331 |
|
---|
| 332 | def configFile(request, version, node, file):
|
---|
| 333 | pdebug(100, "Function: configFile")
|
---|
| 334 | node = Node.objects.get(name=node)
|
---|
| 335 |
|
---|
| 336 | # Extra statictics information for use of generation
|
---|
| 337 | server = {}
|
---|
| 338 | server['host'] = gethostname()
|
---|
| 339 |
|
---|
| 340 | templateFile = version + '/' + file
|
---|
| 341 | return render_to_response(templateFile, {'node' : node, 'server' : server},\
|
---|
| 342 | mimetype='text/plain')
|
---|
| 343 |
|
---|
| 344 | #
|
---|
| 345 | # DnsServer
|
---|
| 346 | class DnsServerForm(forms.ModelForm):
|
---|
| 347 | class Meta:
|
---|
| 348 | model = DnsServer
|
---|
| 349 |
|
---|
| 350 | class DnsServerHandler(GenericHandler):
|
---|
| 351 | def __init__(self, request, dnsServer, mode):
|
---|
| 352 | pdebug(100, "Function: DnsServerHandler.__init__")
|
---|
| 353 | if mode == 'add':
|
---|
| 354 | self.dnsServer = DnsServer()
|
---|
| 355 | else:
|
---|
| 356 | self.dnsServer= DnsServer.objects.get(ipaddress=dnsServer)
|
---|
| 357 | super(DnsServerHandler, self).__init__(request, mode)
|
---|
| 358 |
|
---|
| 359 | def _add(self):
|
---|
| 360 | pdebug(100, "Function: DnsServerHandler._add")
|
---|
| 361 | _instance = self.form.save()
|
---|
| 362 | self.response = HttpResponseRedirect(reverse('exodus.views.viewList', \
|
---|
| 363 | args=['dnsServer']))
|
---|
| 364 |
|
---|
| 365 | def _delete(self):
|
---|
| 366 | pdebug(100, "Function: DnsServerHandler._delete")
|
---|
| 367 | self.object.delete()
|
---|
| 368 | self.response = HttpResponseRedirect(reverse('exodus.views.viewList', \
|
---|
| 369 | args=['dnsServer']))
|
---|
| 370 |
|
---|
| 371 | def _cancel(self):
|
---|
| 372 | pdebug(100, "Function: DnsServerHandler._cancel")
|
---|
| 373 | self.response = HttpResponseRedirect(reverse('exodus.views.viewList', \
|
---|
| 374 | args=['dnsServer']))
|
---|
| 375 |
|
---|
| 376 | def genericModel(request, model, mode, object):
|
---|
| 377 | pdebug(100, "Function: genericModel %s, %s, %s" % (model, mode, object))
|
---|
| 378 | """Wrapper, to get to the function needed"""
|
---|
| 379 | model = model[0].upper() + model[1::]
|
---|
| 380 | model = eval(model + 'Handler')
|
---|
| 381 | handler = model(request, object, mode)
|
---|
| 382 | return handler.render_to_response()
|
---|
| 383 |
|
---|
| 384 | def viewList(request, model):
|
---|
| 385 | pdebug(100, "Function: viewList")
|
---|
| 386 | """Standard interface for simple overview pages, with view/edit/delete
|
---|
| 387 | buttons on it
|
---|
| 388 | """
|
---|
| 389 | modelURL = model
|
---|
| 390 | model = model[0].upper() + model[1::]
|
---|
| 391 | modelName = model
|
---|
| 392 | model = eval(model)
|
---|
| 393 | objects = model.objects.all()
|
---|
| 394 | return render_to_response('viewList.html', {'objects': objects, \
|
---|
| 395 | 'modelURL' : modelURL, 'modelName' : modelName})
|
---|