def wait_for_daemon_to_initialize(self, storlet_name): """ Send a Ping service datagram. Validate that Daemon response is correct. Give up after the predefined number of attempts (5) :param storlet_name: Storlet name we are checking the daemon for :returns: daemon status (True, False) """ storlet_pipe_name = self.storlet_name_to_pipe_name[storlet_name] self.logger.debug('Send PING command to {0} via {1}'. format(storlet_name, storlet_pipe_name)) read_fd, write_fd = os.pipe() try: dtg = SBusDatagram.create_service_datagram( SBUS_CMD_PING, write_fd) for i in range(self.NUM_OF_TRIES_PINGING_STARTING_DAEMON): ret = SBus.send(storlet_pipe_name, dtg) if ret >= 0: resp = os.read(read_fd, 128) if resp.startswith('True'): return True time.sleep(1) else: return False finally: os.close(read_fd) os.close(write_fd)
def start_storlet_daemon(self, spath, storlet_id, language): """ Start SDaemon process in the scope's sandbox """ prms = {'daemon_language': language.lower(), 'storlet_path': spath, 'storlet_name': storlet_id, 'uds_path': self.paths.sbox_storlet_pipe(storlet_id), 'log_level': self.storlet_daemon_debug_level, 'pool_size': self.storlet_daemon_thread_pool_size} with _open_pipe() as (read_fd, write_fd): dtg = SBusDatagram.create_service_datagram( sbus_cmd.SBUS_CMD_START_DAEMON, write_fd, prms) pipe_path = self.paths.host_factory_pipe() rc = SBus.send(pipe_path, dtg) # TODO(takashi): Why we should rond rc into -1? if (rc < 0): return -1 reply = os.read(read_fd, 10) res, error_txt = self._parse_sandbox_factory_answer(reply) if res is True: return 1 self.logger.error('Failed to start storlet daemon: %s' % error_txt) return 0
def ping(self): """ Ping to daemon factory process inside container :returns: 1 when the daemon factory is responsive 0 when the daemon factory is not responsive -1 when it fails to send command to the process """ pipe_path = self.paths.host_factory_pipe() with _open_pipe() as (read_fd, write_fd): dtg = SBusDatagram.create_service_datagram( sbus_cmd.SBUS_CMD_PING, write_fd) rc = SBus.send(pipe_path, dtg) if (rc < 0): return -1 reply = os.read(read_fd, 10) res, error_txt = self._parse_sandbox_factory_answer(reply) if res is True: return 1 self.logger.error('Failed to ping to daemon factory: %s' % error_txt) return 0
def test_create_service_datagram(self): dtg = SBusDatagram.create_service_datagram( self.command, 1, self.params, self.task_id) self.assertEqual(self.params, dtg.params) self.assertEqual(self.command, dtg.command) self.assertEqual(self.task_id, dtg.task_id) self.assertEqual([1], dtg.fds) self.assertEqual([{'storlets': {'type': sbus_fd.SBUS_FD_SERVICE_OUT}, 'storage': {}}], dtg.metadata) dtg = SBusDatagram.create_service_datagram( self.command, 1) self.assertIsNone(dtg.params) self.assertEqual(self.command, dtg.command) self.assertIsNone(dtg.task_id) self.assertEqual([1], dtg.fds) self.assertEqual([{'storlets': {'type': sbus_fd.SBUS_FD_SERVICE_OUT}, 'storage': {}}], dtg.metadata)
def _cancel(self): """ Cancel on-going storlet execution """ with _open_pipe() as (read_fd, write_fd): dtg = SBusDatagram.create_service_datagram( sbus_cmd.SBUS_CMD_CANCEL, write_fd, None, self.task_id) rc = SBus.send(self.storlet_pipe_path, dtg) if (rc < 0): raise StorletRuntimeException('Failed to cancel task') # TODO(takashi): Check the reponse here os.read(read_fd, 10)
def shutdown_process(self, storlet_name): """ send HALT command to storlet daemon :param storlet_name: Storlet name we are checking the daemon for :raises SDaemonError: when wailed to shutdown the storlet daemon """ self.logger.debug( 'Shutdown the storlet daemon {0}'.format(storlet_name)) dmn_pid = self.storlet_name_to_pid.get(storlet_name) self.logger.debug('Storlet Daemon PID is {0}'.format(dmn_pid)) if dmn_pid is None: raise SDaemonError('{0} is not found'.format(storlet_name)) storlet_pipe_name = self.storlet_name_to_pipe_name[storlet_name] self.logger.debug('Send HALT command to {0} via {1}'. format(storlet_name, storlet_pipe_name)) read_fd, write_fd = os.pipe() try: dtg = SBusDatagram.create_service_datagram( SBUS_CMD_HALT, write_fd) rc = SBus.send(storlet_pipe_name, dtg) os.close(write_fd) if rc < 0: raise SDaemonError( 'Failed to send halt to {0}'.format(storlet_name)) resp = os.read(read_fd, 128) if not resp.startswith('True'): raise SDaemonError( 'Failed to send halt to {0}'.format(storlet_name)) finally: os.close(read_fd) try: os.waitpid(dmn_pid, 0) self.storlet_name_to_pid.pop(storlet_name) except OSError: self.logger.exception( 'Error when waiting the storlet daemon {0}'.format( storlet_name)) raise SDaemonError('Failed to wait {0}'.format(storlet_name))
def main(argv): if len(argv) < 2: print_usage(argv) return daemon_factory_pipe_name = argv[1] try: fi, fo = os.pipe() halt_dtg = SBusDatagram.create_service_datagram( SBUS_CMD_HALT, fo) n_status = SBus.send(daemon_factory_pipe_name, halt_dtg) if n_status < 0: print('Sending failed') else: print('Sending succeeded') cmd_response = os.read(fi, 256) print(cmd_response) finally: os.close(fi) os.close(fo)
def stop_storlet_daemon(self, storlet_id): """ Stop SDaemon process in the scope's sandbox """ with _open_pipe() as (read_fd, write_fd): dtg = SBusDatagram.create_service_datagram( sbus_cmd.SBUS_CMD_STOP_DAEMON, write_fd, {'storlet_name': storlet_id}) pipe_path = self.paths.host_factory_pipe() rc = SBus.send(pipe_path, dtg) if (rc < 0): self.logger.info("Failed to send status command to %s %s" % (self.scope, storlet_id)) return -1 reply = os.read(read_fd, 10) res, error_txt = self._parse_sandbox_factory_answer(reply) if res is True: return 1 self.logger.error('Failed to stop storlet daemon: %s' % error_txt) return 0