def json_jobs_update():
try:
job_ids = request.form.getlist('jobs[]')
logging.info('Job ids: {0}'.format(job_ids))
resp = cocaine_request('get_jobs_status', msgpack.packb([job_ids]))
def convert_tss_to_dt(d):
if d.get('create_ts'):
d['create_ts'] = ts_to_dt(d['create_ts'])
if d['start_ts']:
d['start_ts'] = ts_to_dt(d['start_ts'])
if d['finish_ts']:
d['finish_ts'] = ts_to_dt(d['finish_ts'])
for r in resp:
convert_tss_to_dt(r)
for error_msg in r.get('error_msg', []):
error_msg['ts'] = ts_to_dt(error_msg['ts'])
for task in r['tasks']:
convert_tss_to_dt(task)
return resp
except Exception as e:
logging.error(e)
logging.error(traceback.format_exc())
raise
def json_stat():
try:
stats = cocaine_request('get_flow_stats', msgpack.packb(None))
return JsonResponse(json.dumps(stats))
except Exception as e:
logging.error(e)
logging.error(traceback.format_exc())
raise
def json_commands_history(year, month):
try:
resp = cocaine_request('minion_history_log', msgpack.packb([year, month]))
resp = JsonResponse(json.dumps(resp))
return resp
except Exception as e:
logging.error(e)
logging.error(traceback.format_exc())
raise
def json_commands():
try:
resp = cocaine_request('get_commands', msgpack.packb(None))
resp = JsonResponse(json.dumps(resp))
return resp
except Exception as e:
logging.error(e)
logging.error(traceback.format_exc())
raise
def json_group_info(group_id):
try:
resp = cocaine_request(
'get_couple_statistics',
msgpack.packb([int(group_id)])
)
return resp
except Exception as e:
logging.error(e)
logging.error(traceback.format_exc())
raise
def json_commands_node_start():
node = request.form.get('node')
host, port = node.split(':')
if not node:
raise ValueError('Node should be specified')
cmd_resp = cocaine_request(
'start_node_cmd',
msgpack.packb([host.encode('utf-8'), int(port)])
)
cmd = mastermind_response(cmd_resp)
resp = cocaine_request(
'execute_cmd',
msgpack.packb([host, cmd, {'node': node}])
)
resp = mastermind_response(resp)
uid = resp.keys()[0]
return uid
def json_approve_job(job_id):
try:
resp = cocaine_request(
'approve_job',
msgpack.packb([job_id])
)
return resp
except Exception as e:
logging.error(e)
logging.error(traceback.format_exc())
raise
def json_refinish_job(job_id):
try:
resp = cocaine_request(
'restart_failed_to_finish_job',
msgpack.packb([job_id])
)
return resp
except Exception as e:
logging.error(e)
logging.error(traceback.format_exc())
raise
def json_skip_task(job_id, task_id):
try:
resp = cocaine_request(
'skip_failed_job_task',
msgpack.packb([job_id, task_id])
)
return resp
except Exception as e:
logging.error(e)
logging.error(traceback.format_exc())
raise
def json_namespaces():
filter = {
'deleted': False
}
try:
stats = cocaine_request(
'get_namespaces_list',
msgpack.packb([filter])
)
return stats
except Exception as e:
logging.error(e)
logging.error(traceback.format_exc())
raise
def json_treemap(namespace=None):
try:
options = {
'namespace': namespace,
'couple_status': request.args.get('couple_status')
}
resp = cocaine_request(
'get_groups_tree',
msgpack.packb([options])
)
return resp
except Exception as e:
logging.error(e)
logging.error(traceback.format_exc())
raise
def json_jobs_list(job_id=None, job_type=None, job_status=None, tag=None):
if job_id:
params = {
'ids': [job_id],
}
else:
if job_type not in SUPPORTED_JOB_TYPES:
abort(404)
if job_status not in ('not-approved', 'executing', 'pending', 'finished'):
abort(404)
limit = request.args.get('limit', 50)
offset = request.args.get('offset', 0)
params = {
'job_type': MM_JOB_TYPES[job_type],
'tag': tag,
'statuses': MM_JOB_STATUSES[job_status],
'limit': limit,
'offset': offset,
}
try:
resp = cocaine_request('get_job_list', msgpack.packb([params]))
def convert_tss_to_dt(d):
if d.get('create_ts'):
d['create_ts'] = ts_to_dt(d['create_ts'])
if d['start_ts']:
d['start_ts'] = ts_to_dt(d['start_ts'])
if d['finish_ts']:
d['finish_ts'] = ts_to_dt(d['finish_ts'])
for r in resp['jobs']:
convert_tss_to_dt(r)
for error_msg in r.get('error_msg', []):
error_msg['ts'] = ts_to_dt(error_msg['ts'])
for task in r['tasks']:
convert_tss_to_dt(task)
return resp
except Exception as e:
logging.error(e)
logging.error(traceback.format_exc())
raise
def json_monitor_couple_free_eff_space(namespace):
limit = request.args.get('limit')
offset = request.args.get('offset', 0)
request_params = {
'limit': limit,
'offset': offset,
}
try:
samples = cocaine_request(
'get_monitor_effective_free_space',
msgpack.packb([
namespace,
request_params
])
)
return samples
except Exception as e:
logging.error(e)
logging.error(traceback.format_exc())
raise
def json_command_status(uid):
resp = cocaine_request(
'get_command',
msgpack.packb([uid.encode('utf-8')])
)
resp = mastermind_response(resp)
url = STATE_URL_TPL.format(
host=resp['host'],
port=MINIONS_CFG.get('port', 8081),
uid=uid,
)
req = urllib2.Request(url)
if 'authkey' in MINIONS_CFG:
req.add_header('X-Auth', MINIONS_CFG['authkey'])
try:
r = urllib2.urlopen(
req,
timeout=MINIONS_CFG.get('timeout', 5),
)
command_response = json.loads(r.read())
except Exception as e:
resp['output'] = 'Failed to fetch stdout from minions: {}'.format(e)
resp['error_output'] = 'Failed to fetch stderr from minions: {}'.format(e)
else:
if command_response['status'] == 'success':
command_data = command_response['response'][uid]
resp['output'] = command_data['output']
resp['error_output'] = command_data['error_output']
else:
error = command_response['error']
resp['output'] = 'Failed to fetch stdout from minions: {}'.format(error)
resp['error_output'] = 'Failed to fetch stderr from minions: {}'.format(error)
return resp
def json_jobs_filter():
limit = request.args.get('limit', 50)
offset = request.args.get('offset', 0)
types = request.args.getlist('job_types') or None
statuses = request.args.getlist('job_statuses') or None
min_create_ts = dt_to_ts(
request.args.get('min_create_ts'),
format=JOBS_FILTER_DT_FIELD_FORMAT,
)
max_create_ts = dt_to_ts(
request.args.get('max_create_ts'),
format=JOBS_FILTER_DT_FIELD_FORMAT,
)
min_finish_ts = dt_to_ts(
request.args.get('min_finish_ts'),
format=JOBS_FILTER_DT_FIELD_FORMAT,
)
max_finish_ts = dt_to_ts(
request.args.get('max_finish_ts'),
format=JOBS_FILTER_DT_FIELD_FORMAT,
)
ids = None
ids_values = json.loads(request.args.get('tags_ids'))
if ids_values:
ids = ids_values
def ident(x):
return x
tag_types = (
('namespaces', 'namespaces', ident),
('couples', 'couple_ids', int),
('groupsets', 'groupset_ids', ident),
('groups', 'group_ids', int),
('hostnames', 'hostnames', ident),
('paths', 'paths', ident),
)
tags = {}
for tag_type, tag_request_type, map_processor in tag_types:
tag_values = json.loads(request.args.get('tags_' + tag_type))
if tag_values:
tags[tag_request_type] = map(map_processor, tag_values)
params = {
'ids': ids,
'types': types,
'statuses': statuses,
'tags': tags,
'min_create_ts': min_create_ts,
'max_create_ts': max_create_ts,
'min_finish_ts': min_finish_ts,
'max_finish_ts': max_finish_ts,
'limit': limit,
'offset': offset,
}
logging.debug('Job filter request params: {}'.format(params))
try:
resp = cocaine_request('get_job_list', msgpack.packb([params]))
def convert_tss_to_dt(d):
if d.get('create_ts'):
d['create_ts'] = ts_to_dt(d['create_ts'])
if d['start_ts']:
d['start_ts'] = ts_to_dt(d['start_ts'])
if d['finish_ts']:
d['finish_ts'] = ts_to_dt(d['finish_ts'])
for r in resp['jobs']:
convert_tss_to_dt(r)
for error_msg in r.get('error_msg', []):
error_msg['ts'] = ts_to_dt(error_msg['ts'])
for task in r['tasks']:
convert_tss_to_dt(task)
return resp
except Exception as e:
logging.error(e)
logging.error(traceback.format_exc())
raise
