Changeset 6430


Ignore:
Timestamp:
Dec 10, 2008, 2:11:32 PM (17 years ago)
Author:
RIck van der Zwet
Message:

Commit syntax changes

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/exodus/views.py

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