source: dassmodus/trunk/dassmodus/nosferatu/nosferatu/config_classes.py @ 953

Last change on this file since 953 was 953, checked in by pstorz, 10 years ago

first checkin

File size: 26.9 KB
Line 
1# -*- coding: utf-8 -*-
2# $Id: config_classes.py 12290 2011-02-10 14:02:38Z pstorz $
3import re
4import logging
5import copy
6logger = logging.getLogger("directive")
7import scheduleparser # schedule class
8from auto_types import *
9
10from  prettynames import *
11
12RXP_SIMPLE_ITEM = re.compile(r'''
13(^|;)(\s*(?P<itemname>[\w ]+?)?\s*=\s*(?P<value>"?[^;^\n]+"?)(?P<comment>\s+\#.*)?) # xxx = yyy # comment
14''',re.M| re.X)
15#(^|;)(\s*(?P<itemname>[\w ]+?)?\s*=\s*(?P<value>"?[^{^}^;^\n]+"?)(?P<comment>\s+\#.*)?) # xxx = yyy # comment
16   
17#(^|;)(\s*(?P<itemname>[\w ]+?)?\s*=\s*(?P<value>"?[^{^}^;^\n^\s]+"?)\s*(?P<comment>\s+\#.*)?) # xxx = yyy # comment
18
19RXP_RESTYPE = re.compile(r'''
20  ^\s*(?P<resourcetype>\w[\w ]+?\s*(=\s+)?\s?)$
21''', re.M|re.X|re.S)
22
23# TODO: allow spaces in resourcetypes like sd addresses!
24# this does not work now
25#  SD Addresses = <
26 
27RXP_NRTEXT = re.compile(r'''
28(?P<number>\d+)\s?(?P<text>[A-Za-z]+)
29''', re.M|re.X|re.S)
30
31#RXP_TEXTNR = re.compile(r'''
32#(?P<text>\w+)\s?(?P<number>\d+)
33#''', re.M|re.X|re.S)
34
35# what resources can appear multiple times in director configs?
36MULTIPLE_RESOURCES_IN_DIRD = set([
37                                  'client',
38                                  'console',
39                                  'fileset',
40                                  'job',
41                                  'jobdefs',
42                                  'messages',
43                                  'pool',
44                                  'schedule',
45                                  'storage',
46                                  ])
47
48INTERNALLY_REFERENCED_ITEMS = set(['fileset',
49                                  'client' ,
50                                  'catalog',
51                                  'messages',
52                                  'schedule',
53                                  'storage',
54                                  'jobdefs',
55                                  'pool',
56                                  'incrementalbackuppool',
57                                  'fullbackuppool',
58                                  'differentialbackuppool',
59                                  'job',
60                                  'basejob',
61                                  'device',
62                                  ])
63
64# translate full name to short name
65res2shrtn = {          'catalog'      :'cat',
66                       'client'       :'cli',
67                       'console'      :'con',
68                       'counter'      :'counter',
69                       'director'     :'dir',
70                       'fileset'      :'fs',
71                       'filedaemon'   :'cli',  # filedaemon is the same as cli
72                       'job'          :'job',
73                       'jobdefs'      :'job',  # jobdefs are the same as jobs
74                       'messages'     :'msgs',
75                       'pool'         :'pool',
76                       'runscript'    :'runscript',
77                       'schedule'     :'sch',
78                       'storage'      :'store',
79                       #'console'      :'con',
80                       'autochanger'  :'changer',
81                       'device'       :'dev',     
82                      'options'       :'options',
83                       #manually added
84                      'diraddresses'  :'addresses',
85                      'fdaddresses'  :'addresses',
86                      'sdaddresses'  :'addresses',
87                      'ip'           :'ip',
88                      'ipv4'         :'ip',
89                      'ipv6'         :'ip',
90                      'include'      : 'include',
91                      'exclude'      : 'include',
92                       }
93
94
95# which itemsnames can appear multiple times?
96MULTIPLE_ALLOWED_ITEMS_SET  = set([
97                             'file',
98                             'run',
99                             ])
100
101#MULTIPLE_ALLOWED_RESOURCES_SET = set([
102#                                      'include',
103#                                      'exclude',
104#                                      'ip',
105#                                      ])
106
107
108timemultiplicators = {
109               "seconds"  : 1,
110               "minutes"  : 60,
111               "mins"     : 60,
112               "hours"    : 3600,
113               "days"     : 3600*24,
114               "weeks"    : 3600*24*7,   
115               "quarters" : 3600*24*91,   
116               "years"    : 3600*24*365,
117               "months"   : 60*60*24*30,
118               "n"        : 60,
119               }
120
121datamultiplicators  = {
122                "k" : 1024,          #/* kilobyte */
123                "kb": 1000,          #/* kb kilobyte */
124                "m" : 1048576,       #/* megabyte */
125                "mb": 1000000,       #/* mb megabyte */
126                "g" : 1073741824,    #/* gigabyte */
127                "gb": 1000000000};   #/* gb gigabyte */
128               
129
130RESSOURCES_WITH_EQUALSIGN = set(['diraddresses',
131                                'fdaddresses',
132                                'sdaddresses',
133                                'ip',
134                                'ipv4',
135                                'ipv6',
136                                ])
137
138#INDENTSTRING = '|--|'
139INDENTSTRING = '  '
140
141
142
143
144class Item(object):
145    def __init__(self, name, value, defaultvalue, default, type, required, parentresource = None, indentlevel = 0):
146        self.indentlevel = indentlevel
147        self.parentresource = parentresource
148        self.name = name.lower().replace(' ','')
149        self.defaultvalue = defaultvalue
150        self.default = default
151        self.value = value # real value lies in storage       
152        self.type = type
153        self.required = required
154        self.printall = False
155        #TODO: try/except this eval
156        #print type, defaultvalue
157       
158        #storage1 = eval(type + '(' + str(defaultvalue) +')' )
159        #self.storage = copy.deepcopy(storage1)
160        #logger.debug('storage: ' +str(id(self.storage)) + ' storage1: ' + str(id(storage1)))
161       
162        self.storage  =  eval(type + '(' + str(defaultvalue) +')' )
163        self.storage.setValue(value)
164       
165       
166        self.storage.indentlevel = self.indentlevel + 1
167        self.storage.setParentItem(self)
168 
169
170    def __lt__(self,other):
171      #print "comparing", self.name, other.name
172      if self.name == 'name': # name comes first
173        #print self.name,"<",other.name
174        return True
175      if self.name < other.name :
176        #print self.name,"<",other.name
177        return True
178      else:
179        #print self.name,">",other.name
180        return False
181
182
183    def __repr__(self):
184      string_types = set(['store_time'])
185      if self.type in string_types: # explicitly store this in a string
186          return "Item(\'%s\', \'%s\', \'%s\', %s, \'%s\', %s)" % (str(self.name),
187                                                         self.value,
188                                                         self.defaultvalue,
189                                                         self.default,
190                                                         str(self.type),
191                                                         self.required)
192      else:
193          return "Item(\'%s\', %s, %s, %s, \'%s\', %s)" % (str(self.name),
194                                                         self.value,
195                                                         self.defaultvalue,
196                                                         self.default,
197                                                         str(self.type),
198                                                         self.required)
199
200
201    ''' find out if this item is to be printed or not '''
202    def print_item(self):
203        printout = self.printall # override to print all out       
204        if self.default:
205          if str(self.storage.value) != str(self.defaultvalue):
206            logger.debug( "printing " + self.name + " as self.storage.value != self.defaultvalue:"
207                         + str(self.storage.value) + ' != ' + str(self.defaultvalue) + '<' )
208            printout = True
209          else:
210            #pass
211            logger.debug( "NOT printing " + self.name + " as self.storage.value == self.defaultvalue:"
212                         + str(self.storage.value) + ' == ' + str(self.defaultvalue) + '<' )
213
214        elif self.required:
215          # jobs can inherit their items from jobdefs, jobdefs do not need a client
216          # but a name is needed anyway
217          # TODO: merge jobs and jobdefs in order to check if they are complete after merge
218
219          # jobs and jobdefs
220          if self.parentresource.resourcetype.startswith('job') and self.value == self.defaultvalue and str(self.storage.value) == str(self.defaultvalue):
221            printout = False
222          else:
223            logger.debug( "printing " + self.name + " as self.required is set")
224            printout = True
225
226        elif self.storage.value is not None:
227
228          if self.storage.value != self.defaultvalue:
229            logger.debug( "printing " + self.name + " as self.storage.value is set to :>"
230                         + str( self.storage.value )+'<')
231            printout = True
232
233        return printout
234
235
236    def __str__(self):
237        '''
238        standard behaviour:
239        only print items that are configured and have not a different value than the default value
240        '''
241
242        if self.print_item():
243          return '%s%s = %s\n' % ( self.indentlevel * INDENTSTRING,  prettyName(self.name), self.storage)
244          #return '    %s = %s\n' % (prettyName(self.name), self.storage)
245        else:
246          return ''
247
248    def setValue(self, value):
249      '''set value item'''
250      self.storage.setValue(value)
251
252
253
254
255
256#class command(object):
257#  '''
258#  this class contains the information to a console command, also dot commands
259#  '''
260#  def __init__(self, commandtext, commandname, usage, help, inrunscript):
261#    self.commandtext = commandtext
262#    self.commandname = commandname
263#    self.usage = usage
264#    self.help = help
265#    self.inrunscript = inrunscript
266#
267#  def __repr__(self):
268#    return "command('%s','%s','%s','%s','%s')" % (self.commandtext, self.commandname, self.usage, self.help, self.inrunscript)
269
270
271
272
273# the bacula internal storage representations
274#
275# base classes for all storages
276class Item_Storage(object):
277  """
278  base class for the representation of any item object
279  """
280 
281  def __init__(self,val):
282    self.value = val
283    self.comment = ''
284    self.possiblevalues = []  # what values are possible here ?
285    self.parentitem = None
286   
287  def __str__(self):
288    #TODO do this in a nicer way without a catch-all try-except
289    if self.comment != '':
290      comment = "\t# " + self.comment
291    else:
292      comment = ''
293    try:
294      #return self.value
295      return self.value + comment #+self.__class__.__name__ + ' id: '+ str(id(self))
296    except:
297      #return str(self.value)
298      return unicode(self.value) + comment  #+self.__class__.__name__ + ' id: '+ str(id(self))
299   
300  def setParentItem(self,parentItem):
301    self.parentitem = parentItem
302   
303  def setValue(self,value):
304    logger.debug( self.__class__.__name__ +':' + 'called self.value with \''+ str(value) + '\'')   
305    self.value = value
306    logger.debug("self.value is now" + str(self) )
307
308class Item_Storage_String (Item_Storage):
309  pass
310    #def __str__(self):
311    #  return str(self.value)
312      #return '"' + str(self.value) + '"'# + '\t# '+ self.__class__.__name__
313
314
315# generated
316class store_pint32( Item_Storage ):
317  def __str__(self):
318    return str(self.value) #+ '\t# '+self.__class__.__name__ + 'id: '+ str(id(self))
319    #return str(self.value) + '\t# '+self.__class__.__name__ + 'id: '+ str(id(self))
320                   
321
322                   
323
324class store_name( Item_Storage_String ):
325 
326  def setValue(self,value):
327    logger.debug( self.__class__.__name__ +':' + 'called self.value with \''+ unicode(value) + '\'')   
328    if value != None  and value != 0:
329      if type(value) == str:
330        value = value.strip('"')
331      else:
332        value = str(value)
333      self.value = '"' + value.strip('"') + '"'
334    else:
335      self.value = value
336    logger.debug("self.value is now " + unicode(self) )
337                           
338
339class store_str( store_name ):
340  pass                         
341
342class store_time( Item_Storage ):                         
343  def __init__(self,val):
344    self.value = val
345    self.comment = ''
346    self.possiblevalues = []  # what values are possible here ?
347    self.parentitem = None
348   
349  def __str__(self):
350    #TODO do this in a nicer way without a catch-all try-except
351    if self.value is None:
352      return str(self.value)
353    outstring = ''
354    for mult in ["years", "quarters" ,"months" ,"weeks", "days","hours","minutes","seconds"]:
355      if self.value % timemultiplicators[mult] == 0:
356        outstring = "%d %s " % (self.value/timemultiplicators[mult], mult)
357        return outstring   
358    return outstring 
359   
360  def setParentItem(self,parentItem):
361    self.parentitem = parentItem
362   
363  def setValue(self,value):
364    logger.debug( self.__class__.__name__ +':' + 'called self.value with \''+ str(value) + '\'')   
365    self.value = self.__parse_timeinput__(value)
366    logger.debug("self.value is now" + str(self) )
367 
368  def __partNumberKeywords__(self,string):
369    '''
370    inserts a space between numbers and keywords if there is none
371    '''
372    return re.sub(r'([0-9](?=[A-Za-z])|[A-Za-z](?=[0-9]))', "\\1 ", string)
373    #s = ''
374    #for match in RXP_NRTEXT.finditer(string):
375    #  #print string,match.groups()
376    #  s += ' '.join(match.groups()) + ' '
377    #return s
378 
379  def __parse_timeinput__(self,timestring):
380    '''
381    parses the input string and sets the value to the resulting seconds
382    '''
383    timeval = 0
384    if timestring is None or timestring == 'None':
385      return None
386    multiplicator = 1
387    # search for x*x*X*X...
388    index = timestring.find('*')
389    if index != -1:
390      timeval = eval(timestring)
391      #print timeval
392      return timeval
393      #timestring = str(timeval)
394     
395   
396    if  timestring.isdigit():
397      return int(timestring)
398   
399   
400    # search for multiple pairs like "3 seconds 4 days"
401    timestring = self.__partNumberKeywords__(timestring)
402    valueUnitPairs = timestring.split()
403    valueUnitPairs.reverse()
404    #print valueUnitPairs
405    #print timestring+'<'
406    if len(valueUnitPairs)%2:
407      logger.error(valueUnitPairs)
408      logger.error("There should always be a pair of value-unit\n maybe you forgot a space between value and unit?")
409    while len(valueUnitPairs) > 1:
410      vustr = str(valueUnitPairs.pop()) + ' ' + str(valueUnitPairs.pop())
411      for cut in (range(8)):
412        if cut == 0: # extra, as range -0 leads to nothing instead of giving the whole string
413          cut = -8
414        for mult in ('months','seconds',
415                 'mins','minutes','hours',
416                 'days','weeks','quarters',
417                 'years'):        #,'n'     
418          index = vustr.lower().find(mult[:-cut])
419          #print mult[:-cut],vustr
420          if  index != -1 and len(mult[:-cut])>0:
421            multiplicator = timemultiplicators[mult]
422            tmpstring = vustr.replace(mult[:-cut],'')
423            #print mult[:-cut],vustr
424            vustr = tmpstring
425         
426      timeval += float(vustr) * multiplicator   
427      #print "%s -> %d " % (vustr,timeval)
428   
429   
430    return int(timeval)
431
432
433
434
435class store_bool( Item_Storage ):     
436  #pass
437  '''
438  also base class for store_bit
439  '''
440 
441  def __init__(self,val):
442    Item_Storage.__init__(self, val)
443    self.setValue(val)
444   
445  def setValue(self,value):
446    logger.debug( self.__class__.__name__ +':' + 'called self.value with \''+ str(value) + '\' type: ' + str(type(value)))   
447    if type(value) is str:
448      logger.debug('value was string')
449      if value.lower() == 'yes' or value.lower() == '1':
450        self.value = True
451      else:
452        self.value = False   
453       
454    elif type(value) is int: # type int
455      logger.debug('value was int')
456      if value == 1:
457        self.value = True
458      else:
459        self.value = False
460       
461    elif type(value) is bool: # type int
462      logger.debug('value was bool')
463      self.value = value   
464    else:
465      logger.error( "value must be <int> or <str>, but is " + str(type(value)) )
466
467    logger.debug('value is now ' + str(self.value))
468 
469  def __str__(self):
470    if self.comment != '':
471      comment = "\t# " + self.comment
472    else:
473      comment = ''
474    if self.value == True:
475      #return 'Yes'#+ '\t# '+self.__class__.__name__ + 'id: '+ str(id(self))
476      return 'Yes'  + comment  #+self.__class__.__name__ + 'id: '+ str(id(self))
477   
478    else:
479      #return 'No' #+ '\t# '+self.__class__.__name__  + 'id: '+ str(id(self))
480      return 'No'  + comment  #+self.__class__.__name__  + 'id: '+ str(id(self))   
481
482class store_bit( store_bool ):
483  pass       
484
485
486class store_dir( store_name ):     
487  pass
488
489
490class store_alist_str( Item_Storage_String ):
491  pass     
492
493class store_password( store_name ):
494  pass                               
495
496class store_res( Item_Storage_String ):
497  pass                         
498
499
500
501class store_acl( Item_Storage_String ):
502   
503  def __init__(self,val):
504    self.value = val
505    self.comment = ''
506    self.possiblevalues = []  # what values are possible here ?
507    self.parentitem = None
508    self.ACLDict = {}
509   
510  def __str__(self):
511    return str(self.value)
512 
513   
514  def setParentItem(self,parentItem):
515    self.parentitem = parentItem
516   
517  def setValue(self,value):
518    logger.debug( self.__class__.__name__ +':' + 'called self.setvalue with \''+ str(value) + '\'')
519    self.value = value
520    self.__Value2ACLDict__()
521    self.__ACLDict2value__()
522    #self.__parse_ACLinput__(value)
523    #self.ACLDict2value()
524    logger.debug("self.value is now >%s<" %( self.value ))
525 
526  def __Value2ACLDict__(self):
527    '''
528    parses the input string and sets the ACL Dictionary
529    '''
530    #print "parsing the following value: %s  " % (self.value)
531 
532    if self.value is None or self.value == 'None' or self.value == u'' or self.value == '':
533      for k in self.ACLDict.keys():
534        self.ACLDict[k]= False
535      self.value = None
536    else:
537      for acl in self.value.replace(' ','').split(','):
538        self.ACLDict[acl]=True
539    self.__ACLDict2value__()
540    #print self.ACLDict
541   
542 
543  def __ACLDict2value__(self):
544    '''
545    reads the acl Dictionary and produces the correct output in the value field
546    '''
547    s = ''
548
549    for msg,val in self.ACLDict.iteritems():   
550      if val == True:
551        s += '%s,' % (msg)
552    #self.setValue(s[:-1])
553    #self.value = s[:-1]
554    if (len(s[:-1])) == 0:
555      self.value = None
556    else:
557      self.value = s[:-1]# cut last comma
558   
559
560 
561
562
563
564
565
566class store_int32( Item_Storage ):
567  pass                           
568
569class store_addresses_port( Item_Storage ):
570  pass                                     
571
572class store_addresses( Item_Storage ):
573  pass                                     
574
575class store_addresses_address( Item_Storage ):
576  pass
577 
578class store_inc( Item_Storage ):
579  pass                         
580
581class store_migtype( Item_Storage ):
582 
583  def __init__(self,val):
584    Item_Storage.__init__(self, val)
585    self.possiblevalues = migtypes             
586    if val == 0:
587      Item_Storage.setValue(self,  'smallestvolume')   
588   
589class store_short_runscript( Item_Storage ):
590  pass                                     
591
592class store_runscript( Item_Storage ):
593  pass                               
594
595class store_alist_res( Item_Storage_String ):
596  pass                               
597
598class store_jobtype( Item_Storage ):
599 
600  def __init__(self,val):
601    Item_Storage.__init__(self, val)
602    self.possiblevalues = jobtypes
603    if val == 0:
604      Item_Storage.setValue(self,  'backup')
605
606class store_replace( Item_Storage ):
607 
608  def __init__(self,val):
609    Item_Storage.__init__(self, val)
610    self.possiblevalues = ReplaceOptions
611    if val == 0:
612      Item_Storage.setValue(self,  'always')
613
614class store_level( Item_Storage ):
615 
616  def __init__(self,val):
617    Item_Storage.__init__(self, val)
618    self.possiblevalues = joblevels
619    if val == 0:
620      Item_Storage.setValue(self,  'full')   
621
622
623class store_size64( Item_Storage ):
624  def __init__(self,val):
625    self.value = val
626    self.comment = ''
627    self.possiblevalues = []  # what values are possible here ?
628    self.parentitem = None
629   
630  def __str__(self):
631    #TODO do this in a nicer way without a catch-all try-except
632    if self.value is None:
633      return str(self.value)
634    outstring = ''
635    for mult in ["gb","mb","kb","g","m","k"]:
636      if self.value % datamultiplicators[mult] == 0:
637        outstring = "%d %s " % (self.value/datamultiplicators[mult], mult)
638        return outstring   
639    return str(self.value)
640   
641    #outstring = ''
642    #for mult in ["years", "quarters" ,"months" ,"weeks", "days","hours","minutes","seconds"]:
643    #  if self.value % timemultiplicators[mult] == 0:
644    #    outstring = "%d %s " % (self.value/timemultiplicators[mult], mult)
645    #    return outstring   
646    #return outstring 
647   
648  def setParentItem(self,parentItem):
649    self.parentitem = parentItem
650   
651  def setValue(self,value):
652    logger.debug( self.__class__.__name__ +':' + 'called self.value with \''+ str(value) + '\'')   
653    self.value = self.__parse_datainput__(value)
654    logger.debug("self.value is now" + str(self) )
655 
656  def __parse_datainput__(self,datastring):
657    '''
658    parses the input string and sets the value to the resulting seconds
659    '''
660    if datastring is None or datastring == 'None':
661      return None
662   
663    datastring = str(datastring).lower()
664   
665    multiplicator = 1
666    dstring = datastring
667    for mult in ["gb","mb","kb","g","m","k"]:
668        index = dstring.lower().find(mult)
669        if  index != -1:
670          multiplicator = datamultiplicators[mult]
671          tmpstring = datastring.replace(mult,'')
672          #print datastring
673          dstring = tmpstring
674    dataval = float(dstring) * multiplicator   
675    return dataval
676   
677       
678    # search for x*x*X*X...
679    #index = timestring.find('*')
680    #if index != -1:
681    #  timeval = eval(timestring)
682    #  print timeval
683    #  timestring = str(timeval)#####
684
685    #print timestring+'<'
686    #for mult in timemultiplicators:
687    #  for cut in (range(8)):
688    #    if cut == 0: # extra, as range -0 leads to nothing instead of giving the whole string
689    #      cut = -8
690    #    index = timestring.find(mult[:-cut])
691    #    if  index != -1 and len(mult[:-cut])>0:
692    #      multiplicator = timemultiplicators[mult]
693    #      tmpstring = timestring.replace(mult[:-cut],'')
694    #      #print timestring
695    #      timestring = tmpstring
696    #timeval = float(timestring) * multiplicator   
697    #return timeval
698
699
700class store_strname( Item_Storage_String ):
701  pass
702
703class store_label( Item_Storage_String ):
704  pass
705
706class store_actiononpurge( Item_Storage ):
707  pass
708
709class store_runscript_bool( Item_Storage ):
710  pass
711
712class store_runscript_cmd( Item_Storage ):
713  pass
714
715class store_runscript_target( Item_Storage ):
716  pass
717
718class store_runscript_when( Item_Storage ):
719  pass
720
721class store_run( Item_Storage_String ):
722  def __init__(self,val):
723    self.value = val
724    logger.debug('store_run: called with ' + str(val))
725    self.runentry = scheduleparser.RunEntry(val)
726    self.possiblevalues = []
727   
728  def setValue(self,value):
729    self.runentry.setValue(value)
730    # set value to None if resutling string contains only whitespace,
731    # in order to have the default value and not print it
732    if len(str(self.runentry).strip()) == 0:
733      self.value = None
734    else:
735      self.value = str(self.runentry)
736   
737     
738  def __str__(self):
739    self.value = str(self.runentry) # update value string
740    return str(self.runentry)
741
742class store_device( Item_Storage_String ):
743  pass
744
745class store_maxblocksize( Item_Storage ):
746  pass
747
748class store_devtype( Item_Storage ):
749  pass
750
751
752
753class store_msgs( Item_Storage ):
754 
755  def __init__(self,val):
756    self.value = val
757    self.comment = ''
758    self.possiblevalues = []  # what values are possible here ?
759    self.parentitem = None
760    self.messageDict = {}
761    self.parameter = None
762    self.setValue(val)
763   
764  def __str__(self):
765    s = ''
766     
767    if self.parameter is not None:
768      s += self.parameter + ' = '
769     
770    for msg,val in self.messageDict.iteritems():
771      if msg == 'all':
772        if self.messageDict['all']:
773          s += 'all,'
774        continue
775   
776      if self.messageDict['all']:
777        if val == False:
778          s += '!%s,' % (msg)
779      else:# not all, so write all that are true
780        if val == True:
781          s += '%s,' % (msg)
782    return s[:-1] # cut last comma
783 
784  def getParameter(self):
785    '''
786    this returns the target of the messages entry
787    '''
788    return self.parameter
789 
790  def setParameter(self, parameter):
791    self.parameter = parameter
792   
793  def setParentItem(self,parentItem):
794    self.parentitem = parentItem
795   
796  def setValue(self,value):
797    logger.debug( self.__class__.__name__ +':' + 'called self.setvalue with \''+ str(value) + '\'')   
798    self.value = self.__parse_messageinput__(value)
799    logger.debug("self.value is now" + str(self) )
800 
801  def __parse_messageinput__(self,msgsstring):
802    '''
803    parses the input string and sets the value
804    '''
805    if msgsstring is None or msgsstring == 'None':
806      self.parameter = None
807      return None
808   
809    splitted = msgsstring.split('=')   # do we have a message string with parameter
810    if len(splitted) > 1:                 # (like root@localhost = all, !skipped)
811      self.parameter = splitted[0].rstrip(' ')
812      msgsstring = splitted[1]
813       
814         
815    messagestring = msgsstring.lower()
816    for message in msg_types:
817      self.messageDict[message] = None
818      index = messagestring.find('!'+message)
819      if  index != -1:
820        logger.debug( "found NOT %s" % (message) )
821        self.messageDict[message] = False 
822      else:
823        index = messagestring.find(message)
824        if  index != -1:
825          logger.debug("found %s" % (message))
826          self.messageDict[message] = True 
827    return self.__str__()
828
829 
830 
831 
832 
833class store_opts( Item_Storage ):
834  def __init__(self,val):
835    Item_Storage.__init__(self, val)
836    #if val == 0:
837    #  Item_Storage.setValue(self,  'full')
838  def setParentItem(self,parentItem):
839    self.parentitem = parentItem
840    try:
841      self.possiblevalues =   FS_option_kw[self.parentitem.name]
842      logger.debug(self.possiblevalues)
843    except:
844      logger.error('keyerror in FS_option_kw for ' + self.parentitem.name)
845     
846
847class store_drivetype( Item_Storage ):
848  pass
849
850class store_regex( Item_Storage ):
851  pass
852
853class store_wild( Item_Storage ):
854  pass
855
856class store_fstype( Item_Storage ):
857  pass
858
859class store_base( Item_Storage ):
860  pass
861
862class store_plugin( Item_Storage ):
863  pass
864
865class store_excludedir( Item_Storage ):
866  pass
867
868class store_fname( store_name ):
869  pass
870
871
872class options_res( Item_Storage ):
873  pass
874
875
876class store_plugin_name( Item_Storage ):
877  pass
878
879
880
881if __name__ == "__main__":
882  #msgsstore = store_msgs("root@localhost = mount")
883  tmp = store_time("1 hour")
884 
885  #for mult in ('months','seconds','n',
886  #               'mins','minutes','hours',
887  #               'days','weeks','quarters',
888  #               'years'):   
889  #  for val in range(9):   
890  #    value = str(val) + ' ' + mult
891  #    tmp.setValue(value)
892  #    print str(value) + '->'  +  str(tmp)
893  # 
894  tmp.setValue("1month30minutes12seconds")
895  print tmp
Note: See TracBrowser for help on using the repository browser.