def stop_daemons(self, dtg):
try:
self.process_kill_all()
return CommandSuccess('OK', False)
except SDaemonError as err:
self.logger.exception('Failed to stop some storlet daemons')
return CommandFailure(err.args[0], False)
def halt(self, dtg):
try:
self.shutdown_all_processes()
msg = 'Stopped all storlet daemons. Terminating.'
return CommandSuccess(msg, False)
except SDaemonError as err:
self.logger.exception('Failed to stop some storlet daemons')
return CommandFailure(err.args[0], False)
def stop_daemon(self, dtg):
params = dtg.params
storlet_name = params['storlet_name']
try:
pid, code = self.process_kill(storlet_name)
msg = 'The storlet daemon {0} is stopped'.format(storlet_name)
return CommandSuccess(msg)
except SDaemonError as err:
self.logger.exception('Failed to kill the storlet daemon %s' %
storlet_name)
return CommandFailure(err.args[0])
def cancel(self, dtg):
task_id = dtg.task_id
if task_id not in self.task_id_to_pid:
return CommandFailure('Task id %s is not found' % task_id, False)
pid = self.task_id_to_pid.get(task_id)
try:
os.kill(pid, signal.SIGTERM)
self._remove_pid(pid)
return CommandSuccess('Cancelled task %s' % task_id, False)
except OSError:
self.logger.exception('Failed to kill subprocess: %d' % pid)
return CommandFailure('Failed to cancel task %s' % task_id, False)
def daemon_status(self, dtg):
params = dtg.params
storlet_name = params['storlet_name']
try:
if self.get_process_status_by_name(storlet_name):
msg = 'The storlet daemon {0} seems to be OK'.format(
storlet_name)
return CommandSuccess(msg)
else:
msg = 'No running storlet daemons for {0}'.format(storlet_name)
return CommandFailure(msg)
except SDaemonError as err:
self.logger.exception('Failed to get status of the storlet '
'daemon %s' % storlet_name)
return CommandFailure(err.args[0])
def start_daemon(self, dtg):
params = dtg.params
storlet_name = params['storlet_name']
try:
if self.process_start_daemon(params['daemon_language'],
params['storlet_path'],
storlet_name,
params['pool_size'],
params['uds_path'],
params['log_level'],
daemon_language_version=params.get(
'daemon_language_version')):
msg = 'OK'
else:
msg = 'The storlet daemon {0} is already running'.format(
storlet_name)
return CommandSuccess(msg)
except SDaemonError as err:
self.logger.exception(
'Failed to start the sdaemon for {0}'.format(storlet_name))
return CommandFailure(err.args[0])
def execute(self, dtg):
task_id = str(uuid.uuid4())[:8]
self.logger.debug('Execute storlet %s (task %s)' %
(self.storlet_name, task_id))
while len(self.task_id_to_pid) >= self.pool_size:
self._wait_child_process()
pid = os.fork()
if pid:
self.logger.debug('Create a subprocess %d for task %s' %
(pid, task_id))
self.task_id_to_pid[task_id] = pid
for fd in dtg.invocation_fds:
# We do not use invocation fds in main process, so close them
self._safe_close(fd)
else:
self._safe_close(dtg.service_out_fd)
self._execute(dtg)
sys.exit()
return CommandSuccess('OK', task_id=task_id)
def halt(self, dtg):
self.logger.debug('Terminating')
return CommandSuccess('OK', False)
def halt(self, dtg):
return CommandSuccess('OK', False)
def execute(self, dtg):
task_id_out_fd = dtg.task_id_out_fd
task_id = str(uuid.uuid4())[:8]
while len(self.task_id_to_pid) >= self.pool_size:
self._wait_child_process()
self.logger.debug('Returning task_id: %s ' % task_id)
with os.fdopen(task_id_out_fd, 'w') as outfile:
outfile.write(task_id)
storlet_md = dtg.object_in_storlet_metadata
params = dtg.params
in_md = dtg.object_in_metadata
in_fds = dtg.object_in_fds
out_md_fds = dtg.object_metadata_out_fds
out_fds = dtg.object_out_fds
logger_fd = dtg.logger_out_fd
pid = os.fork()
if pid:
self.logger.debug('Create a subprocess %d for task %s' %
(pid, task_id))
self.task_id_to_pid[task_id] = pid
for fd in dtg.fds:
# We do not use fds in main process, so close them
try:
os.close(fd)
except OSError as e:
if e.errno != errno.EBADF:
raise
pass
else:
try:
self.logger.debug('Start storlet invocation')
self.logger.debug(
'in_fds:%s in_md:%s out_md_fds:%s out_fds:%s'
' logger_fd: %s' %
(in_fds, in_md, out_md_fds, out_fds, logger_fd))
in_files = [
self._create_input_file(st_md, md, in_fd)
for st_md, md, in_fd in zip(storlet_md, in_md, in_fds)
]
out_files = [
StorletOutputFile(out_md_fd, out_fd)
for out_md_fd, out_fd in zip(out_md_fds, out_fds)
]
self.logger.debug('Start storlet execution')
with StorletLogger(self.storlet_name, logger_fd) as slogger:
handler = self.storlet_cls(slogger)
handler(in_files, out_files, params)
self.logger.debug('Completed')
except Exception:
self.logger.exception('Error in storlet invocation')
finally:
# Make sure that all fds are closed
self._safe_close_files(in_files)
self._safe_close_files(out_files)
sys.exit()
return CommandSuccess('OK')
def test_init(self):
resp = CommandSuccess('ok')
self.assertTrue(resp.status)
self.assertEqual('ok', resp.message)
self.assertTrue(resp.iterable)
