def set_logLevels(self, logger_name, levels):
"""
Set the default log level for this component.
Parameter:
logger_name - name of the component's logger
levels - maci.LoggingConfigurable.LogLevels instance containing default log level values
Raises: LoggerDoesNotExistExImpl if the logger is not active.
"""
if Log.doesLoggerExist(logger_name):
Log.getLogger(logger_name).setLevels(levels)
else:
raise LoggerDoesNotExistExImpl()
def testNestedOutput(self):
"""SeveralLoggerCheck messages are logged only once for nested loggers"""
nlogger = Log.getLogger("MyLogger1.child")
before = len(Log.CENTRALHANDLER.buffer)
nlogger.logInfo("Nested Message")
after = len(Log.CENTRALHANDLER.buffer)
self.assertEqual(1, after - before)
Log.CENTRALHANDLER.buffer = []
def testNestedOutput(self):
"""SeveralLoggerCheck messages are logged only once for nested loggers"""
nlogger = Log.getLogger("MyLogger1.child")
before = len(Log.CENTRALHANDLER.buffer)
nlogger.logInfo("Nested Message")
after = len(Log.CENTRALHANDLER.buffer)
self.assertEqual(1, after - before)
Log.CENTRALHANDLER.buffer = []
def __init__(self, sourceName = None, hostName = None):
"""
Create an instance of the AlarmSystemInterface.
Parameters: sourceName is the name of this source
hostName is the name of the computer where the source is running.
"""
self.logger = Log.getLogger()
self.sourceName = sourceName
self.hostName = hostName
self.configuration = ASI.ASIConfiguration()
def __init__(self, sourceName=None, hostName=None):
"""
Create an instance of the AlarmSystemInterface.
Parameters: sourceName is the name of this source
hostName is the name of the computer where the source is running.
"""
self.logger = Log.getLogger()
self.sourceName = sourceName
self.hostName = hostName
self.configuration = ASI.ASIConfiguration()
def get_logLevels(self, logger_name):
"""
Retrieve the log levels for a given component.
Parameter:
logger_name - name of the component's logger
Returns: maci.LoggingConfigurable.LogLevels instance containing the logger's log level values
Raises: LoggerDoesNotExistExImpl if the logger is not active.
"""
if Log.doesLoggerExist(logger_name):
return Log.getLogger(logger_name).getLevels()
else:
raise LoggerDoesNotExistExImpl()
def configureComponentLogger(self, name):
'''
Configure the logger for the given component name from the values in the CDB.
Parameters:
name is the name of the component
'''
# Each component has an associated logger instance
clogger = Log.getLogger(name)
# Default levels are used for missing values
defaultlevels = Log.getDefaultLevels()
try:
#Get the global unnamed logging config to retrieve the maxLogsPerSecond attribute
logconfigG = self.cdbAccess.getElement("MACI/Containers/" + self.name + "/LoggingConfig", "LoggingConfig")
maxLogsPerSec = int(logconfigG[0]['maxLogsPerSecond'])
except (Exception):
# No value was supplied so default is used
maxLogsPerSec = -1
try:
# Process all the named logger configurations
logconfig = self.cdbAccess.getElement("MACI/Containers/" + self.name + "/LoggingConfig", "LoggingConfig/log:_")
for cfg in logconfig:
if cfg["Name"] == name:
try:
centrallevel = int(cfg['minLogLevel'])
except KeyError:
# No value was supplied so default is used
centrallevel = defaultlevels.minLogLevel
try:
locallevel = int(cfg['minLogLevelLocal'])
except KeyError:
# No value was supplied so default is used
locallevel = defaultlevels.minLogLevelLocal
clogger.setLevels(maci.LoggingConfigurable.LogLevels(False, centrallevel, locallevel))
clogger.configureLogging(maxLogsPerSec)
# There should only be one entry per logger so we are done
break
else:
# No matching named logger was found so the default values are used
clogger.setLevels(maci.LoggingConfigurable.LogLevels(True, 0, 0))
except Exception:
# No named loggers were defined so the default values are used
clogger.setLevels(maci.LoggingConfigurable.LogLevels(True, 0, 0))
def setUp(self):
self.pname = "MyLogger1"
self.plogger = Log.getLogger(self.pname)
self.cname = "MyLogger2"
self.clogger = Log.getLogger(self.cname)
def setUp(self):
self.mylogger = Log.getLogger()
class AlarmSystemInterfaceFactory(object):
"""
Base class for creating sources and fault states.
"""
logger = Log.getLogger("AlarmSystemInterfaceFactory")
manager = None
systemtype = None
initialized = False
registry = {}
@classmethod
def init(cls, man=None):
"""
Initializes the factory. This method must be called before using
the other methods of this class.
Returns: None
"""
cls.logger.logTrace("AlarmSystemInterfaceFactory::init() entering.")
cls.manager = man
cls.initialized = True
try:
import ACSAlarmSystemInterfaceProxy as ACSProxy
cls.registry['ACS'] = ACSProxy.ACSAlarmSystemInterfaceProxy
except:
pass
try:
import CERNAlarmSystemInterfaceProxy as CERNProxy
cls.registry['CERN'] = CERNProxy.CERNAlarmSystemInterfaceProxy
except:
pass
# Parse the CDB to get the system type
cdb = CDBAccess.CDBaccess()
try:
ln = cdb.getField(
'Alarms/Administrative/AlarmSystemConfiguration',
'AlarmSystemConfiguration/configuration-property')
doc = AcsAlarmSystem_xsd.minidom.parseString(ln)
rootNode = doc.documentElement
rootObj = AcsAlarmSystem_xsd.alarm_system_configurationListType.factory(
)
rootObj.build(rootNode)
cls.systemtype = rootObj.get_configuration_property()[0].valueOf_
except:
cls.systemtype = 'ACS'
cls.logger.logDebug("Using %s alarm system" % cls.systemtype)
cls.logger.logTrace("AlarmSystemInterfaceFactory::init() exiting.")
@classmethod
def done(cls):
"""
Release the resources held by the factory. This method must be called
when the client is finished using the factory.
Returns: None
"""
cls.logger.logTrace("AlarmSystemInterfaceFactory::done() entering.")
cls.manager = None
cls.initialized = False
cls.systemtype = None
cls.registry = {}
cls.logger.logTrace("AlarmSystemInterfaceFactory::done() exiting.")
@classmethod
def createSource(cls, sourceName=None):
"""
Create a new instance of an alarm system interface.
Parameters: sourceName is the name of the alarm source
Returns: an instance of the appropriate interface
Raises: exception if factory has not been initialized
"""
cls.logger.logTrace(
"AlarmSystemInterfaceFactory::createSource() entering.")
if not cls.initialized:
raise ErrFactory.ACSASFactoryNotInitedExImpl()
cls.logger.logTrace(
"AlarmSystemInterfaceFactory::createSource() exiting.")
return cls.registry[cls.systemtype](sourceName)
@classmethod
def createFaultState(cls, family=None, member=None, code=None):
"""
Create a new instance of a fault state.
Parameters: family is the name of the alarm family for this fault
member is the name of the member of the alarm family for this fault
code is the error code for this fault
Returns: an instance of FaultState
Raises: exception if factory has not been initialized
"""
cls.logger.logTrace(
"AlarmSystemInterfaceFactory::createFaultState() entering.")
if not cls.initialized:
raise ErrFactory.ACSASFactoryNotInitedExImpl()
cls.logger.logTrace(
"AlarmSystemInterfaceFactory::createFaultState() exiting.")
return FaultState.FaultState(family, member, code)
def setUp(self):
self.logger = Log.getLogger("dispatchcheck")
self.logger.stdouthandler = mock.Mock()
self.logger.handlers[0] = self.logger.stdouthandler
def __init__ (self, name):
'''
Constructor.
Initializes member variables and CORBA
Parameters: name is the stringified name of this container.
Raises: ???
'''
print maci.Container.ContainerStatusStartupBeginMsg
#Member variables
self.isReady = Event()
self.running = 1 #As long as this is true, container is not shutdown
self.name = name #Container Name
self.canRecover = True #Whether this container is capable of recovery
self.components = {} #A dict where components are referenced by name
self.compHandles = {} #A dict where comp names are referenced by handles
self.shutdownHandles = []
self.containerPOA = None #POA to activate this container
self.componentPOA = None #POA to create POAs for components
self.compPolicies = [] #Policy[] for components
self.offShootPolicies = [] #Policy[] for offshoots
self.corbaRef = None #reference to this object's CORBA reference
self.logger = Log.getLogger(name) # Container's logger
self.client_type = maci.CONTAINER_TYPE
self.cdbContainerInfo = {}
self.autoLoadPackages = []
#dictionary which maps package names to the number of active components
#using said package
self.compModuleCount = {}
# Initialize the alarm factory
Acsalarmpy.AlarmSystemInterfaceFactory.init(ACSCorba.getManager())
# The alarm source
self.alarmSource = None
# The interface to receive notification from the LogThrottle
# for sending alarms
self.clta=ContainerLogThrottleAlarmer(self)
#Configure CORBA
print maci.Container.ContainerStatusORBInitBeginMsg
self.configCORBA()
print maci.Container.ContainerStatusORBInitEndMsg
#call superclass constructor
print maci.Container.ContainerStatusMgrInitBeginMsg
BaseClient.__init__(self, self.name)
print maci.Container.ContainerStatusMgrInitEndMsg
self.logger.logTrace('CORBA configured for Container: ' + self.name)
self.cdbAccess = CDBaccess()
self.logger.logTrace('Starting Container: ' + self.name)
#get info from the CDB
self.getCDBInfo()
self.refresh_logging_config()
self.configureComponentLogger(name)
#Run everything
self.logger.logInfo('Container ' + self.name + ' waiting for requests')
self.isReady.set()
print maci.Container.ContainerStatusStartupEndMsg
sys.stdout.flush()
def setUp(self):
self.pname = "MyLogger1"
self.plogger = Log.getLogger(self.pname)
self.cname = "MyLogger2"
self.clogger = Log.getLogger(self.cname)
def setUp(self):
self.mylogger = Log.getLogger()
def setUp(self):
self.logger = Log.getLogger("dispatchcheck")
self.logger.stdouthandler = mock.Mock()
self.logger.handlers[0] = self.logger.stdouthandler
def setUp(self):
self.logger = Log.getLogger("dispatchcheck")
self.logger.stdouthandler = mock.Mock()
self.logger.handlers[0] = self.logger.stdouthandler
Log.CENTRALHANDLER.buffer = []
def setUp(self):
self.logger = Log.getLogger("dispatchcheck")
self.logger.stdouthandler = mock.Mock()
self.logger.handlers[0] = self.logger.stdouthandler
Log.CENTRALHANDLER.buffer = []
