def on_pending(self, when, instanceid, why):
"""Invoked when task is pending."""
if why:
print('%s - %s pending: %s' %
(utils.strftime_utc(when), instanceid, why))
else:
print('%s - %s pending' % (utils.strftime_utc(when), instanceid))
def on_finished(self, when, instanceid, server, signal, exitcode):
"""Invoked when task is finished."""
if exitcode > 255:
print '%s - %s killed, signal: %s' % (
utils.strftime_utc(when),
instanceid,
utils.signal2name(signal)
)
self.ctx.update(
{
'signal': signal,
'when': when,
'server': server
}
)
else:
print '%s - %s exited, return code: %s' % (
utils.strftime_utc(when),
instanceid,
exitcode
)
self.ctx.update(
{
'exitcode': exitcode,
'when': when,
'server': server
}
)
def on_killed(self, when, instanceid, server, is_oom):
"""Default task-finished handler."""
if is_oom:
print('%s - %s killed, out of memory' %
(utils.strftime_utc(when), instanceid))
else:
print('%s - %s killed' % (utils.strftime_utc(when), instanceid))
def on_scheduled(self, when, instanceid, server, why):
"""Invoked when task is scheduled."""
if why:
print('%s - %s scheduled on %s: %s' %
(utils.strftime_utc(when), instanceid, server, why))
else:
print('%s - %s scheduled on %s' %
(utils.strftime_utc(when), instanceid, server))
def on_pending_delete(self, when, instanceid, why):
"""Invoked when task is about to be deleted.
"""
if why:
print('%s - %s pending delete: %s' % (
utils.strftime_utc(when), instanceid, why))
else:
print('%s - %s pending delete' % (
utils.strftime_utc(when), instanceid))
def on_service_exited(self, when, instanceid, server, uniqueid, service,
exitcode, signal):
"""Suppress stdout/err info."""
if exitcode > 255:
print('%s - %s/%s/service/%s killed, signal: %s' %
(utils.strftime_utc(when), instanceid, uniqueid, service,
utils.signal2name(signal)))
else:
print('%s - %s/%s/service/%s exited, return code: %s' %
(utils.strftime_utc(when), instanceid, uniqueid, service,
exitcode))
def _show_finished(apis, match=None, partition=None):
state = _get_state(apis, match=match, finished=True, partition=partition)
result = []
for item in state:
if item['state'] not in _FINISHED_STATES:
continue
details = None
if item.get('exitcode') is not None:
details = 'return code: {}'.format(item['exitcode'])
if item.get('signal') is not None:
details = 'signal: {}'.format(utils.signal2name(item['signal']))
if item.get('aborted_reason'):
details = 'reason: {}'.format(item['aborted_reason'])
if item.get('terminated_reason'):
details = 'reason: {}'.format(item['terminated_reason'])
if item.get('oom'):
details = 'out of memory'
result.append({
'name': item['name'],
'state': item['state'],
'host': item['host'],
'when': utils.strftime_utc(item['when']),
'details': details,
})
cli.out(_FINISHED_STATE_FORMATTER(result))
def on_service_running(self, when, instanceid, server, uniqueid, service):
"""Invoked when service is running."""
print('%s - %s/%s/service/%s running' % (
utils.strftime_utc(when),
instanceid,
uniqueid,
service,
))
def on_aborted(self, when, instanceid, server, why):
"""Invoked when task is aborted.
"""
try:
why = app_abort.AbortedReason(why)
except ValueError:
why = app_abort.AbortedReason.UNKNOWN
print('%s - %s aborted on %s [reason: %s]' % (
utils.strftime_utc(when), instanceid, server, why.description()))
def on_service_exited(self, when, instanceid, server,
uniqueid, service, exitcode, signal):
"""Invoked when service exits."""
if exitcode > 255:
print '%s - %s/%s/service/%s killed, signal: %s' % (
utils.strftime_utc(when),
instanceid,
uniqueid,
service,
utils.signal2name(signal)
)
else:
print '%s - %s/%s/service/%s exited, return code: %s' % (
utils.strftime_utc(when),
instanceid,
uniqueid,
service,
exitcode
)
def app_cmd(app, reason, clear):
"""Manage app blackouts."""
zkclient = context.GLOBAL.zk.conn
blacklist = zkutils.get_default(zkclient, z.BLACKEDOUT_APPS)
if not blacklist:
blacklist = {}
if app:
if clear:
blacklist.pop(app, None)
else:
if not reason:
raise click.UsageError('--reason is required.')
blacklist[app] = {'reason': reason, 'when': time.time()}
zkutils.put(zkclient, z.BLACKEDOUT_APPS, data=blacklist)
masterapi.create_event(zkclient, 0, 'apps_blacklist', None)
for blacklisted, details in sorted(blacklist.items()):
when = utils.strftime_utc(details['when'])
cli.out('[%s] %s %s', when, blacklisted, details['reason'])
def _list_server_blackouts(zkclient, fmt):
"""List server blackouts."""
# List currently blacked out nodes.
blacked_out = []
try:
blacked_out_nodes = zkclient.get_children(z.BLACKEDOUT_SERVERS)
for server in blacked_out_nodes:
node_path = z.path.blackedout_server(server)
data, metadata = zkutils.get_with_metadata(zkclient, node_path)
blacked_out.append((metadata.created, server, data))
except kazoo.client.NoNodeError:
pass
# [%t] %h %r will be printed as below
# [Thu, 05 May 2016 02:59:58 +0000] <hostname> -
mapping = {'t': 0, 'h': 1, 'r': 2}
formatter = _gen_formatter(mapping, fmt)
for when, server, reason in reversed(sorted(blacked_out)):
reason = '-' if reason is None else reason
print(formatter.format(utils.strftime_utc(when), server, reason))
def _list_server_blackouts(zkclient, fmt):
"""List server blackouts."""
with_partition = '%p' in fmt
with_version = '%v' in fmt
blackouts = []
for node in zkclient.get_children(z.BLACKEDOUT_SERVERS):
try:
node_path = z.path.blackedout_server(node)
data, metadata = zkutils.get_with_metadata(zkclient, node_path)
except kazoo.client.NoNodeError:
continue
partition, version = None, None
if with_partition:
server_data = zkutils.get_default(zkclient, z.path.server(node))
if server_data and server_data.get('partition'):
partition = server_data['partition']
if with_version:
version_data = zkutils.get_default(zkclient, z.path.version(node))
if version_data and version_data.get('codepath'):
version = version_data['codepath']
blackouts.append((metadata.created, node, partition, version, data))
# [%t] %h %r will be printed as below
# [Thu, 05 May 2016 02:59:58 +0000] <hostname> -
fields = ('t', 'h', 'p', 'v', 'r')
formatter = _gen_formatter(fields, fmt)
for when, node, partition, version, reason in reversed(sorted(blackouts)):
cli.out(
formatter.format(utils.strftime_utc(when), node, partition or '-',
version or '-', reason or '-'))
def on_server_blackout_cleared(self, when, servername):
"""Invoked when server blackout is cleared.
"""
print('%s - %s cleared' % (utils.strftime_utc(when), servername))
def on_server_blackout(self, when, servername):
"""Invoked when server is blackedout.
"""
print('%s - %s blackout' % (utils.strftime_utc(when), servername))
def on_server_state(self, when, servername, state):
"""Invoked when server state changes.
"""
print('%s - %s %s' % (utils.strftime_utc(when), servername, state))
def on_pending(self, when, instanceid):
"""Invoked when task is pending."""
print('%s - %s pending' % (utils.strftime_utc(when), instanceid))
def on_finished(self, when, instanceid, server, signal, exitcode):
"""Invoked when task is finished.
"""
print('%s - %s finished on %s' % (
utils.strftime_utc(when), instanceid, server))
def on_deleted(self, when, instanceid):
"""Invoked when task is deleted.
"""
print('%s - %s deleted' % (utils.strftime_utc(when), instanceid))
def on_aborted(self, when, instanceid, server, why):
"""Invoked when task is aborted"""
print('%s - %s aborted on %s [reason: %s]' %
(utils.strftime_utc(when), instanceid, server, why))
def on_configured(self, when, instanceid, server, uniqueid):
"""Invoked when task is configured
"""
print('%s - %s/%s configured on %s' % (
utils.strftime_utc(when), instanceid, uniqueid, server
))
def on_scheduled(self, when, instanceid, server):
"""Invoked when task is scheduled."""
print '%s - %s scheduled on %s' % (
utils.strftime_utc(when), instanceid, server)
