def emit_triggers(self): triggers = self.triggers_to_emit() if not triggers: return log.info(f"{self} publishing triggers: [{', '.join(triggers)}]") job_id = '.'.join(self.job_run_id.split('.')[:-1]) for trigger in triggers: EventBus.publish(f"{job_id}.{self.action_name}.{trigger}")
def _done(self, target, exit_status=0): if self.machine.check(target): if self.triggered_by: EventBus.clear_subscriptions(self.__hash__()) self.exit_status = exit_status self.end_time = timeutils.current_time() log.info(f"{self} completed with {target}, transitioned to " f"{self.state}, exit status: {exit_status}") return self.transition_and_notify(target) else: log.debug( f"{self} cannot transition from {self.state} via {target}")
def publish(self, event): if not EventBus.instance: return dict(error='EventBus disabled') if EventBus.has_event(event): msg = f"event {event} already published" log.warning(msg) return dict(response=msg) if not EventBus.publish(event): msg = f'could not publish {event}' log.error(msg) return dict(error=msg) return dict(response='OK')
def setup_subscriptions(self): remaining_triggers = self.remaining_triggers if not remaining_triggers: return if self.trigger_timeout_timestamp: now = timeutils.current_time().timestamp() delay = max(self.trigger_timeout_timestamp - now, 1) self.trigger_timeout_call = reactor.callLater( delay, self.trigger_timeout_reached) else: log.error(f"{self} has no trigger_timeout_timestamp") for trigger in remaining_triggers: EventBus.subscribe(trigger, self.__hash__(), self.trigger_notify)
def test_setup_eventbus_dir(self, time): os.rmdir(self.logdir.name) time.time = mock.Mock(return_value=1.0) eb = EventBus.create(self.logdir.name) assert os.path.exists(self.logdir.name) assert os.path.exists(os.path.join(self.logdir.name, "current")) time.time = mock.Mock(return_value=2.0) eb.event_log = {'foo': 'bar'} eb.sync_save_log("test") new_eb = EventBus.create(self.logdir.name) new_eb.sync_load_log() assert new_eb.event_log == eb.event_log
def setup_subscriptions(self): remaining_triggers = self.remaining_triggers if not remaining_triggers: return if self.trigger_timeout_timestamp: now = timeutils.current_time().timestamp() delay = max(self.trigger_timeout_timestamp - now, 1) self.trigger_timeout_call = reactor.callLater( delay, self.trigger_timeout_reached ) else: log.error(f"{self} has no trigger_timeout_timestamp") for trigger in remaining_triggers: EventBus.subscribe(trigger, self.__hash__(), self.trigger_notify)
def _done(self, target, exit_status=0): if self.machine.check(target): if self.triggered_by: EventBus.clear_subscriptions(self.__hash__()) self.clear_trigger_timeout() self.exit_status = exit_status self.end_time = timeutils.current_time() log.info( f"{self} completed with {target}, transitioned to " f"{self.state}, exit status: {exit_status}" ) return self.transition_and_notify(target) else: log.debug( f"{self} cannot transition from {self.state} via {target}" )
def emit_triggers(self): if isinstance(self.trigger_downstreams, bool): shortdate = self.render_template("{shortdate}") triggers = [f"shortdate.{shortdate}"] elif isinstance(self.trigger_downstreams, dict): triggers = [ f"{k}.{self.render_template(v)}" for k, v in self.trigger_downstreams.items() ] else: log.error(f"{self} trigger_downstreams must be true or dict") return log.info(f"{self} publishing triggers: [{', '.join(triggers)}]") job_id = '.'.join(self.job_run_id.split('.')[:-1]) for trigger in triggers: EventBus.publish(f"{job_id}.{self.action_name}.{trigger}")
def discard(self, event): if not EventBus.instance: return dict(error='EventBus disabled') if not EventBus.discard(event): msg = f"could not discard {event}" log.error(msg) return dict(error=msg) return dict(response='OK')
def configure_eventbus(self, enabled): if enabled: if not EventBus.instance: EventBus.create(f"{self.working_dir}/_events") EventBus.start() else: EventBus.shutdown()
def remaining_triggers(self): return [ trigger for trigger in map(self.render_template, self.triggered_by or []) if not EventBus.has_event(trigger) ]
def cleanup(self): self.clear_observers() if self.triggered_by: EventBus.clear_subscriptions(self.__hash__()) self.clear_trigger_timeout() self.cancel()
def remaining_triggers(self): return [ trig for trig in self.rendered_triggers if not EventBus.has_event(trig) ]
def shutdown(self): EventBus.shutdown() self.state_watcher.shutdown()
def cleanup(self): self.clear_observers() if self.triggered_by: EventBus.clear_subscriptions(self.__hash__()) self.cancel()
def teardown(self): EventBus.shutdown() self.log_dir.cleanup()
def setup(self): self.log_dir = tempfile.TemporaryDirectory(prefix="tron_eventbus_test") self.eventbus = EventBus.create(self.log_dir.name) self.eventbus.enabled = True
def setup_subscriptions(self): for trigger_pattern in self.triggered_by or []: trigger = self.render_template(trigger_pattern) EventBus.subscribe(trigger, self.__hash__(), self.trigger_notify)