def _on_died(self, state, partner, blackbox, sender):
f = fiber.wrap_defer(partner.call_mro, 'on_died',
agent=state.agent,
brothers=blackbox,
monitor=sender)
f.add_errback(self._error_handler)
return f
def notify_finish(self):
if self._failed:
return fiber.fail(self._result)
elif self._finished:
return fiber.succeed(self._result)
else:
return fiber.wrap_defer(self._notifier.wait, "finished")
def initiate(self, state):
desc = state.medium.get_descriptor()
for required in ['django_settings_module', 'port']:
if not getattr(desc, required):
return fiber.fail(error.FeatError(
"Cannot start without required parameter: %r" % required))
for key, value in desc.environment.items():
self.info("Setting %s=%r environment variable.", key, value)
os.environ[key] = str(value)
for element in reversed(desc.python_path):
self.info("Injecting %r to the python path.", element)
sys.path.insert(0, element)
hostname = desc.hostname or state.medium.get_hostname()
stats = None
if desc.elflog_path:
path = desc.elflog_path
if not os.path.isabs(path):
path = os.path.join(configure.logdir, path)
stats = webserver.ELFLog(path, desc.elflog_fields)
if desc.p12_path and not os.path.isabs(desc.p12_path):
p12_path = os.path.join(configure.confdir, desc.p12_path)
else:
p12_path = desc.p12_path
security_policy = None
if p12_path:
if not os.path.exists(p12_path):
return fiber.fail(error.FeatError(
"P12 file was specified, but doesn't exist. Path: %s." %
(self.p12_path, )))
fac = security.ServerContextFactory(
p12_filename=p12_path,
enforce_cert=desc.check_client_cert,
verify_ca_from_p12=True)
security_policy = security.ServerPolicy(fac)
thread_stats_file = None
if desc.enable_statistics:
thread_stats_file = desc.statistics_db_file
if (thread_stats_file != ':memory:' and
not os.path.isabs(thread_stats_file)):
thread_stats_file = os.path.join(configure.logdir,
thread_stats_file)
# enable image/png content-type and give it a higher
# priority than application/json
server = state.medium.agency._gateway._server
server.enable_mime_type('image/png', 1)
state.server = self.dependency(IServerFactory,
self, desc.port,
str(desc.django_settings_module),
hostname,
prefix=desc.prefix,
interface=desc.interface,
security_policy=security_policy,
server_stats=stats,
thread_stats_file=thread_stats_file)
return fiber.wrap_defer(state.server.initiate)
def alert_resolved(self, state, alert):
r = self._find_entry(alert)
should_notify = (r.received_count > 0 or
r.status_info != alert.status_info)
r.received_count = 0
r.status_info = alert.status_info
if should_notify:
return fiber.wrap_defer(state.nagios.send, [r])
def initiate(self, state):
partners = state.partners.hosts
fibers = list()
for partner in partners:
f = fiber.wrap_defer(state.medium.check_if_hosted, partner.recipient.key)
f.add_callback(self.fixup_host_role, partner)
fibers.append(f)
f = fiber.FiberList(fibers, consumeErrors=True)
return f.succeed()
def push_notifications(self, state):
'''
Triggered by nagios_agent after he has restarted the nagios in order
to get the fresh notifications there.
This method is also run once an hour by recurring task, so that
nagios wouldnt ever have to run check_dummy check.'''
self.debug("Pushing all notifications to nagios.")
f = fiber.wrap_defer(state.nagios.send, state.alerts.values())
f.add_callback(fiber.override_result, None)
return f
def initiate(self, state):
self.may_raise_alert(alert.DynamicAlert(
name=ALERT_NAME,
severity=alert.Severity.warn,
description=ALERT_NAME))
state.unsolvable_conflicts = set()
state.db_config = c = state.medium.agency.get_config().db
f = fiber.wrap_defer(conflicts.configure_replicator_database,
c.host, c.port, c.username, c.password)
f.add_callback(self._replicator_configured)
return f
def alert_resolved(self, state, alert):
if not self._check_should_handle_alert(alert):
return
r = self._find_entry(alert)
should_notify = (r.received_count > 0 or
r.status_info != alert.status_info)
r.received_count = 0
r.status_info = alert.status_info
r.severity = Severity.ok
if should_notify:
f = fiber.wrap_defer(state.nagios.send, [r])
if r.persistent:
f.add_callback(self._update_persistent_alert, r)
return f
def delete_document(self, state, doc):
return fiber.wrap_defer(state.medium.delete_document, doc)
def get_document(self, state, doc_id):
return fiber.wrap_defer(state.medium.get_document, doc_id)
def wait_for_ready(self, state):
return fiber.wrap_defer(state.medium.wait_for_state, AgencyAgentState.ready)
def request_starting_partner(self, state, factory):
task = self.initiate_protocol(StartPartner, factory)
return fiber.wrap_defer(task.notify_finish)
def update_descriptor(self, method, *args, **kwargs):
return fiber.wrap_defer(self._update_descriptor, method,
*args, **kwargs)
def shutdown(self, state):
state.cache.cleanup()
return fiber.wrap_defer(state.labour.cleanup)
def notify_finish(self):
return fiber.wrap_defer(observer.Observer.notify_finish, self)
def query_view(self, factory, **kwargs):
return fiber.wrap_defer(self._db.query_view, factory, **kwargs)
def save_document(self, document):
return fiber.wrap_defer(self._db.save_document, document)
def shutdown(self, state):
self.info("Shutdown called")
if hasattr(state, 'server'):
return fiber.wrap_defer(state.server.cleanup)
def wait(self, notification, timeout=None):
return fiber.wrap_defer(self._wait, notification, timeout)
def on_killed(self, state):
if hasattr(state, 'server'):
self.info("on_killed called")
return fiber.wrap_defer(state.server.cleanup)
def notify_finish(self, state):
return fiber.wrap_defer(state.medium.notify_finish)
def notify_state(self, state, *states):
return fiber.wrap_defer(state.medium.wait_for_state, *states)
def query_view(self, state, factory, **options):
return fiber.wrap_defer(state.medium.query_view, factory, **options)
def save_document(self, state, doc):
return fiber.wrap_defer(state.medium.save_document, doc)
def get_attachment_body(self, state, attachment):
return fiber.wrap_defer(state.medium.get_attachment_body, attachment)
def on_killed(self, state):
state.cache.cleanup()
return fiber.wrap_defer(state.labour.cleanup)
def register_change_listener(self, state, filter_, callback, **kwargs):
return fiber.wrap_defer(state.medium.register_change_listener,
filter_, callback, **kwargs)
def get_document(self, doc_id):
return fiber.wrap_defer(self._db.get_document, doc_id)
def initiate(self, state):
desc = state.medium.get_descriptor()
for required in ['django_settings_module', 'port']:
if not getattr(desc, required):
return fiber.fail(
error.FeatError(
"Cannot start without required parameter: %r" %
required))
for key, value in desc.environment.items():
self.info("Setting %s=%r environment variable.", key, value)
os.environ[key] = str(value)
for element in reversed(desc.python_path):
self.info("Injecting %r to the python path.", element)
sys.path.insert(0, element)
hostname = desc.hostname or state.medium.get_hostname()
stats = None
if desc.elflog_path:
path = desc.elflog_path
if not os.path.isabs(path):
path = os.path.join(configure.logdir, path)
stats = webserver.ELFLog(path, desc.elflog_fields)
if desc.p12_path and not os.path.isabs(desc.p12_path):
p12_path = os.path.join(configure.confdir, desc.p12_path)
else:
p12_path = desc.p12_path
security_policy = None
if p12_path:
if not os.path.exists(p12_path):
return fiber.fail(
error.FeatError(
"P12 file was specified, but doesn't exist. Path: %s."
% (self.p12_path, )))
fac = security.ServerContextFactory(
p12_filename=p12_path,
enforce_cert=desc.check_client_cert,
verify_ca_from_p12=True)
security_policy = security.ServerPolicy(fac)
thread_stats_file = None
if desc.enable_statistics:
thread_stats_file = desc.statistics_db_file
if (thread_stats_file != ':memory:'
and not os.path.isabs(thread_stats_file)):
thread_stats_file = os.path.join(configure.logdir,
thread_stats_file)
# enable image/png content-type and give it a higher
# priority than application/json
server = state.medium.agency._gateway._server
server.enable_mime_type('image/png', 1)
state.server = self.dependency(IServerFactory,
self,
desc.port,
str(desc.django_settings_module),
hostname,
prefix=desc.prefix,
interface=desc.interface,
security_policy=security_policy,
server_stats=stats,
thread_stats_file=thread_stats_file)
return fiber.wrap_defer(state.server.initiate)
def delete_document(self, document):
return fiber.wrap_defer(self._db.delete_document, document)
def shutdown(self, state):
self.info("Shutdown called")
if hasattr(state, 'server'):
return fiber.wrap_defer(state.server.cleanup)
def notify_finish(self):
return fiber.wrap_defer(self.get_def)
def on_killed(self, state):
if hasattr(state, 'server'):
self.info("on_killed called")
return fiber.wrap_defer(state.server.cleanup)
