def run(self):
while True:
try:
if not self.paused:
yield self.sync()
except Exception:
if get_config().getboolean('debug', 'print_exceptions'):
log.err(system='sync')
yield async_sleep(self.interval)
def run(self):
while True:
try:
if not self.paused:
yield self.ping_check()
except Exception:
if get_config().getboolean('debug', 'print_exceptions'):
log.err(system='ping-check')
yield async_sleep(self.interval)
def run(self):
while True:
try:
if not self.paused:
yield self.pack()
except Exception:
import traceback
traceback.print_exc()
pass
yield async_sleep(self.interval)
def run(self):
while True:
try:
if not self.paused:
yield self.pack()
except Exception:
import traceback
traceback.print_exc()
pass
yield async_sleep(self.interval)
def run(self):
while True:
try:
# Currently we have special codes for gathering info about machines
# hostinginv VM, in future here we'll traverse the whole zodb and search for gatherers
# and maintain the gatherers via add/remove events.
if not self.paused:
yield self.gather_machines()
except Exception:
self.log_err()
yield async_sleep(self.interval)
def run(self):
while True:
try:
# Currently we have special codes for gathering info about machines
# hostinginv VM, in future here we'll traverse the whole zodb and search for gatherers
# and maintain the gatherers via add/remove events.
if not self.paused:
yield self.gather_machines()
except Exception:
self.log_err()
yield async_sleep(self.interval)
def run(self):
while True:
try:
if not self.paused:
if IndexerDaemonProcess.queue == self.black_hole:
IndexerDaemonProcess.queue = deque()
self.reindex()
yield self.process()
else:
IndexerDaemonProcess.queue = self.black_hole
except Exception:
log.err(system='indexer')
yield async_sleep(1)
def execute(self, cmd, args):
yield BaseHostRequestAction.execute(self, cmd, args)
hostname = yield db.get(self.context, 'hostname')
# Acceptance of a new HN should trigger its syncing
uuid = yield register_machine(hostname, mgt_stack=ISaltInstalled)
cmd.write('Host %s accepted. Syncing shortly...\n' % hostname)
log.msg('Host %s accepted. Syncing in 5 seconds...' % hostname, system='action-accept')
yield async_sleep(5)
compute = yield get_machine_by_uuid(uuid)
assert compute is not None, 'Machine not found after accept: %s' % uuid
log.msg('Syncing NOW...', system='action-accept')
syncaction = SyncAction(compute)
syncaction._do_not_enqueue = False
args = argparse.Namespace()
args.full = True
yield syncaction.execute(DetachedProtocol(), args)
def execute(self, args):
if args.d:
import ipdb
ipdb.set_trace()
return
if args.b:
@db.ro_transact
def get_db_object(path):
import ipdb
ipdb.set_trace()
return self.traverse(path)
yield get_db_object('/')
return
if args.t:
mpdaemon = find_daemon_in_proc(MemoryProfilerDaemonProcess)
oldtrack = mpdaemon.track
mpdaemon.track = True
handler = CommandInterfaceWriter(self)
logger.addHandler(handler)
def keystrokeReceived(keyID, mod):
logger.removeHandler(handler)
if args.t:
mpdaemon.track = oldtrack
r = self.protocol._orig_keystrokeReceived(keyID, mod)
self.protocol.keystrokeReceived = self.protocol._orig_keystrokeReceived
return r
self.protocol._orig_keystrokeReceived = self.protocol.keystrokeReceived
self.protocol.keystrokeReceived = keystrokeReceived
try:
while True:
yield async_sleep(1)
finally:
logger.removeHandler(handler)
if args.t:
mpdaemon.track = oldtrack
self.protocol.keystrokeReceived = self.protocol._orig_keystrokeReceived
def execute(self, cmd, args):
yield BaseHostRequestAction.execute(self, cmd, args)
hostname = yield db.get(self.context, 'hostname')
# Acceptance of a new HN should trigger its syncing
uuid = yield register_machine(hostname, mgt_stack=ISaltInstalled)
cmd.write('Host %s accepted. Syncing shortly...\n' % hostname)
log.msg('Host %s accepted. Syncing in 5 seconds...' % hostname,
system='action-accept')
yield async_sleep(5)
compute = yield get_machine_by_uuid(uuid)
assert compute is not None, 'Machine not found after accept: %s' % uuid
log.msg('Syncing NOW...', system='action-accept')
syncaction = SyncAction(compute)
syncaction._do_not_enqueue = False
args = argparse.Namespace()
args.full = True
yield syncaction.execute(DetachedProtocol(), args)
def run(self):
if self.enabled and self.track:
yield self.collect_and_dump()
while True:
try:
if self.enabled and not self.paused:
if self.track:
yield self.track_changes()
else:
yield self.collect_and_dump()
if self.verbose:
yield self.collect_and_dump_garbage()
yield self.collect_and_dump_root()
except Exception:
log.err(system=self.__name__)
yield async_sleep(self.interval)
def run(self):
if self.enabled and self.track:
yield self.collect_and_dump()
while True:
try:
if self.enabled and not self.paused:
if self.track:
yield self.track_changes()
else:
yield self.collect_and_dump()
if self.verbose:
yield self.collect_and_dump_garbage()
yield self.collect_and_dump_root()
except Exception:
log.err(system=self.__name__)
yield async_sleep(self.interval)
def execute(self, args):
if args.d:
import ipdb
ipdb.set_trace()
return
if args.b:
@db.ro_transact
def get_db_object(path):
import ipdb
ipdb.set_trace()
return self.traverse(path)
yield get_db_object('/')
return
if args.t:
mpdaemon = find_daemon_in_proc(MemoryProfilerDaemonProcess)
oldtrack = mpdaemon.track
mpdaemon.track = True
handler = CommandInterfaceWriter(self)
logger.addHandler(handler)
def keystrokeReceived(keyID, mod):
logger.removeHandler(handler)
if args.t:
mpdaemon.track = oldtrack
r = self.protocol._orig_keystrokeReceived(keyID, mod)
self.protocol.keystrokeReceived = self.protocol._orig_keystrokeReceived
return r
self.protocol._orig_keystrokeReceived = self.protocol.keystrokeReceived
self.protocol.keystrokeReceived = keystrokeReceived
try:
while True:
yield async_sleep(1)
finally:
logger.removeHandler(handler)
if args.t:
mpdaemon.track = oldtrack
self.protocol.keystrokeReceived = self.protocol._orig_keystrokeReceived
