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)
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)