class TriggersConfigurator(CompositeNode):
security = SecurityInformation.from_default()
secured_by(security)
def __init__(self, *args):
self._triggers = None
self.security_manager = None
self._pdo_lock = Lock()
super(TriggersConfigurator, self).__init__(*args)
def configure(self, config):
self.setattr('path', config.get('path','/triggerconfig'))
self.setattr('manager', config.get('container','/services/Trigger Manager'))
self.secured = as_internal_node("/services").secured
super(TriggersConfigurator, self).configure(config)
def configuration(self):
config = super(TriggersConfigurator, self).configuration()
config['path'] = self.getattr('path')
config['manager'] = self.getattr('manager')
return 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 stop(self):
super(TriggersConfigurator, self).stop()
self.manager = None
def _loadtriggers(self, names=None):
triggers = []
if names is None:
names = self._triggers.keys()
elif not isinstance(names, (list, tuple, set)):
names = [names]
for name in names:
dump = self._triggers[name]
try:
trigger = unmarshal(dump)
except:
msglog.log("broadway", msglog.types.WARN,
"Unable to load trigger: %s" % name)
msglog.exception(prefix="handled")
else:
triggers.append(trigger)
return triggers
def _storetriggers(self, triggers=None):
if triggers is None:
triggers = self.manager.get_triggers()
elif not isinstance(triggers, (list, set, tuple)):
triggers = [triggers]
for trigger in triggers:
try:
dump = marshal(trigger)
except:
msglog.log("broadway", msglog.types.WARN,
"Unable to marshal trigger: %s" % trigger.name)
msglog.exception(prefix="handled")
else:
self._triggers[trigger.name] = dump
return triggers
def _poptriggers(self, names=None):
if names is None:
existing = set(self.manager.get_trigger_names())
stored = self._triggers.keys()
names = set(stored) - set(existing)
elif not isinstance(names, (list, tuple, set)):
names = [names]
removed = []
for name in names:
try:
self._triggers.pop(name)
except:
msglog.log("broadway", msglog.types.WARN,
"Unable to remove trigger data: %s" % name)
msglog.exception(prefix="handled")
else:
removed.append(name)
return removed
def match(self, path):
return path.startswith(self.path)
security.protect('create_trigger', 'Configure')
security.protect('create_node', 'Configure')
def create_trigger(self, name, config=()):
config = dict(config)
if "type" in config:
type = config.pop("type")
else:
type = "ComparisonTrigger"
if isinstance(type, str):
if type.endswith("ComparisonTrigger"):
type = ComparisonTrigger
elif type.endswith("BoundTrigger"):
type = BoundTrigger
else:
raise ValueError("Uknown type: %r" % type)
config.setdefault("name", name)
config.setdefault("parent", self.manager)
trigger = self._create_trigger(type, config)
self._storetriggers([trigger])
return trigger.name
create_node = create_trigger
security.protect('remove_trigger', 'Configure')
security.protect('remove_node', 'Configure')
def remove_trigger(self, name):
self._remove_trigger(name)
self._poptriggers([name])
return name
remove_node = remove_trigger
security.protect('configure_trigger', 'Configure')
security.protect('configure_node', 'Configure')
def configure_trigger(self, name=None, config=()):
config = dict(config)
if name is None:
if config.has_key("name"):
name = config["name"]
else:
raise TypeError("configure_trigger() requires"
" name or configuration with name")
trigger = self.manager.get_trigger(name)
try:
trigger.stop()
except Exception, error:
msglog.log('broadway', msglog.types.WARN,
'Ignoring following exception on stop.')
msglog.exception(prefix = 'Handled')
trigger.configure(config)
try:
trigger.start()
except Exception, error:
msglog.log('broadway', msglog.types.WARN,
'Ignoring following exception on start.')
msglog.exception(prefix = 'Handled')
class TriggersConfigurator(CompositeNode):
security = SecurityInformation.from_default()
secured_by(security)
def __init__(self, *args):
self._triggers = None
self.security_manager = None
self._pdo_lock = Lock()
super(TriggersConfigurator, self).__init__(*args)
def configure(self, config):
self.setattr('path', config.get('path', '/triggerconfig'))
self.setattr('manager',
config.get('container', '/services/Trigger Manager'))
self.secured = as_internal_node("/services").secured
super(TriggersConfigurator, self).configure(config)
def configuration(self):
config = super(TriggersConfigurator, self).configuration()
config['path'] = self.getattr('path')
config['manager'] = self.getattr('manager')
return 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 stop(self):
super(TriggersConfigurator, self).stop()
self.manager = None
def _loadtriggers(self, names=None):
triggers = []
if names is None:
names = self._triggers.keys()
elif not isinstance(names, (list, tuple, set)):
names = [names]
for name in names:
dump = self._triggers[name]
try:
trigger = unmarshal(dump)
except:
msglog.log("broadway", msglog.types.WARN,
"Unable to load trigger: %s" % name)
msglog.exception(prefix="handled")
else:
triggers.append(trigger)
return triggers
def _storetriggers(self, triggers=None):
if triggers is None:
triggers = self.manager.get_triggers()
elif not isinstance(triggers, (list, set, tuple)):
triggers = [triggers]
for trigger in triggers:
try:
dump = marshal(trigger)
except:
msglog.log("broadway", msglog.types.WARN,
"Unable to marshal trigger: %s" % trigger.name)
msglog.exception(prefix="handled")
else:
self._triggers[trigger.name] = dump
return triggers
def _poptriggers(self, names=None):
if names is None:
existing = set(self.manager.get_trigger_names())
stored = self._triggers.keys()
names = set(stored) - set(existing)
elif not isinstance(names, (list, tuple, set)):
names = [names]
removed = []
for name in names:
try:
self._triggers.pop(name)
except:
msglog.log("broadway", msglog.types.WARN,
"Unable to remove trigger data: %s" % name)
msglog.exception(prefix="handled")
else:
removed.append(name)
return removed
def match(self, path):
return path.startswith(self.path)
security.protect('create_trigger', 'Configure')
security.protect('create_node', 'Configure')
def create_trigger(self, name, config=()):
config = dict(config)
if "type" in config:
type = config.pop("type")
else:
type = "ComparisonTrigger"
if isinstance(type, str):
if type.endswith("ComparisonTrigger"):
type = ComparisonTrigger
elif type.endswith("BoundTrigger"):
type = BoundTrigger
else:
raise ValueError("Uknown type: %r" % type)
config.setdefault("name", name)
config.setdefault("parent", self.manager)
trigger = self._create_trigger(type, config)
self._storetriggers([trigger])
return trigger.name
create_node = create_trigger
security.protect('remove_trigger', 'Configure')
security.protect('remove_node', 'Configure')
def remove_trigger(self, name):
self._remove_trigger(name)
self._poptriggers([name])
return name
remove_node = remove_trigger
security.protect('configure_trigger', 'Configure')
security.protect('configure_node', 'Configure')
def configure_trigger(self, name=None, config=()):
config = dict(config)
if name is None:
if config.has_key("name"):
name = config["name"]
else:
raise TypeError("configure_trigger() requires"
" name or configuration with name")
trigger = self.manager.get_trigger(name)
try:
trigger.stop()
except Exception, error:
msglog.log('broadway', msglog.types.WARN,
'Ignoring following exception on stop.')
msglog.exception(prefix='Handled')
trigger.configure(config)
try:
trigger.start()
except Exception, error:
msglog.log('broadway', msglog.types.WARN,
'Ignoring following exception on start.')
msglog.exception(prefix='Handled')
class TrendManager(CompositeNode):
implements(ITrendManager)
security = SecurityInformation.from_default()
secured_by(security)
def __init__(self, *args):
super(TrendManager, self).__init__(*args)
self.logger_url = None
self.trends = None
self._pdo_lock = Lock()
self._trendconfig = None
self.__running = False
self.secured = True
return
def _persist_trend_configuration(self, trend):
self._pdo_lock.acquire()
try:
self._trendconfig[trend.name] = marshal(trend)
finally:
self._pdo_lock.release()
return
def _delete_trend_configuration(self, trend_name):
self._pdo_lock.acquire()
try:
if self._trendconfig.has_key(trend_name):
del self._trendconfig[trend_name]
finally:
self._pdo_lock.release()
return
def configure(self, config):
self.setattr("name", config.get("name", "Trend Manager"))
self.setattr("logger_url", config.get("logger_url", "/services/logger"))
self.secured = as_internal_node("/services").secured
super(TrendManager, self).configure(config)
return
def configuration(self):
config = super(TrendManager, self).configuration()
config["logger_url"] = self.getattr("logger_url")
return config
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 stop(self):
self.__running = False
super(TrendManager, self).stop()
return
def is_trendable(self, log_node):
if log_node.configuration().has_key("period"):
# Assume a log with a period is valid.
return True
if not log_node.has_child("columns"):
# If the log does not have a columns container, than it doesn't
# look like a proper log.
return False
column_nodes = log_node.get_child("columns").children_nodes()
if not column_nodes:
# If the log does not have any columns, than it doesn't
# look like a proper log.
return False
if len(column_nodes) > MAX_TRENDABLE_COLUMNS:
# If the log has more than MAX_TRENDABLE_COLUMNS (9), then the
# EmbeddedGraph can not display it.
return False
has_timestamp = False
for column in column_nodes:
column_configuration = column.configuration()
if not column_configuration.has_key("name"):
# OK, this should NEVER happen...
return False
if column_configuration["name"] == "timestamp":
has_timestamp = True
if not column_configuration.has_key("conversion"):
# To be safe, each column must have a conversion...
return False
if column_configuration["conversion"] != "magnitude":
# And the conversion must be a 'magnitude'
return False
if not has_timestamp:
# Graph requires a timestamp.
return False
return True
security.protect("get_trends", "View")
def get_trends(self):
if not self.__running:
raise ENotRunning()
trend_names = []
for name in self.trends.children_names():
trend_names.append(name)
for log_node in self.logger.children_nodes():
trend_name = log_node.name
if not trend_name in trend_names:
if self.is_trendable(log_node):
trend_adapter = PeriodicLogTrendAdapter()
trend_adapter.configure({"parent": self.trends, "name": trend_name})
trend_adapter.start()
self._persist_trend_configuration(trend_adapter)
trend_names.append(trend_name)
trend_names.sort()
trends = []
for trend_name in trend_names:
trends.append(self.trends.get_child(trend_name))
return trends
security.protect("get_trend", "View")
def get_trend(self, trend_name):
if not self.__running:
raise ENotRunning()
if not self.trends.has_child(trend_name):
# Autodiscoveresque.
self.get_trends()
# @fixme Raise a better exception...
return self.trends.get_child(trend_name)
def get_trend_preferences(self, trend_name):
trend_name = urllib.unquote_plus(trend_name)
trend = self.get_trend(trend_name)
preferences = trend.get_preferences()
points = trend.get_points()
for i in xrange(0, len(points)):
try:
points[i]["color"] = preferences["points"][i]["color"] = "#%06X" % int(
preferences["points"][i]["color"]
)
except:
points[i]["color"] = preferences["points"][i]["color"]
points[i]["y-axis"] = preferences["points"][i]["y-axis"]
preferences["points"] = points
try:
preferences["background"]["color"] = "#%06X" % int(preferences["background"]["color"])
except:
pass
try:
preferences["text"]["color"] = "#%06X" % int(preferences["text"]["color"])
except:
pass
msglog.log("broadway", msglog.types.INFO, "Preferences: %r" % preferences)
return preferences
security.protect("delete_trend", "Configure")
def delete_trend(self, trend_name):
if not self.__running:
raise ENotRunning()
self._delete_trend_configuration(trend_name)
if not self.trends.has_child(trend_name):
# Autodiscoveresque.
self.get_trends()
# @fixme Raise a better exception...
trend = self.trends.get_child(trend_name)
trend.prune()
trend.destroy()
return
security.protect("update_trend", "Configure")
def update_trend(self, trend_name, new_cfg, **kw):
if not self.__running:
raise ENotRunning()
confirmed = kw.get("confirmed", 0)
deletedata = kw.get("deletedata", 0)
trend = self.get_trend(trend_name)
confirmation = ConfirmUpdateTrend(trend, new_cfg)
# @fixme, dleimbro
if 0: # not confirmed and confirmation.requires_confirmation():
return confirmation
if confirmation.configuration_changed():
try:
if deletedata:
trend.delete_existing_data()
if confirmation.requires_stop_and_restart():
trend.stop()
trend.configure(confirmation.configuration())
if confirmation.requires_stop_and_restart():
trend.start()
except:
msglog.exception()
try:
trend.stop()
except:
msglog.exception()
trend.configure(confirmation.original_configuration())
trend.start()
raise
else:
self._persist_trend_configuration(trend)
return None
def _new_trend(self, name):
if not self.__running:
raise ENotRunning()
"""
Return an instance that implements ITrend interface for new trend with
no points.
"""
new_trend = Trend()
period = 60
points = []
preferences = {}
new_trend.configure(
{"parent": self.trends, "name": name, "period": period, "points": points, "preferences": preferences}
)
return new_trend
security.protect("new_trend", "Configure")
def new_trend(self, name=None):
if name:
return self._new_trend(name)
while True:
try:
new_trend = self._new_trend(self.generate_trend_name())
break # was going into loop and generating thousands of trends.
# This breaks loop when an unused (generated) trend name is found
except ENameInUse:
continue
return new_trend
security.protect("generate_trend_name", "View")
def generate_trend_name(self):
i_trend = 1
while True:
try:
self.get_trend("Trend %d" % i_trend)
i_trend += 1
except ENoSuchName:
break
return "Trend %d" % i_trend
class TrendManager(CompositeNode):
implements(ITrendManager)
security = SecurityInformation.from_default()
secured_by(security)
def __init__(self, *args):
super(TrendManager, self).__init__(*args)
self.logger_url = None
self.trends = None
self._pdo_lock = Lock()
self._trendconfig = None
self.__running = False
self.secured = True
return
def _persist_trend_configuration(self, trend):
self._pdo_lock.acquire()
try:
self._trendconfig[trend.name] = marshal(trend)
finally:
self._pdo_lock.release()
return
def _delete_trend_configuration(self, trend_name):
self._pdo_lock.acquire()
try:
if self._trendconfig.has_key(trend_name):
del self._trendconfig[trend_name]
finally:
self._pdo_lock.release()
return
def configure(self, config):
self.setattr('name', config.get('name', 'Trend Manager'))
self.setattr('logger_url', config.get('logger_url',
'/services/logger'))
self.secured = as_internal_node("/services").secured
super(TrendManager, self).configure(config)
return
def configuration(self):
config = super(TrendManager, self).configuration()
config['logger_url'] = self.getattr('logger_url')
return config
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 stop(self):
self.__running = False
super(TrendManager, self).stop()
return
def is_trendable(self, log_node):
if log_node.configuration().has_key('period'):
# Assume a log with a period is valid.
return True
if not log_node.has_child('columns'):
# If the log does not have a columns container, than it doesn't
# look like a proper log.
return False
column_nodes = log_node.get_child('columns').children_nodes()
if not column_nodes:
# If the log does not have any columns, than it doesn't
# look like a proper log.
return False
if len(column_nodes) > MAX_TRENDABLE_COLUMNS:
# If the log has more than MAX_TRENDABLE_COLUMNS (9), then the
# EmbeddedGraph can not display it.
return False
has_timestamp = False
for column in column_nodes:
column_configuration = column.configuration()
if not column_configuration.has_key('name'):
# OK, this should NEVER happen...
return False
if column_configuration['name'] == 'timestamp':
has_timestamp = True
if not column_configuration.has_key('conversion'):
# To be safe, each column must have a conversion...
return False
if column_configuration['conversion'] != 'magnitude':
# And the conversion must be a 'magnitude'
return False
if not has_timestamp:
# Graph requires a timestamp.
return False
return True
security.protect('get_trends', 'View')
def get_trends(self):
if not self.__running: raise ENotRunning()
trend_names = []
for name in self.trends.children_names():
trend_names.append(name)
for log_node in self.logger.children_nodes():
trend_name = log_node.name
if not trend_name in trend_names:
if (self.is_trendable(log_node)):
trend_adapter = PeriodicLogTrendAdapter()
trend_adapter.configure({
'parent': self.trends,
'name': trend_name,
})
trend_adapter.start()
self._persist_trend_configuration(trend_adapter)
trend_names.append(trend_name)
trend_names.sort()
trends = []
for trend_name in trend_names:
trends.append(self.trends.get_child(trend_name))
return trends
security.protect('get_trend', 'View')
def get_trend(self, trend_name):
if not self.__running: raise ENotRunning()
if not self.trends.has_child(trend_name):
# Autodiscoveresque.
self.get_trends()
# @fixme Raise a better exception...
return self.trends.get_child(trend_name)
def get_trend_preferences(self, trend_name):
trend_name = urllib.unquote_plus(trend_name)
trend = self.get_trend(trend_name)
preferences = trend.get_preferences()
points = trend.get_points()
for i in xrange(0, len(points)):
try:
points[i]["color"] = preferences["points"][i][
"color"] = "#%06X" % int(preferences["points"][i]["color"])
except:
points[i]["color"] = preferences["points"][i]["color"]
points[i]["y-axis"] = preferences["points"][i]["y-axis"]
preferences["points"] = points
try:
preferences["background"]["color"] = "#%06X" % int(
preferences["background"]["color"])
except:
pass
try:
preferences["text"]["color"] = "#%06X" % int(
preferences["text"]["color"])
except:
pass
msglog.log("broadway", msglog.types.INFO,
"Preferences: %r" % preferences)
return preferences
security.protect('delete_trend', 'Configure')
def delete_trend(self, trend_name):
if not self.__running: raise ENotRunning()
self._delete_trend_configuration(trend_name)
if not self.trends.has_child(trend_name):
# Autodiscoveresque.
self.get_trends()
# @fixme Raise a better exception...
trend = self.trends.get_child(trend_name)
trend.prune()
trend.destroy()
return
security.protect('update_trend', 'Configure')
def update_trend(self, trend_name, new_cfg, **kw):
if not self.__running: raise ENotRunning()
confirmed = kw.get('confirmed', 0)
deletedata = kw.get('deletedata', 0)
trend = self.get_trend(trend_name)
confirmation = ConfirmUpdateTrend(trend, new_cfg)
#@fixme, dleimbro
if 0: #not confirmed and confirmation.requires_confirmation():
return confirmation
if confirmation.configuration_changed():
try:
if deletedata:
trend.delete_existing_data()
if confirmation.requires_stop_and_restart():
trend.stop()
trend.configure(confirmation.configuration())
if confirmation.requires_stop_and_restart():
trend.start()
except:
msglog.exception()
try:
trend.stop()
except:
msglog.exception()
trend.configure(confirmation.original_configuration())
trend.start()
raise
else:
self._persist_trend_configuration(trend)
return None
def _new_trend(self, name):
if not self.__running: raise ENotRunning()
"""
Return an instance that implements ITrend interface for new trend with
no points.
"""
new_trend = Trend()
period = 60
points = []
preferences = {}
new_trend.configure({
'parent': self.trends,
'name': name,
'period': period,
'points': points,
'preferences': preferences
})
return new_trend
security.protect('new_trend', 'Configure')
def new_trend(self, name=None):
if name:
return self._new_trend(name)
while True:
try:
new_trend = self._new_trend(self.generate_trend_name())
break #was going into loop and generating thousands of trends.
#This breaks loop when an unused (generated) trend name is found
except ENameInUse:
continue
return new_trend
security.protect('generate_trend_name', 'View')
def generate_trend_name(self):
i_trend = 1
while True:
try:
self.get_trend('Trend %d' % i_trend)
i_trend += 1
except ENoSuchName:
break
return ('Trend %d' % i_trend)
class EquipmentMonitor(CompositeNode):
implements(IEquipmentMonitor)
def __init__(self, *args):
self.test_machines = []
self.synclock = RLock()
self.threadcount = 1
self.formatter = None
self.transporter = None
self.smservice = None
self.subscriptions = None
self.running = Flag()
self.work_threads = []
self.work_queue = Queue()
self.scheduling_lock = Lock()
self.execution_groups = Dictionary()
self.smnodeurl = '/services/Subscription Manager'
super(EquipmentMonitor, self).__init__(*args)
def configure(self, config):
self.smnodeurl = config.get('subscription_manager', self.smnodeurl)
self.threadcount = int(config.get('threadcount', self.threadcount))
super(EquipmentMonitor, self).configure(config)
def configuration(self):
config = super(EquipmentMonitor, self).configuration()
config['subscription_manager'] = self.smnodeurl
config['threadcount'] = str(self.threadcount)
return config
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()
def stop(self):
if not self.is_running():
raise TypeError('Equipment Monitor not running.')
self.synclock.acquire()
try:
self.running.clear()
message = "Equipment Monitor shutdown: %s %s"
for subscription in self.subscriptions.values():
try:
subscription.stop()
except:
msglog.exception(prefix='Handled')
else:
self.debugout(message % ('stopped', subscription))
self.teardown_work_threads()
except:
message = "Exception caused Eqiupment Monitor shutdown to fail."
msglog.log('broadway', msglog.types.ERR, message)
self.running.set()
raise
else:
self.cleanup_resources()
finally:
self.synclock.release()
super(EquipmentMonitor, self).stop()
def get_subscription(self, sid, default = None):
return self.subscriptions.get(sid, default)
def get_subscription_manager(self):
return self.smservice
def get_formatter(self):
return self.formatter
def get_transporter(self):
return self.transporter
def schedule_subscription(self, subscription, timestamp):
self.scheduling_lock.acquire()
try:
schedulegroup = self.execution_groups.get(timestamp)
if schedulegroup is None:
schedulegroup = SubscriptionGroup(self, timestamp)
self.execution_groups[timestamp] = schedulegroup
schedulegroup.scheduled = scheduler.at(
timestamp, schedulegroup.execute)
schedentry = schedulegroup.add_subscription(subscription)
finally:
self.scheduling_lock.release()
return schedentry
def enqueue_work(self, callback, *args):
self.work_queue.put((callback, args))
def dequeue_work(self, blocking = True):
return self.work_queue.get(blocking)
def is_running(self):
return self.running.isSet()
def assert_running(self):
if not self.is_running():
raise TypeError('Service must be running.')
return
def create_pushed(self, target, node_table, period=2, retries=10):
self.assert_running()
pushed = PushedSubscription(self, target, node_table, period, retries)
sid = pushed.setup_subscription()
self.subscriptions[sid] = pushed
message = ['Equipment Monitor created subscription: ']
message.append('Target URL: %s' % target)
message.append('Period: %d sec' % period)
message.append('Subscription ID: %s' % sid)
if isinstance(node_table, str):
message.append('Subscription for children of: %s' % node_table)
else:
firstthree = node_table.items()[0:3]
message.append('Number of nodes: %d' % len(node_table))
message.append('First three nodes: %s' % (firstthree,))
self.debugout('\n '.join(message), 2)
pushed.start(1)
return sid
def cancel(self, sid):
self.assert_running()
if self.pause(sid):
subscription = self.subscriptions.pop(sid)
message = 'Equipment Monitor cancelled subscription: "%s"'
self.debugout(message % sid, 2)
return True
return False
def pause(self, sid, delay = None):
subscription = self.subscriptions.get(sid)
if subscription and subscription.is_running():
subscription.stop()
return True
else:
return False
def play(self, sid):
self.assert_running()
subscription = self.subscriptions[sid]
if not subscription.is_running():
subscription.start()
return True
else:
return False
def reset(self, sid):
subscription = self.subscriptions.get(sid)
if subscription:
subscription.reset_subscription()
return True
else:
return False
def list_subscriptions(self):
return self.subscriptions.keys()
def notify_group_executed(self, group):
self.scheduling_lock.acquire()
try:
self.execution_groups.pop(group.timestamp)
finally:
self.scheduling_lock.release()
def cleanup_resources(self):
self.synclock.acquire()
try:
for group in self.execution_groups:
try:
group.scheduled.cancel()
except:
msglog.exception(prefix="handled")
self.execution_groups.clear()
try:
while self.work_queue.get_nowait():
pass
except Empty:
pass
if self.transporter:
commonitor = self.transporter.monitor
transmanager = self.transporter.transaction_manager
try:
commonitor.shutdown_channels()
except:
msglog.exception(prefix="handled")
transmanager.controllers.clear()
if self.subscriptions and not self.subscriptions.closed():
self.subscriptions.close()
self.subscriptions = None
self.transporter = None
self.formatter = None
finally:
self.synclock.release()
def setup_work_threads(self):
assert self.is_running()
assert len(self.work_threads) == 0
while len(self.work_threads) < self.threadcount:
monitor = WorkThread(self.is_running, self.dequeue_work)
monitor.setDaemon(True)
monitor.start()
self.work_threads.append(monitor)
return len(self.work_threads)
def teardown_work_threads(self):
assert not self.is_running()
threadcount = len(self.work_threads)
map(self.work_queue.put, [None] * threadcount)
while self.work_threads:
self.work_threads.pop().join()
return threadcount
def serialize_subscription(self, subscription):
return repr(subscription.as_dictionary())
def unserialize_subscription(self, data):
return PushedSubscription.from_dictionary(eval(data))
def debugout(self, dbmessage, dblevel = 1):
if dblevel <= DEBUG:
msglog.log('broadway', msglog.types.DB, dbmessage)
class EquipmentMonitor(CompositeNode):
implements(IEquipmentMonitor)
def __init__(self, *args):
self.test_machines = []
self.synclock = RLock()
self.threadcount = 1
self.formatter = None
self.transporter = None
self.smservice = None
self.subscriptions = None
self.running = Flag()
self.work_threads = []
self.work_queue = Queue()
self.scheduling_lock = Lock()
self.execution_groups = Dictionary()
self.smnodeurl = '/services/Subscription Manager'
super(EquipmentMonitor, self).__init__(*args)
def configure(self, config):
self.smnodeurl = config.get('subscription_manager', self.smnodeurl)
self.threadcount = int(config.get('threadcount', self.threadcount))
super(EquipmentMonitor, self).configure(config)
def configuration(self):
config = super(EquipmentMonitor, self).configuration()
config['subscription_manager'] = self.smnodeurl
config['threadcount'] = str(self.threadcount)
return config
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()
def stop(self):
if not self.is_running():
raise TypeError('Equipment Monitor not running.')
self.synclock.acquire()
try:
self.running.clear()
message = "Equipment Monitor shutdown: %s %s"
for subscription in self.subscriptions.values():
try:
subscription.stop()
except:
msglog.exception(prefix='Handled')
else:
self.debugout(message % ('stopped', subscription))
self.teardown_work_threads()
except:
message = "Exception caused Eqiupment Monitor shutdown to fail."
msglog.log('broadway', msglog.types.ERR, message)
self.running.set()
raise
else:
self.cleanup_resources()
finally:
self.synclock.release()
super(EquipmentMonitor, self).stop()
def get_subscription(self, sid, default=None):
return self.subscriptions.get(sid, default)
def get_subscription_manager(self):
return self.smservice
def get_formatter(self):
return self.formatter
def get_transporter(self):
return self.transporter
def schedule_subscription(self, subscription, timestamp):
self.scheduling_lock.acquire()
try:
schedulegroup = self.execution_groups.get(timestamp)
if schedulegroup is None:
schedulegroup = SubscriptionGroup(self, timestamp)
self.execution_groups[timestamp] = schedulegroup
schedulegroup.scheduled = scheduler.at(timestamp,
schedulegroup.execute)
schedentry = schedulegroup.add_subscription(subscription)
finally:
self.scheduling_lock.release()
return schedentry
def enqueue_work(self, callback, *args):
self.work_queue.put((callback, args))
def dequeue_work(self, blocking=True):
return self.work_queue.get(blocking)
def is_running(self):
return self.running.isSet()
def assert_running(self):
if not self.is_running():
raise TypeError('Service must be running.')
return
def create_pushed(self, target, node_table, period=2, retries=10):
self.assert_running()
pushed = PushedSubscription(self, target, node_table, period, retries)
sid = pushed.setup_subscription()
self.subscriptions[sid] = pushed
message = ['Equipment Monitor created subscription: ']
message.append('Target URL: %s' % target)
message.append('Period: %d sec' % period)
message.append('Subscription ID: %s' % sid)
if isinstance(node_table, str):
message.append('Subscription for children of: %s' % node_table)
else:
firstthree = node_table.items()[0:3]
message.append('Number of nodes: %d' % len(node_table))
message.append('First three nodes: %s' % (firstthree, ))
self.debugout('\n '.join(message), 2)
pushed.start(1)
return sid
def cancel(self, sid):
self.assert_running()
if self.pause(sid):
subscription = self.subscriptions.pop(sid)
message = 'Equipment Monitor cancelled subscription: "%s"'
self.debugout(message % sid, 2)
return True
return False
def pause(self, sid, delay=None):
subscription = self.subscriptions.get(sid)
if subscription and subscription.is_running():
subscription.stop()
return True
else:
return False
def play(self, sid):
self.assert_running()
subscription = self.subscriptions[sid]
if not subscription.is_running():
subscription.start()
return True
else:
return False
def reset(self, sid):
subscription = self.subscriptions.get(sid)
if subscription:
subscription.reset_subscription()
return True
else:
return False
def list_subscriptions(self):
return self.subscriptions.keys()
def notify_group_executed(self, group):
self.scheduling_lock.acquire()
try:
self.execution_groups.pop(group.timestamp)
finally:
self.scheduling_lock.release()
def cleanup_resources(self):
self.synclock.acquire()
try:
for group in self.execution_groups:
try:
group.scheduled.cancel()
except:
msglog.exception(prefix="handled")
self.execution_groups.clear()
try:
while self.work_queue.get_nowait():
pass
except Empty:
pass
if self.transporter:
commonitor = self.transporter.monitor
transmanager = self.transporter.transaction_manager
try:
commonitor.shutdown_channels()
except:
msglog.exception(prefix="handled")
transmanager.controllers.clear()
if self.subscriptions and not self.subscriptions.closed():
self.subscriptions.close()
self.subscriptions = None
self.transporter = None
self.formatter = None
finally:
self.synclock.release()
def setup_work_threads(self):
assert self.is_running()
assert len(self.work_threads) == 0
while len(self.work_threads) < self.threadcount:
monitor = WorkThread(self.is_running, self.dequeue_work)
monitor.setDaemon(True)
monitor.start()
self.work_threads.append(monitor)
return len(self.work_threads)
def teardown_work_threads(self):
assert not self.is_running()
threadcount = len(self.work_threads)
map(self.work_queue.put, [None] * threadcount)
while self.work_threads:
self.work_threads.pop().join()
return threadcount
def serialize_subscription(self, subscription):
return repr(subscription.as_dictionary())
def unserialize_subscription(self, data):
return PushedSubscription.from_dictionary(eval(data))
def debugout(self, dbmessage, dblevel=1):
if dblevel <= DEBUG:
msglog.log('broadway', msglog.types.DB, dbmessage)
