C:/work/RevealedSystems/EyeSpy-RS/eyespy/src/objects/logic/configuration/configurator.py

Go to the documentation of this file.

# Copyright (C) 2008-2009  Mark Hanegraaff
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.


import ConfigParser, os
from objects.logic.common.exception import exception
from objects.logic.common.logger import logger
from threading import RLock



## Base class for all configurator type objects. This class is essentially a
# Wrapper to the existing python SafeConfiguratorParser class, which is a simple
# interface to an INI file. Note that this class is implemented as thread safe.
class configurator():
    def __init__(self, configFileName):
        self.config = ConfigParser.SafeConfigParser()
        self.lck = RLock()
        
        self.configFileName = configFileName
    
    
    ## Load the configuration file specified in the constructor
    def loadConfig(self):
        fileFp = None
        
        self.lck.acquire(1)
        try:
            fileFp = open(self.configFileName)
            self.config.readfp(fileFp)
        except Exception, data:
            logger.log(__name__ + "There was an error reading: " + self.configFileName)
            logger.log(data)
            
            raise Exception, data
        finally:
            self.lck.release()
            if fileFp != None: fileFp.close() 
            
    
    
    ## helper "get" function which fetches some configuration item from the INI file.
    # @param section INI file Section name [SECTION]....
    # @param option INI file variable name
    # @param default default value (if not found)
    # @param setIfNotFound If True, this parameter will be written to the INI file using the default value if not found  
    def getConfigValue(self, section, option, default, setIfNotFound):
        
        self.lck.acquire(1)        
        try:
            return self.readFmat(self.config.get(section, option))
                    
        except Exception, getError:
            errMsg = "Could not retrieve [%s]==>%s: %s" % (section, option, getError)
            logger.log(__name__ + errMsg )
            
            if setIfNotFound == True:
                # attempt to write that option back to the config file
                fileFp = None
                
                try:
                    fileFp = open(self.configFileName, 'w')
                    
                    logger.log(__name__ + ": Writing default value back to configuration file" )
                    
                    self.setConfigValue(section, option, self.writeFmat(str(default)))
                    #self.config.set(section, option, self.writeFmat(str(default)))
                    #self.config.write(fileFp)
                    
                except Exception, setError:
                    errMsg = ": Could not write default setting back to file: %s" % (setError)
                    logger.log(__name__ + errMsg )
                    
                finally:
                    if fileFp != None: fileFp.close()
            # since there was an error, return the default value             
            return self.readFmat(default)
        finally:
            self.lck.release()
            
            
    ## Retrieves an entire section as returns it as a list of section variables
    # @param section Section name
    def getSection(self, section):                
        try:
            self.lck.acquire(1)
            return self.config.items(section)
        except ConfigParser.NoSectionError:
            logger.log(__name__ + ": There was an error Retrieving ini file section")
            logger.log(section)
            logger.log(__name__ + ": Section will be added")
            
            try:
                self.config.add_section(section)                
            except Exception:
                logger.log(__name__ + ": Holy !@#$%. I can't even add the section. I give up")
            finally:
                return []
                
            
        finally:
            self.lck.release()
            
            
    ## Helper function used to set a configuration value
    # @param section INI File Section Name
    # @param option INI file variable name
    # @param value INI file variable value
    def setConfigValue(self, section, option, value):
        try:
            self.lck.acquire(1)
            fileFp = open(self.configFileName, 'w')
            
            try:
                self.config.add_section(section)
            except Exception:
                # i really don't care if this happens
                pass
            
            #logger.log(__name__ + ": Writing display setting option back to configuration file" )
            self.config.set(section, option, self.writeFmat(str(value)))            
            
            self.config.write(fileFp)
            
        except Exception, setError:
            errMsg = ": Could not write display setting option to file: %s" % (setError)
            raise exception(setError, False)
            logger.log(__name__ + errMsg )
            
        finally:
            if fileFp != None: fileFp.close()
            self.lck.release()
            
    
    
    ## This helper function will replace all empty strings with a special token. 
    # Although the application may want to save an empty string as part of its configuration, 
    # doing so will it will break the integrity of the INI file and make it unparsable later.
    # @param str String to format 
    def writeFmat(self, str):
        if str == None or str == "" or str == "None":
            return "__None__"
        else:
            return str
    
    # this function will take any specially formatted token strings from the INI files
    # and replace them with a a corresponding empty strings. This is done because because empty
    # strings cannot be physically written into the INI file
    # @param str String to convert
    def readFmat(self, str):
        if str == "__None__":
            return "";
        else: 
            return str
    
    
            
            
        

---