Package Gnumed :: Package pycommon :: Module gmConfigCommon
[frames] | no frames]

Source Code for Module Gnumed.pycommon.gmConfigCommon

  1  """GNUmed: Mid-level configuration editor object. 
  2   
  3  Theory of operation: 
  4   
  5  ConfigSourceDB/File holds config data (read from backend or file) and related 
  6  config definitions. Definitions are retrieved automatically from a given config 
  7  definition file (if available). See _defaultDefSourceTable below for standard file 
  8  names. 
  9   
 10  First get a list of available config parameters through getAllParamNames (returns 
 11  names + metadata), get the values using GetConfigData, change, check for validity 
 12  using isValid (if definition data and parameter definition is available) and  
 13  set data using SetConfigData. 
 14  License: GNU Public License  
 15  """ 
 16  #================================================================== 
 17  # $Source: /home/ncq/Projekte/cvs2git/vcs-mirror/gnumed/gnumed/client/pycommon/gmConfigCommon.py,v $ 
 18  __version__ = "$Revision: 1.10 $" 
 19  __author__ = "H.Berger,K.Hilbert" 
 20   
 21  import sys, os, string, types, pickle 
 22   
 23  from Gnumed.pycommon import gmCfg, gmPG2 
 24   
 25  _log = gmLog.gmDefLog 
 26  if __name__ == '__main__': 
 27          _log.SetAllLogLevels(gmLog.lData) 
 28          _ = lambda x:x 
 29   
 30  _log.Log(gmLog.lData, __version__) 
 31  _cfg = gmCfg.gmDefCfgFile 
 32  _defaultDefSourceTable = { 
 33          'DB:CURRENT_USER_CURRENT_WORKPLACE': 'config-definitions/DBDefault.definitions', 
 34          'DB:CURRENT_USER_DEFAULT_WORKPLACE' : 'config-definitions/DBDefault.definitions', 
 35          'DB:DEFAULT_USER_CURRENT_WORKPLACE' : 'config-definitions/DBDefault.definitions', 
 36          'DB:DEFAULT_USER_DEFAULT_WORKPLACE' : 'config-definitions/DBDefault.definitions', 
 37          'gnumed.conf': 'config-definitions/gnumed.conf.definitions' 
 38  } 
 39   
 40  ############################################################################### 
