def start(self):
filename = '%s (%s)' % (self.name, 'triggers')
self.manager = self.nodespace.as_node(self.manager)
self._pdo_lock.acquire()
try:
if self._triggers is None:
self._triggers = PersistentDictionary(filename,
encode=None,
decode=None)
if not self._triggers:
pdodata = PersistentDataObject(self, dmtype=GC_NEVER)
if os.path.exists(pdodata.filename()):
msglog.log('broadway', msglog.types.INFO,
"Migrating previous trigger data.")
pdodata.triggers = {}
pdodata.load()
self._triggers.update(pdodata.triggers)
pdodata.destroy()
del (pdodata)
self._loadtriggers()
if self.secured:
self.security_manager = self.as_node(
"/services/Security Manager")
else:
self.security_manager = None
finally:
self._pdo_lock.release()
return super(TriggersConfigurator, self).start()
def start(self):
self._pdo = PersistentDataObject(self)
self._pdo.last_dictionary = None
self._pdo.load()
self._started = 1
self.parent.event_subscribe(self, AlarmTriggerEvent)
CompositeNode.start(self)
def start(self):
if self.__running:
return
if self.debug:
msglog.log('EnergywiseManager :', msglog.types.INFO,
'Inside start')
CompositeNode.start(self)
# start_node = as_node('/services/EnergywiseManager/')
# self.configure_trend_in_switches(start_node, 60)
self.__running = True
self._pdo_lock.acquire()
self._pdo = PersistentDataObject(self, dmtype=GC_NEVER)
self._pdo.trends = {}
self._pdo.load()
self._pdo_lock.release()
if self.has_child('trends'):
self.trends = self.get_child('trends')
else:
self.trends = CompositeNode()
self.trends.configure({'parent': self, 'name': 'trends'})
self.trends.start()
# start trending for saved domains
for domain, freq in self._pdo.trends.items():
try:
start_node = as_node(domain)
# self.configure_trend_in_switches( start_node,freq )
start_node.new_trend(freq)
except:
self.delete_trend_configuration(domain)
return
def start(self):
self._PDO = PersistentDataObject(self,dmtype=GC_NEVER)
self._PDO.exception_log_last_time = 0.0
self._PDO.load()
# Scan subtree of grandparent logger for channel (column) 'fsg_attrs'
# nodes containing info required for FSG Demo, so that we don't have
# to do the scan every time format() is called:
self._channels = {}
columns_node = self.parent.parent.parent.get_child('columns')
column_nodes = columns_node.children_nodes()
for column_node in column_nodes:
if column_node.name == 'timestamp':
continue
assert isinstance(column_node, ChannelAttrsColumn) \
or isinstance(column_node, ChannelAttrsDeltaColumn), \
'Column %s should be class ChannelAttrsColumn, but is class %s' \
% (column_node.name, column_node.__class__.__name__)
self._channels[column_node.name] = {
'channel_node':column_node,'values':[]
}
self._exception_log = None
try:
self._exception_log = as_node(self.exception_log_url)
except ENoSuchName:
pass
return
def start(self):
ServiceNode.start(self)
# this will correctly add the msglog as a child
# to the logger.
if 'msglog' not in self.children_names():
columns = mpx.lib.msglog.get_columns()
log = Log()
log.configure({'name': 'msglog', 'parent': self})
for c in columns:
column = mpx.lib.factory('mpx.service.logger.column')
config = c.configuration()
config['parent'] = log
column.configure(config)
self._logs = PersistentDataObject(self)
self._logs.names = []
self._logs.load()
for name in self._logs.names:
if ((not mpx.lib.log.log_exists(name))
and (name not in self.children_names())):
log = mpx.lib.log.log(name)
log.destroy()
del (log)
self._logs.names = []
for child in self.children_nodes():
if not isinstance(child, Alias):
# Don't manage other managers' logs...
self._logs.names.append(child.name)
self._logs.save()
def start(self):
self.managernode = self.as_node(self.manager)
self.synclock.acquire()
try:
alarmsname = '%s (%s)' % (self.name, 'alarms')
eventsname = '%s (%s)' % (self.name, 'events')
self.alarms = PersistentDictionary(alarmsname,
encode=self.encode,
decode=self.decode)
self.events = PersistentDictionary(eventsname,
encode=self.encode,
decode=self.decode)
# Migrate PDO data from old style persistence.
pdodata = PersistentDataObject(self, dmtype=GC_NEVER)
if os.path.exists(pdodata.filename()):
msglog.log('broadway', msglog.types.INFO,
"Migrating previous alarm and event data")
pdodata.events = {}
pdodata.alarms = {}
pdodata.load()
migrate(pdodata, self.decode)
self.rebuildstorage()
pdodata.destroy()
del(pdodata)
finally:
self.synclock.release()
self.securitymanager = self.as_node('/services/Security Manager')
register = self.managernode.register_for_type
self.sub = register(self.handle_event, StateEvent)
self.running.set()
super(AlarmConfigurator, self).start()
def start(self):
self.security_manager = self.nodespace.as_node(self.security_manager)
self._pdo_lock.acquire()
try:
self._pdo = PersistentDataObject(self, dmtype=GC_NEVER)
self._pdo.valuedrivers = {}
self._pdo.load()
valuedriverdumps = self._pdo.valuedrivers.items()
finally:
self._pdo_lock.release()
super(DriverConfigurator, self).start()
tstart = time.time()
for drivername, driverdump in valuedriverdumps:
try:
IPickles(cPickle.loads(driverdump))()
except:
message = self.LOADFAILURE % (self.name, 'Value Driver',
drivername)
msglog.log('broadway', msglog.types.ERR, message)
msglog.exception(prefix='Handled')
tend = time.time()
tlapse = tend - tstart
msglog.log(
'broadway', msglog.types.INFO, 'Value Driver Configurator loaded '
'%s nodes in %s seconds.' % (len(valuedriverdumps), tlapse))
return
def start(self):
self.nodes = []
from mpx.service.time.time_zone import TimeZone
if not IScheduleHolderParent.implementedBy(TimeZone):
class_implements(TimeZone, IScheduleHolderParent)
self.security_manager = self.nodespace.as_node(self.security_manager)
self._pdo_lock.acquire()
try:
if not self._pdo:
self._pdo = PersistentDataObject(self, dmtype=GC_NEVER)
self._pdo.holders = {}
self._pdo.schedules = {}
self._pdo.load()
holderdicts = self._pdo.holders.values()
holderdumps = []
for holderdict in holderdicts:
holderdumps.extend(holderdict.items())
# schedules = {'local': {'Holder1': {'Sched1': Sched1Dump}, 'Holder2': ...}, 'UTC': ...}
scheduledicts = []
[
scheduledicts.extend(holderdict.values())
for holderdict in self._pdo.schedules.values()
]
scheduledumps = []
for scheduledict in scheduledicts:
scheduledumps.extend(scheduledict.items())
finally:
self._pdo_lock.release()
super(ScheduleConfigurator, self).start()
tstart = time.time()
for holdername, holderdump in holderdumps:
try:
self.nodes.append(IPickles(cPickle.loads(holderdump))())
except:
message = self.LOADFAILURE % (self.name, 'Schedule Holder',
holdername)
msglog.log('broadway', msglog.types.ERR, message)
msglog.exception(prefix='Handled')
tend = time.time()
tlapse = tend - tstart
msglog.log(
'broadway', msglog.types.INFO, 'Schedule Configurator loaded '
'%s nodes in %s seconds.' % (len(holderdumps), tlapse))
tstart = time.time()
for schedulename, scheduledump in scheduledumps:
try:
self.nodes.append(IPickles(cPickle.loads(scheduledump))())
except:
message = self.LOADFAILURE % (self.name, 'Schedule Holder',
schedulename)
msglog.log('broadway', msglog.types.ERR, message)
msglog.exception(prefix='Handled')
tend = time.time()
tlapse = tend - tstart
msglog.log(
'broadway', msglog.types.INFO, 'Schedule Configurator loaded '
'%s nodes in %s seconds.' % (len(scheduledumps), tlapse))
self.template = self.parent.read_resource(self.page_template)
def configure(self, config):
self._pdo = PersistentDataObject(self)
self._pdo.stats_dict = {
} #used to detect changes to xml files based on timestamp. Tuple (modify time, pickle string)
self._pdo.load()
# write_priority can be set for the entire control service, though
# it may be specialized at the individual application node level.
set_attribute(self, 'write_priority', 9, config, int)
CompositeNode.configure(self, config)
def configure(self, config):
set_attribute(self, 'directory', '/tmp', config)
set_attribute(self, 'file_prefix', REQUIRED, config)
set_attribute(self, 'file_suffix', REQUIRED, config)
set_attribute(self, 'name_scheme', None, config)
set_attribute(self, 'timestamp_format', '%s', config)
Transporter.configure(self, config)
self._last = PersistentDataObject(self)
self._last.filename = None
self._last.count = 1
self._last.load()
def start(self):
try:
self._pdo_lock.acquire()
try:
if self.__running:
return
self.__running = True
self._trendconfig = PersistentDictionary(filename(self),
encode=None,
decode=None)
if not self._trendconfig:
pdodata = PersistentDataObject(self, dmtype=GC_NEVER)
if os.path.exists(pdodata.filename()):
msglog.log('broadway', msglog.types.INFO,
"Migrating previous trend data")
pdodata.trends = {}
pdodata.load()
self._trendconfig.update(pdodata.trends)
del (pdodata)
finally:
self._pdo_lock.release()
super(TrendManager, self).start()
self.logger = node.as_internal_node(self.logger_url)
if self.has_child('trends'):
self.trends = self.get_child('trends')
else:
self.trends = CompositeNode()
self.trends.configure({'parent': self, 'name': 'trends'})
self.trends.start()
corrupt_trends = []
for trendname, trenddump in self._trendconfig.items():
msg = "Loading trend: %s" % trendname
msglog.log('trendmanager', msglog.types.INFO, msg)
try:
trend = unmarshal(trenddump)
except:
corrupt_trends.append(trendname)
msg = "Failed to load trend: %s" % trendname
msglog.log('trendmanager', msglog.types.ERR, msg)
msglog.exception(prefix='Handled')
for trendname in corrupt_trends:
try:
msg = "Deleting trend information: %s" % trendname
msglog.log('trendmanager', msglog.types.INFO, msg)
self._delete_trend_configuration(trendname)
if self.trends.has_child(trendname):
trend = self.trends.get_child(trendname)
trend.prune(force=True)
except:
msglog.exception(prefix='Handled')
except:
self.__running = False
raise
return
def start(self):
Exporter.start(self)
if not self.running:
self.running = 1
self.connection = as_node(self.connection_node)
self._time_keeper = PersistentDataObject(self)
self._time_keeper.start_time = 0
self._time_keeper.load()
self._period = self.parent.parent.period
self._setup_trigger()
else:
raise EAlreadyRunning
def _certificate_maintenance(self):
previous = PersistentDataObject(self)
previous.cert_config = None
previous.key_file = None
previous.server_cert = None
previous.cert_fingerprint = None
previous.load()
c = certificate.CertificateConfiguration(self)
config = {'C':self.country}
config['ST'] = self.state
config['L'] = self.city
config['O'] = self.organization
config['OU'] = self.organizational_unit
config['CN'] = self.common_name
config['emailAddress'] = self.email
c.configure(config)
cert_fingerprint = makecert.get_fingerprint(self.server_cert)
if previous.cert_fingerprint == cert_fingerprint:
msglog.log('broadway', msglog.types.INFO, 'Certificate Fingerprint Match!!!!' )
else:
msglog.log('broadway', msglog.types.INFO, 'Certificate Fingerprint Mismatch!!!!' )
if c == previous.cert_config and \
previous.key_file == self.key_file and \
previous.cert_fingerprint == cert_fingerprint and \
not certificate.is_outdated(self.server_cert):
msglog.log('broadway', msglog.types.INFO,
'Using existing certificate')
return
msglog.log('broadway', msglog.types.INFO, 'Generating new certificate')
filename = os.path.join(properties.TEMP_DIR, 'cert_config.tmp')
file = open(filename, 'w')
c.formatted_output_to_file(file)
try:
failed = 1
makecert.create_from_file(filename, self.key_file,
self.server_cert)
failed = 0
msglog.log('broadway', msglog.types.INFO,
'Certificate generated')
except:
msglog.exception()
msglog.log('broadway', msglog.types.WARN,
'Certificate generation failed')
file.close()
os.remove(filename)
if not failed:
previous.cert_config = c.configuration()
previous.key_file = self.key_file
previous.server_cert = self.server_cert
previous.cert_fingerprint = makecert.get_fingerprint(self.server_cert)
previous.save()
return
def configure(self, config):
SimpleValue.configure(self, config)
self._pdo = PersistentDataObject(self)
self._pdo.value = None
self._pdo.conversion = None
self._pdo.load()
conversion = _get_name(self.conversion)
if (self._pdo.value == None or self._pdo.conversion != conversion):
self._pdo.value = self.value
self._pdo.conversion = conversion
self._pdo.save()
else:
self.value = self._pdo.value
def start(self):
from mpx.lib.persistent import PersistentDataObject
ServiceNode.start(self)
if self.debug: print 'Garbage Collector Starting!'
self._data = PersistentDataObject(self,dmtype=GC_NEVER)
self._data.registered = []
self._data.load()
if self.debug: print 'GC Data is %s.' % self._data
if self.debug: print 'GC Data._reg is %s.' % self._data.registered
def start(self):
Exporter.start(self)
if not self.running:
self.running = 1
self.connection = as_node(self.connection_node)
self._event_count = self.log_multiple - 1
self._time_keeper = PersistentDataObject(self)
self._time_keeper.start_time = 0
self._time_keeper.load()
self._period = self.parent.parent.period
self.parent.parent.event_subscribe(self, LogAddEntryEvent)
else:
raise EAlreadyRunning
def test_upgrade(self):
from mpx.upgrade.persistent import persistent_0
old = persistent_0.PersistentDataObject('upgrade_test')
old.purpose = 'testing'
old.save()
old_filename = old._persistent.filename
del (old.__dict__['_persistent'])
del (old)
new = PersistentDataObject('upgrade_test')
self.failIf(os.path.exists(old_filename),
'Upgrade failed to remove old version')
new.purpose = None
new.load()
self.failUnless(new.purpose == 'testing',
'Upgrade failed to get old value')
new.destroy()
del (new)
def start(self):
self.manager = self.nodespace.as_node(self.manager)
self.security_manager = as_node(self.security_manager)
self._pdo = PersistentDataObject(self)
msg='The CloudConfigurator Persistent Object is in the file :%s' %str(self._pdo.filename())
msglog.log('CloudConfigurator', msglog.types.INFO,msg)
if os.path.exists(self._pdo.filename()):
# Migration
msglog.log('CloudConfigurator', msglog.types.INFO, 'PDO Migration in Progress')
self._pdo.formation = cPickle.dumps(IPickles(self.manager.formation))
self._pdo.load()
formation = IPickles(cPickle.loads(self._pdo.formation))()
msglog.log('CloudConfigurator', msglog.types.INFO, 'PDO Migration for the Formation:%s' %str(formation))
self.manager.update_formation(formation,None)
self._pdo.destroy()
del(self._pdo)
msglog.log('CloudConfigurator', msglog.types.INFO, 'PDO Migration is Complete')
return super(CloudConfigurator, self).start()
def start(self):
self.container = self.nodespace.as_node(self.container)
self._pdo_lock.acquire()
try:
self._pdo = PersistentDataObject(self, dmtype=GC_NEVER)
self._pdo.exporters = {}
self._pdo.load()
exporterdumps = self._pdo.exporters.values()
finally:
self._pdo_lock.release()
super(ExportersConfigurator, self).start()
tstart = time.time()
for exporterdump in exporterdumps:
IPickles(cPickle.loads(exporterdump))()
tend = time.time()
tlapse = tend - tstart
msglog.log(
'broadway', msglog.types.INFO, 'Exporter Configurator loaded '
'%s exporters in %s seconds.' % (len(exporterdumps), tlapse))
self.manager = self.container
def configure(self, config):
set_attribute(self, 'host', REQUIRED, config)
set_attribute(self, 'port', 21, config, int)
set_attribute(self, 'directory', '', config)
set_attribute(self, 'username', REQUIRED, config)
set_attribute(self, 'password', REQUIRED, config)
#CSCtn64870
if (config.has_key('timeout') and config['timeout'] == ''):
config['timeout'] = 'None'
set_attribute(self, 'timeout', None, config, float)
set_attribute(self, 'file_prefix', 'cisco', config)
set_attribute(self, 'file_suffix', '.dat', config)
set_attribute(self, 'name_scheme', 'timestamp', config)
set_attribute(self, 'timestamp_format', '%s', config)
set_attribute(self, 'passive_mode', 1, config, as_boolean)
set_attribute(self, 'file_append', 0, config, as_boolean)
Transporter.configure(self, config)
if self._last is None:
self._last = PersistentDataObject(self)
self._last.filename = None
self._last.count = 1
self._last.load()
def start(self):
if self.is_running():
raise TypeError("Equipment Monitor already running.")
if TESTING and not self.test_machines:
self.test_machines = setup_machines()
machinecount = len(self.test_machines)
self.debugout("Setup %d test machines" % machinecount)
self.synclock.acquire()
try:
self.running.set()
if self.subscriptions and not self.subscriptions.closed():
self.subscriptions.close()
self.formatter = None
self.transporter = None
children = self.children_nodes()
for childnode in children:
if IFormatter.providedBy(childnode):
if self.formatter is not None:
raise TypeError("Already has formatter child.")
self.formatter = childnode
if ITransporter.providedBy(childnode):
if self.transporter is not None:
raise TypeError("Already has transporter child.")
self.transporter = childnode
if not self.formatter:
raise TypeError("Must have one formatter child node.")
if not self.transporter:
raise TypeError("Must have one transporter child node.")
self.smservice = as_node(self.smnodeurl)
self.subscriptions = PersistentDictionary(
self.name,
encode=self.serialize_subscription,
decode=self.unserialize_subscription)
pdodata = PersistentDataObject(self)
if os.path.exists(pdodata.filename()):
msglog.log('broadway', msglog.types.WARN,
"Equipment Monitor upgrading persistence.")
migrate = frompdo(pdodata)
self.subscriptions.update(migrate)
message = "Equipment Monitor merged %d subscriptions."
message = message % len(migrate)
msglog.log('broadway', msglog.types.INFO, message)
pdodata.destroy()
msglog.log('broadway', msglog.types.WARN,
"Equipment Monitor destroyed old persistence.")
msglog.log('broadway', msglog.types.INFO,
"Equipment Monitor persistence upgrade complete.")
del (pdodata)
message = 'Equipment Monitor startup: %s %s'
for subscription in self.subscriptions.values():
try:
subscription.setup_subscription()
except:
msglog.exception(prefix="handled")
else:
self.debugout(message % ('setup', subscription))
skipcounts = []
for i in range(0, 1 + len(self.subscriptions) / 30):
skipcounts.extend([i + 1] * 30)
self.setup_work_threads()
for subscription in self.subscriptions.values():
try:
subscription.start(skipcounts.pop())
except:
msglog.exception(prefix="Handled")
else:
self.debugout(message % ('started', subscription))
except:
self.cleanup_resources()
self.running.clear()
raise
finally:
self.synclock.release()
super(EquipmentMonitor, self).start()
