class Logger(ServiceNode):
##
# @author Craig Warren
# @param config
# @return None
def configure(self,config):
ServiceNode.configure(self,config)
##
# @author Craig Warren
# starts the logger service
# @return None
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()
##
# @author Craig Warren
# stops the logger service
# @return None
def stop(self):
return ServiceNode.stop(self)
##
# @author Craig Warren
# @param log_name
# the name of the log to return
# @return Log
# returns the log if it can't find the log it
# returns None
def get_log(self,log_name):
for child in self.children_nodes():
if child.name == log_name:
return child
return None
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.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
class LastAlarm(CompositeNode,EventConsumerMixin):
def __init__(self):
self._last_alarm = None
self._started = 0
CompositeNode.__init__(self)
EventConsumerMixin.__init__(self,self._alarm_triggered)
def configure(self, config):
CompositeNode.configure(self, config)
def configuration(self):
config = CompositeNode.configuration(self)
return config
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 stop(self):
selt._started = 0
self.parent.cancel(self,AlarmTriggerEvent)
CompositeNode.stop(self)
def _alarm_triggered(self, alarm):
self._last_alarm = alarm
self._pdo.last_dictionary = alarm.dictionary()
self._pdo.save()
def get(self, skipCache=0):
return self._last_alarm
def get_dictionary(self):
return self._pdo.last_dictionary
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.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 __init__(self, *args, **kw):
self.integer = None
self.integers = None
self.letters = None
self.letterset = None
self.letterlist = None
self.letterdict = None
PDO.__init__(self, *args, **kw)
def __init__(self, node):
self.__lock = Lock()
self.__last_save = {}
self.max_seq = -1
self.pending_seqs = []
self.inprocess_seqs = []
PersistentDataObject.__init__(self, node, auto_load=True)
return
def __init__(self, *args, **kw):
self.integer = None
self.integers = None
self.letters = None
self.letterset = None
self.letterlist = None
self.letterdict = None
PDO.__init__(self, *args, **kw)
def __init__(self, node):
self.__lock = Lock()
self.__last_save = {}
self.max_seq = -1
self.pending_seqs = []
self.inprocess_seqs = []
PersistentDataObject.__init__(self, node, auto_load=True)
return
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)
class TriggeredExporter(SynchronizedExporter):
def __init__(self):
SynchronizedExporter.__init__(self)
self._sid = None
self.evt = None #dil - debug
def handle_log(self, event):
self.debug_information('Log export triggered.')
self.evt = event #dil - debug
value = event.results()[1]['value']
if isinstance(value, Exception):
raise value
if value: # only export when value is true
self.debug_information('Going to start export thread.')
if self._lock.acquire(0):
try:
thread = Thread(name=self.name,
target=self.go,
args=(time.time(), ))
thread.start()
finally:
self._lock.release()
else:
msglog.log('broadway', msglog.types.WARN,
('Last export still active, ' +
'skipping current request.'))
def configure(self, config):
set_attribute(self, 'trigger', REQUIRED, config)
SynchronizedExporter.configure(self, config)
def configuration(self):
config = SynchronizedExporter.configuration(self)
get_attribute(self, 'trigger', config, str)
return config
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 _setup_trigger(self):
try:
self._sid = SM.create_delivered(self, {1: as_node(self.trigger)})
except ENotStarted, ENoSuchNode:
msg = 'TriggeredExporter trigger: %s does not exist - could be nascent' % self._trigger
msglog.log('broadway', msglog.types.WARN, msg)
scheduler.seconds_from_now_do(60, self._setup_trigger)
class WritingTransporter(Transporter):
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 configuration(self):
config = Transporter.configuration(self)
get_attribute(self, 'directory', config)
get_attribute(self, 'file_prefix', config)
get_attribute(self, 'file_suffix', config)
get_attribute(self, 'name_scheme', config)
get_attribute(self, 'timestamp_format', config)
return config
def transport(self, data):
if type(data) == type(''):
data = StringIO.StringIO(data)
filename = self._generate_filename()
tempname = filename + '.tmp'
file = open(tempname, 'w')
try:
write = data.read(1024)
while write:
file.write(write)
write = data.read(1024)
finally:
file.close()
os.chmod(tempname, 0444)
os.rename(tempname, filename)
def _generate_filename(self):
filename = self.file_prefix
append = ''
if self.name_scheme == 'incremental':
append = '%s' % self._last.count
elif self.name_scheme == 'timestamp':
file_time = self.parent.time_function(self.parent.scheduled_time())
filename = filename + time.strftime(self.timestamp_format,
file_time)
append = '_%s' % (self._last.count + 1)
if filename != self._last.filename:
self._last.count = 0
append = ''
self._last.count += 1
self._last.filename = filename
return os.path.join(self.directory,
filename + append + self.file_suffix)
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 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()
class TriggeredExporter(SynchronizedExporter):
def __init__(self):
SynchronizedExporter.__init__(self)
self._sid = None
self.evt = None #dil - debug
def handle_log(self,event):
self.debug_information('Log export triggered.')
self.evt = event #dil - debug
value = event.results()[1]['value']
if isinstance(value,Exception):
raise value
if value: # only export when value is true
self.debug_information('Going to start export thread.')
if self._lock.acquire(0):
try:
thread = Thread(name=self.name, target=self.go,
args=(time.time(),))
thread.start()
finally:
self._lock.release()
else:
msglog.log('broadway',msglog.types.WARN,
('Last export still active, ' +
'skipping current request.'))
def configure(self, config):
set_attribute(self, 'trigger',REQUIRED,config)
SynchronizedExporter.configure(self, config)
def configuration(self):
config = SynchronizedExporter.configuration(self)
get_attribute(self,'trigger',config,str)
return config
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 _setup_trigger(self):
try:
self._sid = SM.create_delivered(self, {1:as_node(self.trigger)})
except ENotStarted, ENoSuchNode:
msg = 'TriggeredExporter trigger: %s does not exist - could be nascent' % self._trigger
msglog.log('broadway',msglog.types.WARN,msg)
scheduler.seconds_from_now_do(60, self._setup_trigger)
def __init__(self, name, password_file=PASSWD_FILE, group_file=GROUP_FILE, shadow_file=SHADOW_FILE):
self.__lock = Lock()
self.__password_file = password_file
self.__group_file = group_file
self.__shadow_file = shadow_file
self.meta = {}
self.USERS.load()
if not self.USERS.has_key(self.name()):
msglog.log("broadway", msglog.types.INFO, ("No profile for user %s found, creating" " new profile" % name))
self.USERS[self.name()] = str(UUID())
PersistentDataObject.__init__(self, self.USERS[self.name()])
PersistentDataObject.load(self)
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 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):
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 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):
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
class WritingTransporter(Transporter):
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 configuration(self):
config = Transporter.configuration(self)
get_attribute(self, 'directory', config)
get_attribute(self, 'file_prefix', config)
get_attribute(self, 'file_suffix', config)
get_attribute(self, 'name_scheme', config)
get_attribute(self, 'timestamp_format', config)
return config
def transport(self, data):
if type(data) == type(''):
data = StringIO.StringIO(data)
filename = self._generate_filename()
tempname = filename + '.tmp'
file = open(tempname,'w')
try:
write = data.read(1024)
while write:
file.write(write)
write = data.read(1024)
finally:
file.close()
os.chmod(tempname,0444)
os.rename(tempname,filename)
def _generate_filename(self):
filename = self.file_prefix
append = ''
if self.name_scheme == 'incremental':
append = '%s' % self._last.count
elif self.name_scheme == 'timestamp':
file_time = self.parent.time_function(self.parent.scheduled_time())
filename = filename + time.strftime(self.timestamp_format,file_time)
append = '_%s' % (self._last.count + 1)
if filename != self._last.filename:
self._last.count = 0
append = ''
self._last.count += 1
self._last.filename = filename
return os.path.join(self.directory,filename + append + self.file_suffix)
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):
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._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 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 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 __init__(self,
name,
password_file=PASSWD_FILE,
group_file=GROUP_FILE,
shadow_file=SHADOW_FILE):
self.__lock = Lock()
self.__password_file = password_file
self.__group_file = group_file
self.__shadow_file = shadow_file
self.meta = {}
self.USERS.load()
if not self.USERS.has_key(self.name()):
msglog.log('broadway', msglog.types.INFO,
('No profile for user %s found, creating'
' new profile' % name))
self.USERS[self.name()] = str(UUID())
PersistentDataObject.__init__(self, self.USERS[self.name()])
PersistentDataObject.load(self)
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.manager = self.nodespace.as_node(self.manager)
self._pdo_lock.acquire()
try:
self._pdo = PersistentDataObject(self, dmtype=GC_NEVER)
self._pdo.users = {}
self._pdo.roles = {}
self._pdo.policies = {}
self._pdo.load()
userdumps = self._pdo.users.items()
roledumps = self._pdo.roles.items()
policydumps = self._pdo.policies.items()
finally: self._pdo_lock.release()
super(SecurityConfigurator, self).start()
tstart = time.time()
for rolename, roledump in roledumps:
try: IPickles(cPickle.loads(roledump))()
except:
message = self.LOADFAILURE % (self.name, 'role', rolename)
msglog.log('broadway', msglog.types.ERR, message)
msglog.exception(prefix = 'Handled')
tend = time.time()
tlapse = tend - tstart
msglog.log('broadway', msglog.types.INFO,
'Security Configurator loaded '
'%s roles in %s seconds.' % (len(roledumps), tlapse))
tstart = time.time()
for policyname, policydump in policydumps:
try: IPickles(cPickle.loads(policydump))()
except:
message = self.LOADFAILURE % (self.name, 'policy', policyname)
msglog.log('broadway', msglog.types.ERR, message)
msglog.exception(prefix = 'Handled')
tend = time.time()
tlapse = tend - tstart
msglog.log('broadway', msglog.types.INFO,
'Security Configurator loaded '
'%s policies in %s seconds.' % (len(policydumps), tlapse))
tstart = time.time()
for username, userdump in userdumps:
try: IPickles(cPickle.loads(userdump))()
except:
message = self.LOADFAILURE % (self.name, 'user', username)
msglog.log('broadway', msglog.types.ERR, message)
msglog.exception(prefix = 'Handled')
tend = time.time()
tlapse = tend - tstart
msglog.log('broadway', msglog.types.INFO,
'Security Configurator loaded '
'%s users in %s seconds.' % (len(userdumps), 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 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, '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):
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
class SimplePersistentValue(SimpleValue):
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 configuration(self):
self.value = self._pdo.value
return SimpleValue.configuration(self)
def set(self, value, asyncOK=1):
SimpleValue.set(self, value, asyncOK)
self._pdo.value = self.value
self._pdo.save()
def get(self, skipCache=0):
return self._pdo.value
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):
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 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
class LastAlarm(CompositeNode, EventConsumerMixin):
def __init__(self):
self._last_alarm = None
self._started = 0
CompositeNode.__init__(self)
EventConsumerMixin.__init__(self, self._alarm_triggered)
def configure(self, config):
CompositeNode.configure(self, config)
def configuration(self):
config = CompositeNode.configuration(self)
return config
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 stop(self):
selt._started = 0
self.parent.cancel(self, AlarmTriggerEvent)
CompositeNode.stop(self)
def _alarm_triggered(self, alarm):
self._last_alarm = alarm
self._pdo.last_dictionary = alarm.dictionary()
self._pdo.save()
def get(self, skipCache=0):
return self._last_alarm
def get_dictionary(self):
return self._pdo.last_dictionary
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 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.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 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 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):
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
class SimplePersistentValue(SimpleValue):
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 configuration(self):
self.value = self._pdo.value
return SimpleValue.configuration(self)
def set(self,value,asyncOK=1):
SimpleValue.set(self, value, asyncOK)
self._pdo.value = self.value
self._pdo.save()
def get(self, skipCache=0):
return self._pdo.value
def __init__(self, node):
self.last_time = 0
PersistentDataObject.__init__(self, node)
class GarbageCollector(ServiceNode):
def __init__(self):
ServiceNode.__init__(self)
self.debug = 0
self._registered = ()
self._did_save = 0
self._post_configuration=0
if self.debug: print 'Initialized _registered to [] for %s.' % self
def singleton_unload_hook(self):
return
##
# @param config
# @return None
def configure(self,config):
ServiceNode.configure(self,config)
def configuration(self):
if self.debug: print 'In GarbageCollector:configuration().'
config = ServiceNode.configuration(self)
return config
##
# starts the data manager service
# @return None
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
##
# stops the data manager service
# @return None
def stop(self):
return ServiceNode.stop(self)
##
# set_faillist is the hook which allows the system to inform the data
# manager about which nodes failed to start up. Each list item should
# be a dictionary with the following members:
# name - the name of the node (without parent information)
# parent - the parent of the node (with any relevant parent information,
# e.g. /services/com1
# type - what type of failure occured. Acceptable values are
# load and config.
def set_faillist(self, faillist):
if self.debug: print 'Got faillist of %s.' % faillist
if self.debug: print 'Got reglist of %s.' % self._registered
old_registered = self._data.registered[:]
# By now, everyone should have had a chance to start up.
# @fixme (real soon now, I promise): Use the cool new method that
# Mark and Shane suggested to consume an event from the root node
# when all nodes have been started as a trigger for starting
# the garbage collection process.
self._data.registered = list(self._registered)
# OK, now process our lists and see who is naughty and who is
# nice.
if self.debug: print '---- Starting to Process Potential Reaping List ----'
for regnode in old_registered:
purge_type = regnode['type']
filename = regnode['filename']
nodename = regnode['nodename']
# If we are never supposed to purge this data, then don't bother
# to do any more checking
if purge_type == GC_NEVER:
if self.debug: print '%s: Skipping because it is GC_NEVER.' % nodename
continue
if self.debug: print '%s: Checking.' % nodename
node_did_register = 0
node_did_fail = 0
node_did_fail_on_config = 0
node_did_fail_on_load = 0
node_did_fail_on_start = 0
parent_did_fail = 0
should_purge = 0
# If this node has registered with us, then we assume that
# it started up and is present, etc. This might not always
# be the correct thing to do, but for now it seems like the
# correct enough thing to do and should keep performance
# from becoming an issue.
if regnode in self._registered:
if self.debug: print '%s: Appears to be happy.' % nodename
node_did_register = 1
else:
# Check to see if the node or one of it's ancestors failed
for failnode in faillist:
curnode = failnode['name']
curpare = failnode['parent']
curtype = failnode['type']
if curpare == '/':
curpath = curpare + curnode
else:
curpath = curpare + '/' + curnode
if self.debug: print 'curpath is %s and nodename is %s.' % (curpath, nodename)
if nodename == curpath:
if self.debug: print 'We got a match, %s failed because of %s.' % (
nodename, curtype)
if curtype == 'load':
node_did_fail_on_load = 1
elif curtype == 'config':
node_did_fail_on_config = 1
else:
raise 'Unrecognized failure type: %s.' % curtype
# Don't need to check any further
break
else:
if self._path_is_parent(curpath, nodename):
if self.debug: print 'We found a parent who failed: %s.' % curpath
parent_did_fail = 1
# Don't need to check any further
break
if node_did_fail_on_config or node_did_fail_on_load:
node_did_fail = 1
# If the node didn't fail in load or config, but it didn't register either,
# then check to see if perhaps it exists, but didn't start. We detect this
# by doing an as_node on it. If this succeeds, we can check the node's state.
# If it doesn't succeed, then we can pretty safely assume that the node
# has been delete (or, unfortunately, is auto-discovered).
if not node_did_fail and not node_did_register:
try:
x = as_node(nodename)
node_did_fail_on_start = 1
node_did_fail = 1
if self.debug: print 'We were able to instantiate node: %s.' % nodename
except:
if self.debug: print 'Failed to instantiate node: %s.' % nodename
# The node doesn't seem to exist at all. Let the following code
# draw the appropriate conclusions.
pass
if not node_did_register:
if self.debug: print 'node_did_fail_on_load: %d.' % node_did_fail_on_load
if self.debug: print 'node_did_fail_on_config: %d.' % node_did_fail_on_config
if self.debug: print 'node_did_fail_on_start: %d.' % node_did_fail_on_start
if self.debug: print 'node_did_fail: %d.' % node_did_fail
if self.debug: print 'parent_did_fail: %d.' % parent_did_fail
if self.debug: print 'purge_type: %d.' % purge_type
# OK, the node didn't register. Check to see what we've
# been told to do in this case.
if node_did_fail and (purge_type == GC_ONFAILURE):
should_purge = 1
# For now, purge even if it was a parent who failed and purge_type
# is GC_ONFAILURE. @fixme: We need to think about if this is what
# we want to do or not.
if parent_did_fail and (purge_type == GC_ONFAILURE):
should_purge = 1
# If the node did not register and neither it nor a parent
# failed to start, then we assume that it has been deleted.
# Note: This does not seem to be correct for auto-discovered
# nodes, so we need a better way of detecting this case.
if (not node_did_fail) and (not parent_did_fail) and (purge_type == GC_ONDELETE):
should_purge = 1
# If the node did not register and we aren't going to purge it, then
# save it's registration information so that if circumstances change,
# we can consider purging it at some later date.
if (not node_did_register) and (not should_purge):
if self.debug: print '%s did not register, but we are registering for it.' % nodename
self._data.registered.append(regnode)
# OK, we've figured out that we should purge this persistent
# data. Go ahead and do so.
if should_purge:
if os.access(filename, os.F_OK):
if self.debug: print 'We decided we should purge the following file: %s.' % filename
msglog.log('garbage_collector',msglog.types.INFO,
'Purging the following persistent data file: %s on behalf of %s.' % (filename,
nodename))
try:
os.remove(filename)
except:
msglog.log('garbage_collector',msglog.types.INFO,
'Got exception trying to remove persistent data: %s.' % filename)
msglog.exception('garbage_collector')
else:
if self.debug: print '%s: Will SAVE the following file: %s.' % (nodename, filename)
if self.debug: print '---- Done Processing Potential Reaping List ----'
# Now, at long last, persist our own data.
self._data.save()
self._did_save = 1
self._post_configuration=1
def register(self, nodename, filename, type=None):
# Default to GC_ONDELETE
if type == None:
type = GC_ONDELETE
if self.debug: print '%s: Registered with type of %d.' % (nodename, type)
if self._post_configuration:
self._data.registered+=(
{'nodename':nodename, 'filename':filename, 'type':type},
)
else:
self._registered += (
{'nodename':nodename, 'filename':filename, 'type':type},
)
# If we have already saved our data, but just received a new registration,
# then save it again.
if self._did_save:
self._data.save()
def _path_is_parent(self, path, node):
# If they are the same, we aren't talking a parent/child relationship here
if path == node:
return 0
strind = string.find(node, path)
if strind == -1:
return 0
if strind == 0:
return 1
# If we got something other than -1 or 0 here, strange things are
# happening. Dump a message to msglog so that whatever is wrong
# can be fixed.
msglog.log(
'garbage_collector',msglog.types.INFO,
'_path_is_parent: Found %s at a weird spot in %s.' % (node,
parent)
)
return 1
##
# Return a tuple of dict()s describing all the registered PDOs.
# @note DO NOT MODIFY THE DICT()s IN THE TUPLE!
def registered_pdo_tuple(self):
return self._registered
class CloudConfigurator(CompositeNode):
def __init__(self, *args, **kw):
self.secured = True
self.path = "/cloudconfig"
self.manager = '/services/Cloud Manager'
self.security_manager = '/services/Security Manager'
super(CloudConfigurator, self).__init__(*args, **kw)
def configure(self, config):
self.secured = as_boolean(as_internal_node("/services").secured)
self.setattr('path', config.get('path',self.path))
self.setattr('manager', config.get('manager','/services/Cloud Manager'))
super(CloudConfigurator, self).configure(config)
def configuration(self):
config = super(CloudConfigurator, self).configuration()
config['path'] = self.getattr('path')
config['manager'] = self.getattr('manager')
config['secured'] = str(int(self.secured))
return config
def stop(self):
if not isinstance(self.manager, str):
self.manager.dispatcher.unregister(self.sub)
self.manager = as_node_url(self.manager)
if not isinstance(self.security_manager, str):
self.security_manager = as_node_url(self.security_manager)
return super(CloudConfigurator, self).stop()
def get_manager(self):
manager = self.manager
if self.secured:
manager = self.security_manager.as_secured_node(manager)
return manager
def match(self, path):
return path.startswith(self.path)
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 get_node_names(self):
formation = self.manager.get_formation()
norm_formation=self.manager.nformation.normalize_formation(formation)
ind=norm_formation.index(self.manager.peer)
# move the peer to be at the head of the list
p=formation.pop(ind)
formation.insert(0,p)
#insert manager at the very first place
portal=self.manager.get_portal()
if(portal == None):
formation.insert(0,"")
else:
formation.insert(0,portal)
return (formation)
def validate(self,name):
name=name.strip()
if ( not (valid_ip_address(name) or valid_hostname(name))):
return(1)
if(name == 'localhost' ):
return(1)
if(name == '127.0.0.1' ):
return(1)
return(0)
def handle_request(self, request):
pass
#create_node: name - name of the peer/portal
#config - type = config["type"] string will tell if this is a "Peer" or a "Portal"
def create_node(self, name, config=()):
config = dict(config)
type = config['type'].lower()
manager = self.get_manager()
# Next statements verify access to modifier permitted.
if type == "peer":
manager.add_peer
else:
manager.set_portal
config.setdefault("parent", self.manager)
peer_or_portal = config.setdefault("name", name).strip()
ret = self.validate(peer_or_portal)
if(ret != 0 ):
msg='Add Peer/Portal failed. %s is a invalid hostname/IP Address' %(peer_or_portal)
raise ValueError(msg)
if(valid_hostname(peer_or_portal)):
tmp=get_ip_addr(peer_or_portal)
if(not valid_ip_address(tmp) ):
raise ValueError('Cannot resolve the hostname %s. Please try with a valid Hostname' %(peer_or_portal))
if(type == 'peer'):
peer=peer_or_portal
if (self.manager.is_peer_in_formation(peer) == False):
if(self.manager.is_host_the_portal(peer) == False):
msg='Adding %s as a Peer' %str(peer)
msglog.log('CloudConfigurator', msglog.types.INFO,msg)
# Use possibly secured reference for the add.
manager.add_peer(peer)
else:
raise ValueError,'A Portal cannot be a Peer : "%s" is the Portal for the Cloud.' % peer
else:
raise ValueError,'Add peer did nothing: "%s" already in Cloud Formation.' % peer
else:
portal=peer_or_portal
if(self.manager.is_host_the_portal(portal) == False):
if (self.manager.is_peer_in_formation(portal) == False):
msg='Setting the Portal as :%s' %str(portal)
msglog.log('CloudConfigurator', msglog.types.INFO,msg)
# Use possibly secured reference for the modification.
manager.set_portal(portal)
else:
raise ValueError,'%s is in the formation. It cannot be added as Portal ' % portal
else:
raise ValueError,'Set Portal did nothing: "%s" already the Portal' % portal
return(peer_or_portal)
#remove_node: First check if name is manager then check in peer list to delete
def remove_node(self, name):
manager = self.get_manager()
formation=self.manager.get_formation()
if( name in formation ):
msg='Removing %s as a Peer' %str(name)
msglog.log('CloudConfigurator', msglog.types.INFO,msg)
manager.remove_peer(name)
else:
msg='Removing %s as a Portal' %str(name)
msglog.log('CloudConfigurator', msglog.types.INFO,msg)
manager.set_portal(None)
return name
class ScheduleConfigurator(CompositeNode):
LOADFAILURE = '"%s" failed to load %s "%s". Exception follows.'
def __init__(self, *args):
self._pdo = None
self.template = ""
self._pdo_lock = Lock()
self.page_template = "/templates/schedules.html"
super(ScheduleConfigurator, self).__init__(*args)
def configure(self, config):
self.setattr('path', config.get('path', '/scheduleconfig'))
self.secured = as_boolean(as_internal_node("/services").secured)
security_manager = config.get('security_manager',
'/services/Security Manager')
self.setattr('security_manager', security_manager)
super(ScheduleConfigurator, self).configure(config)
def configuration(self):
config = super(ScheduleConfigurator, self).configuration()
config['path'] = self.getattr('path')
config['security_manager'] = self.getattr('security_manager')
config['secured'] = str(self.getattr('secured'))
return config
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 stop(self):
super(ScheduleConfigurator, self).stop()
def match(self, path):
return path.startswith(self.path)
def message(self, message, *args, **kw):
mtype = kw.get("type", msglog.types.INFO)
if mtype != msglog.types.DB or self.debug:
message = message % args
msglog.log("broadway", mtype, "[%s] %s" % (self.name, message))
return True
return False
def debugout(self, *args, **kw):
kw.setdefault("type", msglog.types.DB)
return self.message(*args, **kw)
def configurenode(self, node, data):
config = {}
for fieldname in data.keys():
prefix, sep, attrname = fieldname.partition('.')
if sep and prefix == "configure":
values = map(urllib.unquote_plus, data[fieldname])
if (attrname == "name"):
#make sure the node name starts with RZSched_
#if not, append it.
if not values[0].startswith("RZSched_"):
values[0] = "RZSched_" + values[0]
config[attrname] = values[0]
self.message("configuring %s with %s", node, config)
try:
node.stop()
except:
msglog.exception(prefix='Handled')
node.configure(config)
try:
node.start()
except:
msglog.exception(prefix='Handled')
return node.parent
def createnode(self, node, data):
if IScheduleHolderParent.providedBy(node):
defaultname = "Holder %d"
nodetype = ScheduleHolder
elif IScheduleHolder.providedBy(node):
defaultname = "RZShed_%d"
nodetype = Schedule
else:
message = "createnode() does not know what to create for %s"
raise TypeError(message % node)
parentnode = node
if data.has_key("configure.name"):
childname = urllib.unquote_plus(data['configure.name'][0])
else:
index = len(parentnode.children_nodes()) + 1
childname = defaultname % index
while parentnode.has_child(childname):
index += 1
childname = defaultname % index
childname = defaultname % len(parentnode.children_nodes())
if not childname:
raise TypeError("Illegal node name: %r" % childname)
if IScheduleHolder.providedBy(node):
if childname == '':
error = "Holder name required"
raise TypeError(error)
if not childname.startswith("RZSched_"):
if childname.lower().startswith("rzsched_"):
childname = childname.lower().split("rzsched_")[1]
childname = "RZSched_" + childname
config = {
'name': childname,
'parent': parentnode,
'description': '',
'source': 'ScheduleConfigurator'
}
message = "createnode() creating %s type child of %s."
self.message(message, nodetype.__name__, parentnode)
childnode = nodetype()
childnode.configure(config)
return parentnode
def holder_parents(self):
children = as_node("/services/time").children_nodes()
return filter(IScheduleHolderParent.providedBy, children)
def holder_parent_names(self):
return [parent.name for parent in self.holder_parents()]
def schedule_holders(self, parent=None):
if parent is None:
parent = self.nodespace.as_node("/services/time/local")
return filter(IScheduleHolder.providedBy, parent.children_nodes())
def schedule_holder_names(self, parent=None):
return [holder.name for holder in self.schedule_holders(parent)]
def prunenode(self, node, data):
self.message("removing %s", as_node_url(node))
parentnode = node.parent
self.debugout("parent node %s", as_node_url(parentnode))
node.prune()
return parentnode
def handle_request(self, request):
response = Response(request)
data = request.get_post_data_as_dictionary()
data.update(request.get_query_string_as_dictionary())
if data.has_key("node"):
nodeurl = urllib.unquote_plus(data["node"][0])
else:
nodeurl = "/services/time/local"
try:
adapt = self.__handle_by_context(nodeurl, request, data)
except TypeError, error:
msglog.exception(prefix="handled")
response.send_error(500, str(error))
else:
def __init__(self):
PersistentDataObject.__init__(self, 'mpx.lib.user._UserDictionary')
self.users = {}
self.__lock = Lock()