41 -class ConfigSource:
42 """Base class for interface to access config data and definitions on a single 43 configuration source (config file, user/workplace specific backend data 44 collection. 45 The source name will be used to retrieve the config definitions from 46 a config definition source (file, DB) automatically. 47 """ 48 49 _DefinitionSourceTable = None 50
51 - def __init__(self,aSourceType=None,aSourceName=None,aDataSource=None):
52 self.mSourceType = aSourceType 53 self.mSourceName = aSourceName 54 self.mDataSource = aDataSource 55 56 if ConfigSource._DefinitionSourceTable is None: 57 ConfigSource._DefinitionSourceTable=self.__getDefinitionSourceTable() 58 59 try: 60 DefinitionSource = ConfigSource._DefinitionSourceTable[self.mSourceName] 61 self.mDefinitionSource = ConfigDefinition(DefinitionSource) 62 except: 63 _log.Log(gmLog.lWarn, "No definition source found for %s" % self.mSourceName) 64 self.mDefinitionSource = None
65 66 #--------------------------------------------------------------------- 67 # TODO : get definition source table from cfg file if available 70 71 #------------------------------------------------------------------------
72 - def getParamType(self, aParam = None):
73 """ get type of parameter value """ 74 75 # try to get the type from config definitions 76 # if this fails, get last known type from config data dict 77 definitionType = None 78 79 if not self.mDefinitionSource is None: 80 definitionName = self.mDataSource.getRawName(aParam) 81 definitionType = self.mDefinitionSource.getParamType(definitionName) 82 83 if not definitionType is None: 84 mType = definitionType 85 else: 86 mType = self.mDataSource.getParamType(aParam) 87 88 return mType
89 90 #------------------------------------------------------------------------
91 - def castType(self, aParam = None, aValue=None):
92 """ cast type of entered parameter value to the previously existing type.""" 93 94 castType = self.getParamType(aParam) 95 if castType == 'str_array': 96 castedVal = string.split(aValue,'\n') 97 if not type(castedVal) is types.ListType: 98 castedVal = [str(castedVal)] 99 elif castType == 'numeric': 100 if not type(eval(aValue)) in (types.IntType, types.FloatType, types.LongType): 101 castedVal = None 102 else: 103 castedVal = eval(aValue) 104 elif castType == 'string': 105 castedVal = str(aValue) 106 107 return castedVal
108 109 #----------------------------------------------------------------------
110 - def getDescription(self, aParam=None):
111 """ 112 Get parameter description either from config definition or from config data 113 """ 114 # if no parameter definition is available, get definition from data 115 # source 116 definitionName = self.mDataSource.getRawName(aParam) 117 description = None 118 if not self.mDefinitionSource is None: 119 description = self.mDefinitionSource.getParamDescription(definitionName) 120 121 if description is None: 122 description = self.mDataSource.getParamDescription(aParam) 123 124 return description
125 126 # here come the wrapper functions that link to config data and definition 127 # objects 128 #---------------------------------------------------------------------
129 - def getAllParamNames(self):
130 """ 131 Get all parameter names from backend or a file. 132 Returns dict of names + metadata. 133 format: 134 dict {'name1': [namepart_2,namepart_1,owner,type,description], 135 'name2': [option,group,owner,type,description],...} 136 usually the full name is a composition of namepart_1 +_2, 137 but don't rely on the order - it depends on whether you get 138 data from DB or file. type is the type as found in the data 139 (one of 'string', 'string_arr' or 'numeric'). description is the 140 description supplied with the data, not the one given in the 141 parameter definition file ! Use getDescription() to get the right 142 one. 143 """ 144 if not self.mDataSource is None: 145 return self.mDataSource.getAllNames()
146 #---------------------------------------------------------------------
147 - def setConfigData(self,aParam,aValue):
148 """ 149 Set config data for a aParam to aValue. 150 """ 151 return self.mDataSource.SetConfigData(aParam,aValue)
152 #---------------------------------------------------------------------
153 - def getConfigData(self,aParam):
154 """ 155 Get config data for a aParam. 156 """ 157 return self.mDataSource.GetConfigData(aParam)
158 159 #---------------------------------------------------------------------
160 - def addConfigParam(self,aParam,aType,aValue,aDescription):
161 """ 162 Adds config new config parameter. 163 """ 164 return self.mDataSource.AddConfigParam(aParam,aType,aValue,aDescription)
165 #---------------------------------------------------------------------
166 - def getRawName(self,aParam):
167 """Get config data for a aParam.""" 168 return self.mDataSource.getRawName(aParam)
169 #---------------------------------------------------------------------
170 - def hasDefinition(self):
171 """ return true if config definition object is available""" 172 return ( not self.mDefinitionSource is None)
173 174 #---------------------------------------------------------------------
175 - def hasParameterDefinition(self,aParam):
176 """ 177 Returns true if config definition is available for this 178 parameter. 179 """ 180 return self.mDefinitionSource.hasParameter(aParam)
181 182 #---------------------------------------------------------------------
183 - def isValid(self,aParam,aValue):
184 """ 185 Returns true if aValue matches config definition for this 186 parameter. 187 """ 188 return self.mDefinitionSource.isValid(aParam,aValue)
189 190 191 ###############################################################################
192 -class ConfigSourceDB(ConfigSource):
193 """Interface to access config data and definitions in a single 194 configuration user/workplace specific backend data collection. 195 """
196 - def __init__(self, aSourceName=None,aUser = None, aWorkplace = 'xxxDEFAULTxxx'):
197 try: 198 mConfigDataSource = ConfigDataDB(aUser,aWorkplace) 199 except: 200 mConfigDataSource = None 201 202 ConfigSource.__init__(self,"DB",aSourceName,mConfigDataSource)
203 204 205 ###############################################################################
206 -class ConfigSourceFile(ConfigSource):
207 """ 208 Interface to access config data and definitions in a config file. 209 """
210 - def __init__(self, aSourceName=None,aFileName=None):
211 try: 212 mConfigDataSource = ConfigDataFile(aFileName) 213 except: 214 mConfigDataSource = None 215 216 ConfigSource.__init__(self,"FILE",aSourceName,mConfigDataSource)
217 218
219 - def GetFullPath(self):
220 if not self.mDataSource is None: 221 return self.mDataSource.GetFullPath()
222 223 ###############################################################################
224 -class ParameterDefinition:
225 """Describes a gnumed configuration parameter. 226 """
227 - def __init__(self,aParamName = None,aParamType = None,aValidValsList = None,aParamDescription = None):
228 self.mName = aParamName 229 self.mType = aParamType 230 self.mDescription = aParamDescription 231 # perhaps make this a class <validator>, too ? 232 # - one method: bool isValid() 233 # - derived classes for: 234 # validator -> string -> font 235 # validator -> string -> color 236 # validator -> numeric -> range 237 # ... 238 self.mValidVals = aValidValsList
239 240 #---------------------------------------------------------------------
241 - def isValid(self,aValue):
242 if self.mType == "string": 243 return self.__isString(aValue) 244 elif self.mType == "str_array": 245 return self.__isStringArray(aValue) 246 elif self.mType == "numeric": 247 return self.__isNumeric(aValue) 248 else: 249 _log.Log (gmLog.lPanic, "isValid %s - %s %s" % (self.mName, self.mType, aValue)) 250 return 0
251 252 #---------------------------------------------------------------------
253 - def __isString(self,aValue):
254 if type(aValue) == types.StringType or type (s) == types.UnicodeType: 255 if self.mValidVals is None: 256 return 1 257 elif str(aValue) in (self.mValidVals): 258 return 1 259 return 0
260 261 #---------------------------------------------------------------------
262 - def __isStringArray(self,aValue):
263 # value must be a list and all elements must be strings 264 if type(aValue) == types.ListType: 265 for s in (aValue): 266 if not (type(s) == types.StringType or type (s) == types.UnicodeType): 267 return 0 268 return 1 269 return 0
270 271 #---------------------------------------------------------------------
272 - def __isNumeric(self,aValue):
273 if type(aValue) in (types.IntType, types.FloatType, types.LongType): 274 if self.mValidVals is None: 275 return 1 276 elif str(aValue) in (self.mValidVals): 277 return 1 278 return 0
279 280 ############################################################################### 281 # IDEAS: if no config definition is available, we should make the 282 # data read-only by default, and only allow change after an explicit warning 283 # TODO : almost all
284 -class ConfigDefinition:
285 """ holds config definitions read from a file/DB. 286 this will contain: 287 a) config parameter names 288 b) config parameter description (optional) 289 c) config parameter type 290 d) config parameter valid values (if type is select_from_list) 291 e) config information version (must match the version used in ConfigData) 292 """ 293
294 - def __init__(self, aDefinitionSource=None):
295 # get queries from configuration source (currently only files are supported) 296 297 self.__mParameterDefinitions = {} 298 self.__mVersion = None 299 300 if aDefinitionSource is None: 301 _log.Log(gmLog.lWarn, "No configuration definition source specified") 302 # we want to return an error here 303 # in that case we'll have to raise an exception... can't return 304 # anything else than None from an __init__ method 305 raise TypeError, "No configuration definition source specified !" 306 else: 307 self.__mDefinitionSource = aDefinitionSource 308 if not self.__getDefinitions(): 309 raise IOError, "cannot load definitions"
310 311 #------------------------------------------------------------------------
312 - def hasParameter(self, aParameterName = None):
313 return self.__mParameterDefinitions.has_key(aParameterName)
314 315 #------------------------------------------------------------------------
316 - def isValid(self,aParameterName=None,aValue=None):
317 if self.hasParameter(aParameterName): 318 return self.__mParameterDefinitions[aParameterName].isValid(aValue) 319 else: 320 return 0
321 322 #------------------------------------------------------------------------
323 - def getParamType(self, aParameterName = None):
324 if self.hasParameter(aParameterName): 325 return self.__mParameterDefinitions[aParameterName].mType
326 327 #------------------------------------------------------------------------
328 - def getParamDescription(self, aParameterName = None):
329 if self.hasParameter(aParameterName): 330 return self.__mParameterDefinitions[aParameterName].mDescription
331 332 #------------------------------------------------------------------------
333 - def __getDefinitions(self):
334 """get config definitions""" 335 336 # open configuration definition source 337 try: 338 cfgDefSource = gmCfg.cCfgFile(aFile = self.__mDefinitionSource, \ 339 flags=gmCfg.cfg_SEARCH_STD_DIRS | gmCfg.cfg_IGNORE_CMD_LINE) 340 # handle all exceptions including 'config file not found' 341 except: 342 exc = sys.exc_info() 343 _log.LogException("Unhandled exception while opening config file [%s]" % self.__mDefinitionSource, exc,verbose=0) 344 return None 345 346 cfgData = cfgDefSource.getCfg() 347 groups = cfgDefSource.getGroups() 348 349 if not '_config_version_' in (groups): 350 _log.Log(gmLog.lWarn, "No configuration definition version defined.") 351 _log.Log(gmLog.lWarn, "Matching definitions to config data is unsafe.") 352 _log.Log(gmLog.lWarn, "Config data will be read-only by default.") 353 self.mVersion = None 354 else: 355 version = cfgDefSource.get('_config_version_', "version") 356 # we don't check for type in order to allow for versions like '1.20.1b' 357 self.__mVersion = version 358 _log.Log(gmLog.lInfo, "Found config parameter definition version %s in %s" % (version,self.__mDefinitionSource)) 359 360 361 # every group holds one parameter description 362 # group name = parameter name 363 for paramName in groups: 364 # ignore config version group 365 if paramName == '_config_version_': 366 continue 367 368 paramType = cfgDefSource.get(paramName, "type") 369 if paramType is None: 370 continue 371 372 # parameter description - might differ from that stored 373 # in backend tables (cfg_template) 374 paramDescription = cfgDefSource.get(paramName, "description") 375 if paramDescription is None: 376 continue 377 378 validValuesRaw = None 379 # if valid value list is supplied, get it 380 if "validvalue" in (cfgDefSource.getOptions(paramName)): 381 validValuesRaw = cfgDefSource.get(paramName, "validvalues") 382 # transform valid values to a list 383 validVals = None 384 if not validValuesRaw is None: 385 if type(validValuesRaw) == types.ListType: 386 validVals = validValuesRaw 387 388 # add new entry to parameter definition dictionary 389 self.__mParameterDefinitions 390 self.__mParameterDefinitions[paramName] = ParameterDefinition(paramName,paramType,validVals,paramDescription) 391 return 1
392 393 ############################################################################### 394 # TODO: 395 # -handle backend data modifications using backend notification 396 # -method to change/add new parameters 397
398 -class ConfigData:
399 """ 400 Base class. Derived classes hold config data for a particular 401 backend user/workplace combination, config file etc. 402 this will contain: 403 a) config parameter names 404 b) config parameter values 405 c) config information version (must match the version used in ConfigDefinition) 406 """ 407
408 - def __init__(self, aType = None):
409 self.type = aType 410 self.mConfigData = {}
411 412 # pure virtual methods
413 - def GetAllNames(self):
414 pass
415
416 - def GetConfigData(self):
417 pass
418
419 - def SetConfigData(self):
420 pass
421
422 - def getRawName(self):
423 pass
424
425 - def AddConfigParam(self):
426 pass
427 428 #---------------------------------------------------------------------
429 - def getParamType(self,aParameterName = None):
430 """ 431 Returns the parameter type as found in the data source. 432 """ 433 try: 434 return self.mConfigData[aParameterName][3] 435 except KeyError: 436 # is it possible to have a parameter without type ?? 437 # TODO 438 return None
439 440 #---------------------------------------------------------------------
441 - def getParamDescription(self,aParameterName = None):
442 """ 443 Returns the parameter type as found in the data source. 444 """ 445 try: 446 return self.mConfigData[aParameterName][4] 447 except KeyError: 448 return None
449 450 451 #--------------------------------------------------------------------------
452 -class ConfigDataDB(ConfigData):
453 """ 454 Class that holds config data for a particular user/workplace pair 455 """ 456 # static class variables that hold links to backend and gmCfg 457 # this will be shared by all ConfigDataDB objects 458 # this assumes that there will always be only one backend config source 459 _dbcfg = None 460
461 - def __init__(self, aUser = None, aWorkplace = 'xxxDEFAULTxxx'):
462 """ Init DB connection""" 463 ConfigData.__init__(self,"DB") 464 465 # connect to config database 466 if ConfigDataDB._dbcfg is None: 467 ConfigDataDB._dbcfg = gmCfg.cCfgSQL() 468 469 self.mUser = aUser 470 self.mWorkplace = aWorkplace
471 #---------------------------------------------------------------------
472 - def GetConfigData(self, aParameterName = None):
473 """ 474 Gets Config Data for a particular parameter. 475 Returns parameter value. 476 """ 477 try: 478 # print "param name:", aParameterName 479 name=self.mConfigData[aParameterName][0] 480 cookie = self.mConfigData[aParameterName][1] 481 # print "name:", name 482 # print "cookie.", cookie 483 result = ConfigDataDB._dbcfg.get2 ( 484 workplace=self.mWorkplace, 485 # self.mUser, 486 cookie = cookie, 487 option = name, 488 bias = 'user' 489 ) 490 except: 491 _log.Log(gmLog.lErr, "Cannot get parameter value for [%s]" % aParameterName ) 492 return None 493 return result
494 495 #---------------------------------------------------------------------
496 - def SetConfigData(self, aParameterName, aValue):
497 """ 498 Sets Config Data for a particular parameter. 499 """ 500 try: 501 name=self.mConfigData[aParameterName][0] 502 cookie = self.mConfigData[aParameterName][1] 503 result=ConfigDataDB._dbcfg.set ( 504 workplace = self.mWorkplace, 505 # user = self.mUser, 506 cookie = cookie, 507 option = name, 508 value = aValue, 509 ) 510 except: 511 _log.Log(gmLog.lErr, "Cannot set parameter value for [%s]" % aParameterName ) 512 return None 513 return 1
514 #--------------------------------------------------------------------- 515 # aType is not used so far. Do we need it ? 516 # TODO: maybe we could combine that with SetConfigData (the low level methods in gmCfg do add/update, anyways)
517 - def AddConfigParam(self, aParameterName, aType = None ,aValue=None,aDescription = None):
518 """ 519 Adds a new config parameter. 520 Note: You will have to re-read the cache (call GetAllNames()) 521 in order to change this parameter afterwards. 522 """ 523 # make sure that the pameter does not exist yet 524 if self.mConfigData.has_key(aParameterName): 525 return None 526 527 # now we have to split the parameter name into 528 # option and cookie part 529 530 pNameParts = string.split(aParameterName,".") 531 # check if we have a cookie 532 if pNameParts[-1][0] == '_': 533 cookie = pNameParts[-1][1:] 534 option = string.join(pNameParts[:-1],".") 535 else: 536 cookie = None 537 option = aParameterName 538 539 # print "[%s, %s]" % (cookie, option) 540 if option is None: 541 return None 542 # now actually write the new parameter 543 try: 544 result=ConfigDataDB._dbcfg.set ( 545 workplace = self.mWorkplace, 546 # user = self.mUser, 547 cookie = cookie, 548 option = option, 549 value = aValue, 550 ) 551 except: 552 _log.Log(gmLog.lErr, "Cannot set parameter value for [%s]" % aParameterName ) 553 return None 554 # now we should re-read the name cache in order to have 555 # consistent data. Since we wont signal the frontend, we will 556 # have to do this manually in the fronend 557 558 return 1
559 #---------------------------------------------------------------------
560 - def getAllNames(self):
561 """ 562 fetch names and parameter data from backend. Returns list of 563 parameter names where cookie and real name are concatenated. 564 Refreshes the parameter cache, too. 565 """ 566 result=ConfigDataDB._dbcfg.getAllParams(self.mUser,self.mWorkplace) 567 if not result: 568 return None 569 else: 570 # gmCfg.getAllParams returns name,cookie, owner, type and description 571 # of a parameter. 572 # We combine name + cookie to one single name. If cookie == 'xxxDEFAULTxxx' 573 # we set the last part of the name to "" (an empty part). This 574 # must processed by the ConfigTree so that the empty part is not 575 # displayed. If the cookie is something else, we mark the cookie part 576 # by a leading "._" 577 mParamNames = [] 578 # for param in (result): why??? 579 for param in result: 580 name = param[0] 581 cookie = param[1] 582 if cookie == 'xxxDEFAULTxxx': 583 cookie_part = "" 584 else: 585 cookie_part = "._%s" % cookie 586 587 newName = name + cookie_part 588 # store data for every parameter in mConfigData 589 self.mConfigData[newName]=param 590 # add new name to list 591 mParamNames.append(newName) 592 #DEBUG 593 # _log.Log (gmLog.lData, "%s" % self.mConfigData) 594 595 return mParamNames
596 597 #---------------------------------------------------------------------
598 - def getRawName(self,aParameterName = None):
599 """ 600 Returns the parameter name without possible cookie part(s). 601 Needed to indentify matching config definition entry. 602 """ 603 try: 604 return self.mConfigData[aParameterName][0] 605 except KeyError: 606 return None
607 608 #--------------------------------------------------------------------------
609 -class ConfigDataFile(ConfigData):
610 """ 611 Class that holds config data for a particular config file 612 """
613 - def __init__(self, aFilename = None):
614 """ Init config file """ 615 ConfigData.__init__(self,"FILE") 616 617 self.filename = aFilename 618 self.__cfgfile = None 619 self.fullPath = None 620 621 # open config file 622 try: 623 self.__cfgfile = gmCfg.cCfgFile(aFile = self.filename) 624 # this is a little bit ugly, but we need to get the full name of the 625 # file because this depends on the installation/system settings 626 # if no absolute path was specified, we get the config file gnumed 627 # would find first which is what we want usually 628 self.fullPath = self.__cfgfile.cfgName 629 630 except: 631 _log.LogException("Can't open config file !", sys.exc_info(), verbose=0) 632 raise ConstructorError, "ConfigDataFile: couldn't open config file"
633 634 #---------------------------------------------------------------------
635 - def GetFullPath(self):
636 """ returns the absolute path to the config file in use""" 637 return self.fullPath
638 639 #---------------------------------------------------------------------
640 - def GetConfigData(self, aParameterName = None):
641 """ 642 Gets Config Data for a particular parameter. 643 Returns parameter value. 644 """ 645 name=self.mConfigData[aParameterName][0] 646 group = self.mConfigData[aParameterName][1] 647 try: 648 result=self.__cfgfile.get(group,name) 649 except: 650 _log.Log(gmLog.lErr, "Cannot get parameter value for [%s]" % aParameterName ) 651 return None 652 return result
653 654 #---------------------------------------------------------------------
655 - def SetConfigData(self, aParameterName = None, aValue = None):
656 """ 657 Sets Config Data for a particular parameter. 658 """ 659 option = self.mConfigData[aParameterName][0] 660 group = self.mConfigData[aParameterName][1] 661 try: 662 result=self.__cfgfile.set(aGroup = group, 663 anOption = option, 664 aValue = aValue) 665 self.__cfgfile.store() 666 except: 667 _log.Log(gmLog.lErr, "Cannot set parameter value for [%s]" % aParameterName ) 668 return None 669 return 1
670 671 #---------------------------------------------------------------------
672 - def AddConfigParam(self, aParameterName, aType = None ,aValue=None, aDescription =None):
673 """ 674 Adds a new config parameter. 675 """ 676 pNameParts = string.split(aParameterName,".") 677 # check if we have a cookie 678 option = pNameParts[-1:][1:] 679 group = string.join(pNameParts[:-1],".") 680 if option is None or group is None: 681 return None 682 683 try: 684 result=self.__cfgfile.set(aGroup = group, 685 anOption = option, 686 aValue = aValue, 687 aComment = aDescription) 688 self.__cfgfile.store() 689 except: 690 _log.Log(gmLog.lErr, "Cannot set parameter value for [%s]" % aParameterName ) 691 return None 692 return 1
693 694 #---------------------------------------------------------------------
695 - def getAllNames(self):
696 """ 697 fetch names and parameter data from config file. Returns list of 698 parameter names where group and option name are concatenated. 699 """ 700 701 # this returns name,cookie, owner (TODO), type and description 702 # of a parameter. 703 # We combine group + option name to one single name. 704 groups = self.__cfgfile.getGroups() 705 if len(groups) == 0: 706 return None 707 mParamNames = [] 708 for group in (groups): 709 options = self.__cfgfile.getOptions(group) 710 if len(options) == 0: 711 continue 712 else: 713 for option in (options): 714 currType=type(self.__cfgfile.get(group,option)) 715 if currType in (types.IntType, types.FloatType, types.LongType): 716 myType = 'numeric' 717 elif currType is types.StringType: 718 myType = 'string' 719 elif currType is types.ListType: 720 myType = 'str_array' 721 else: 722 # FIXME: we should raise an exception here or make the entry 723 # read only since we don't know how to handle this entry 724 mType = 'string' 725 726 description = self.__cfgfile.getComment(group,option) 727 if description is []: 728 description = '' 729 else: 730 myDescription = string.join(description,'\n') 731 optionData=[option,group,'',myType,myDescription] 732 733 newName = group + '.' + option 734 self.mConfigData[newName] = optionData 735 mParamNames.append(newName) 736 737 #DEBUG 738 # _log.Log (gmLog.lData, "%s" % self.mConfigData) 739 740 return mParamNames
741 742 #---------------------------------------------------------------------
743 - def getRawName(self,aParameterName = None):
744 """ 745 Returns the parameter name without possible cookie part(s). 746 Needed to indentify matching config definition entry. 747 """ 748 # since CfgFile does not know about cookies, just return 749 # the parameter name 750 751 return aParameterName
752 753 754 #=========================================================================
755 -def exportDBSet(filename,aUser = None, aWorkplace = 'xxxDEFAULTxxx'):
756 """ 757 Fetches a backend stored set of config options (defined by user and workplace) 758 and returns it as a plain text file. 759 NOTE: This will not write "valid value" information, since this is only 760 hold in config definition files ! 761 Returns: 1 for success, 0 if no parameters were found, None on failure. 762 """ 763 try: 764 expConfigSource = ConfigSourceDB("export",aUser,aWorkplace) 765 except: 766 _log.Log(gmLog.lErr, "Cannot open config set [%s@%s]." % (aUser,aWorkplace)) 767 return None 768 769 try: 770 file = open(filename,"w") 771 except: 772 _log.Log(gmLog.lErr, "Cannot open output file %s." % (filename)) 773 raise 774 775 paramList = expConfigSource.getAllParamNames() 776 if paramList is None: 777 _log.Log(gmLog.lInfo, "DB-set [%s,%s]contained no data." % (aUser,aWorkplace)) 778 return 0 779 text = '' 780 for param in (paramList): 781 description = expConfigSource.getDescription(param) 782 cType = expConfigSource.getParamType(param) 783 value = expConfigSource.getConfigData(param) 784 # we try to dump human readable types as text, 785 # all other as a 'pickled' string 786 if cType in ['string','numeric','str_array']: 787 valuestr = value 788 else: 789 valuestr = pickle.dumps(value) 790 791 file.write( "[%s]\ntype = %s\ndescription = %s\nvalue = %s\n\n" % \ 792 (param,cType,description,value)) 793 return len(paramList)
794 #-------------------------------------------------------------------------
795 -def importDBSet(filename,aUser = None, aWorkplace = 'xxxDEFAULTxxx'):
796 """get config definitions from a file exported with 797 exportDBSet().""" 798 799 # open configuration definition source 800 try: 801 importFile = gmCfg.cCfgFile(aFile = filename, \ 802 flags= gmCfg.cfg_IGNORE_CMD_LINE) 803 # handle all exceptions including 'config file not found' 804 except: 805 exc = sys.exc_info() 806 _log.LogException("Unhandled exception while opening input file [%s]" % filename, exc,verbose=0) 807 return None 808 809 try: 810 importConfigSource = ConfigSourceDB("export",aUser,aWorkplace) 811 except: 812 _log.Log(gmLog.lErr, "Cannot open config set [%s@%s]." % (aUser,aWorkplace)) 813 return None 814 815 existingParamList = importConfigSource.getAllParamNames() 816 817 importData = importFile.getCfg() 818 groups = importFile.getGroups() 819 # every group holds one parameter description 820 # group name = parameter name 821 successfully_stored = 0 822 for paramName in groups: 823 # ignore empty parameter names 824 if paramName == "": 825 continue 826 paramType = importFile.get(paramName, "type") 827 if paramType is None: 828 continue 829 830 # parameter description - might differ from that stored 831 # in backend tables (cfg_template) 832 paramDescription = importFile.get(paramName, "description") 833 if paramDescription is None: 834 continue 835 836 837 paramValueStr = importFile.get(paramName, "value") 838 if paramDescription is None: 839 continue 840 else: 841 if paramType in ['string','numeric','str_array']: 842 paramValue = eval(repr(paramValueStr)) 843 else: 844 paramValue = pickle.loads(paramValueStr) 845 # TODO: check if the parameter already exists with different type 846 if existingParamList is not None and paramName in (existingParamList): 847 if not importConfigSource.getParamType(paramName) == paramType: 848 # if yes, print a warning 849 # you will have to delete that parameter before 850 # storing a different type 851 _log.Log(gmLog.lWarn, 852 "Cannot store config parameter [%s]: different type stored already." % paramName) 853 else: 854 # same type -> store new value 855 s=importConfigSource.setConfigData(paramName,paramValue) 856 if s is None: 857 _log.Log(gmLog.lWarn, 858 "Cannot store config parameter [%s] to set [%s@%s]." % (paramName,aUser,aWorkplace)) 859 else: 860 successfully_stored = successfully_stored + 1 861 862 else: 863 # add new entry to parameter definition dictionary 864 s=importConfigSource.addConfigParam(paramName,paramType,paramValue,paramDescription) 865 if s is None: 866 _log.Log(gmLog.lWarn, 867 "Cannot store config parameter [%s] to set [%s@%s]." % (paramName,aUser,aWorkplace)) 868 else: 869 successfully_stored = successfully_stored + 1 870 return successfully_stored
871 872 #============================================================= 873