def handle_process(self, task_id, process_id):
all_processes = {}
current_run = self._observer.process(task_id, process_id)
if not current_run:
HttpServer.abort(404, 'Invalid task/process combination: %s/%s' % (task_id, process_id))
process = self._observer.process_from_name(task_id, process_id)
if process is None:
msg = 'Could not recover process: %s/%s' % (task_id, process_id)
log.error(msg)
HttpServer.abort(404, msg)
current_run_number = current_run['process_run']
all_processes[current_run_number] = current_run
for run in range(current_run_number):
all_processes[run] = self._observer.process(task_id, process_id, run)
template = {
'task_id': task_id,
'process': {
'name': process_id,
'status': all_processes[current_run_number]["state"],
'cmdline': process.cmdline().get()
},
}
template['process'].update(**all_processes[current_run_number].get('used', {}))
template['runs'] = all_processes
log.debug('Rendering template is: %s' % template)
return template
def handle_process(self, task_id, process_id):
all_processes = {}
current_run = self._observer.process(task_id, process_id)
if not current_run:
HttpServer.abort(
404, 'Invalid task/process combination: %s/%s' %
(task_id, process_id))
process = self._observer.process_from_name(task_id, process_id)
if process is None:
msg = 'Could not recover process: %s/%s' % (task_id, process_id)
log.error(msg)
HttpServer.abort(404, msg)
current_run_number = current_run['process_run']
all_processes[current_run_number] = current_run
for run in range(current_run_number):
all_processes[run] = self._observer.process(
task_id, process_id, run)
template = {
'task_id': task_id,
'process': {
'name': process_id,
'status': all_processes[current_run_number]["state"],
'cmdline': process.cmdline().get()
},
}
template['process'].update(
**all_processes[current_run_number].get('used', {}))
template['runs'] = all_processes
log.debug('Rendering template is: %s', template)
return template
def handle_vars(self, var=None):
HttpServer.set_content_type('text/plain; charset=iso-8859-1')
samples = self._monitor.sample()
if var is None:
return '\n'.join(
'%s %s' % (key, val) for key, val in sorted(samples.items()))
else:
if var in samples:
return samples[var]
else:
HttpServer.abort(404, 'Unknown exported variable')
def handle_vars(self, var = None):
samples = self._monitor.sample()
if var is None:
body='<br>'.join(
'%s %s' % (key, val) for key, val in samples.iteritems())
return '<html><body><pre>%s</pre></body></html>' % body
else:
if var in samples:
return samples[var]
else:
HttpServer.abort(404, 'Unknown exported variable')
def handle_vars(self, var=None):
HttpServer.set_content_type('text/plain; charset=iso-8859-1')
samples = self._monitor.sample()
if var is None:
return '\n'.join('%s %s' % (key, val)
for key, val in sorted(samples.items()))
else:
if var in samples:
return samples[var]
else:
HttpServer.abort(404, 'Unknown exported variable')
def handle_vars(self, var=None):
samples = self._monitor.sample()
if var is None:
body = '<br>'.join('%s %s' % (key, val)
for key, val in samples.items())
return '<html><body><pre>%s</pre></body></html>' % body
else:
if var in samples:
return samples[var]
else:
HttpServer.abort(404, 'Unknown exported variable')
def handle_vars(self, var=None):
HttpServer.set_content_type('text/plain; charset=iso-8859-1')
filtered = self._parse_filtered_arg()
samples = self._monitor.sample()
if var is None and filtered and self._stats_filter:
return '\n'.join('%s %s' % (key, val)
for key, val in sorted(samples.items())
if not self._stats_filter.match(key))
elif var is None:
return '\n'.join('%s %s' % (key, val)
for key, val in sorted(samples.items()))
else:
if var in samples:
return samples[var]
else:
HttpServer.abort(404, 'Unknown exported variable')
def handle_vars(self, var=None):
HttpServer.set_content_type('text/plain; charset=iso-8859-1')
filtered = self._parse_filtered_arg()
samples = self._monitor.sample()
if var is None and filtered and self._stats_filter:
return '\n'.join(
'%s %s' % (key, val) for key, val in sorted(samples.items())
if not self._stats_filter.match(key))
elif var is None:
return '\n'.join(
'%s %s' % (key, val) for key, val in sorted(samples.items()))
else:
if var in samples:
return samples[var]
else:
HttpServer.abort(404, 'Unknown exported variable')
def handle_task(self, task_id):
task = self.get_task(task_id)
processes = self._observer.processes([task_id])
if not processes.get(task_id, None):
HttpServer.abort(404, 'Unknown task_id: %s' % task_id)
processes = processes[task_id]
state = self._observer.state(task_id)
return dict(
task_id=task_id,
task=task,
statuses=self._observer.task_statuses(task_id),
user=task['user'],
ports=task['ports'],
processes=processes,
chroot=state.get('sandbox', ''),
launch_time=state.get('launch_time', 0),
hostname=state.get('hostname', 'localhost'),
)
def handle_task(self, task_id):
task = self.get_task(task_id)
processes = self._observer.processes([task_id])
if not processes.get(task_id, None):
HttpServer.abort(404, 'Unknown task_id: %s' % task_id)
processes = processes[task_id]
state = self._observer.state(task_id)
return dict(
task_id = task_id,
task = task,
statuses = self._observer.task_statuses(task_id),
user = task['user'],
ports = task['ports'],
processes = processes,
chroot = state.get('sandbox', ''),
launch_time = state.get('launch_time', 0),
hostname = state.get('hostname', 'localhost'),
)
def handle_task(self, task_id):
task = self.get_task(task_id)
processes = self._observer.processes([task_id])
if not processes.get(task_id, None):
HttpServer.abort(404, "Unknown task_id: %s" % task_id)
processes = processes[task_id]
state = self._observer.state(task_id)
return dict(
task_id=task_id,
task=task,
statuses=self._observer.task_statuses(task_id),
user=task["user"],
ports=task["ports"],
processes=processes,
chroot=state.get("sandbox", ""),
launch_time=state.get("launch_time", 0),
hostname=state.get("hostname", "localhost"),
)
def handle_process(self, task_id, process_id):
all_processes = {}
current_run = self._observer.process(task_id, process_id)
if not current_run:
HttpServer.abort(
404, 'Invalid task/process combination: %s/%s' %
(task_id, process_id))
process = self._observer.process_from_name(task_id, process_id)
if process is None:
msg = 'Could not recover process: %s/%s' % (task_id, process_id)
log.error(msg)
HttpServer.abort(404, msg)
current_run_number = current_run['process_run']
all_processes[current_run_number] = current_run
for run in range(current_run_number):
all_processes[run] = self._observer.process(
task_id, process_id, run)
def convert_process_tuple(run_tuple):
process_tuple = dict(state=run_tuple['state'])
if 'start_time' in run_tuple:
process_tuple.update(start_time=run_tuple['start_time'])
if 'stop_time' in run_tuple:
process_tuple.update(stop_time=run_tuple['stop_time'])
return process_tuple
template = {
'task_id': task_id,
'process': {
'name': process_id,
'status': all_processes[current_run_number]["state"],
'cmdline': process.cmdline().get()
},
}
template['process'].update(
**all_processes[current_run_number].get('used', {}))
template['runs'] = dict((run, convert_process_tuple(run_tuple))
for run, run_tuple in all_processes.items())
log.info('Rendering template is: %s' % template)
return template
def handle_process(self, task_id, process_id):
all_processes = {}
current_run = self._observer.process(task_id, process_id)
if not current_run:
HttpServer.abort(404, 'Invalid task/process combination: %s/%s' % (task_id, process_id))
process = self._observer.process_from_name(task_id, process_id)
if process is None:
msg = 'Could not recover process: %s/%s' % (task_id, process_id)
log.error(msg)
HttpServer.abort(404, msg)
current_run_number = current_run['process_run']
all_processes[current_run_number] = current_run
for run in range(current_run_number):
all_processes[run] = self._observer.process(task_id, process_id, run)
def convert_process_tuple(run_tuple):
process_tuple = dict(state = run_tuple['state'])
if 'start_time' in run_tuple:
process_tuple.update(start_time = run_tuple['start_time'])
if 'stop_time' in run_tuple:
process_tuple.update(stop_time = run_tuple['stop_time'])
return process_tuple
template = {
'task_id': task_id,
'process': {
'name': process_id,
'status': all_processes[current_run_number]["state"],
'cmdline': process.cmdline().get()
},
}
template['process'].update(**all_processes[current_run_number].get('used', {}))
template['runs'] = dict((run, convert_process_tuple(run_tuple))
for run, run_tuple in all_processes.items())
log.info('Rendering template is: %s' % template)
return template
def handle_process(self, task_id, process_id):
all_processes = {}
current_run = self._observer.process(task_id, process_id)
if not current_run:
HttpServer.abort(404, "Invalid task/process combination: %s/%s" % (task_id, process_id))
process = self._observer.process_from_name(task_id, process_id)
if process is None:
msg = "Could not recover process: %s/%s" % (task_id, process_id)
log.error(msg)
HttpServer.abort(404, msg)
current_run_number = current_run["process_run"]
all_processes[current_run_number] = current_run
for run in range(current_run_number):
all_processes[run] = self._observer.process(task_id, process_id, run)
def convert_process_tuple(run_tuple):
process_tuple = dict(state=run_tuple["state"])
if "start_time" in run_tuple:
process_tuple.update(start_time=run_tuple["start_time"])
if "stop_time" in run_tuple:
process_tuple.update(stop_time=run_tuple["stop_time"])
return process_tuple
template = {
"task_id": task_id,
"process": {
"name": process_id,
"status": all_processes[current_run_number]["state"],
"cmdline": process.cmdline().get(),
},
}
template["process"].update(**all_processes[current_run_number].get("used", {}))
template["runs"] = dict((run, convert_process_tuple(run_tuple)) for run, run_tuple in all_processes.items())
log.info("Rendering template is: %s" % template)
return template
def handle_main(self, type=None, offset=None, num=None):
if type not in (None, 'all', 'finished', 'active'):
HttpServer.abort(404, 'Invalid task type: %s' % type)
if offset is not None:
try:
offset = int(offset)
except ValueError:
HttpServer.abort(404, 'Invalid offset: %s' % offset)
if num is not None:
try:
num = int(num)
except ValueError:
HttpServer.abort(404, 'Invalid count: %s' % num)
return self._observer.main(type, offset, num)
def handle_main(self, type=None, offset=None, num=None):
if type not in (None, 'all', 'finished', 'active'):
HttpServer.abort(404, 'Invalid task type: %s' % type)
if offset is not None:
try:
offset = int(offset)
except ValueError:
HttpServer.abort(404, 'Invalid offset: %s' % offset)
if num is not None:
try:
num = int(num)
except ValueError:
HttpServer.abort(404, 'Invalid count: %s' % num)
return self._observer.main(type, offset, num)
def get_task(self, task_id):
task = self._observer._task(task_id)
if not task:
HttpServer.abort(
404, "Failed to find task %s. Try again shortly." % task_id)
return task
def get_task(self, task_id):
task = self._observer._task(task_id)
if not task:
HttpServer.abort(404, "Failed to find task %s. Try again shortly." % task_id)
return task
