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 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 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 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 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 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 remaining_triggers(self):
return [
trig for trig in self.rendered_triggers
if not EventBus.has_event(trig)
]
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)
def shutdown(self):
EventBus.shutdown()
self.state_watcher.shutdown()