def request_config(self): action = 'get_conf' payload = [] message = actionSerializer.serialize_request(action, payload) self.send_queue.put(message) action = 'get_host_list' message = actionSerializer.serialize_request(action, payload) self.send_queue.put(message)
def cleanup(self, full=False, exit_code=config.ExitStatus.FINE): if full: action = 'quit' message = actionSerializer.serialize_request(action, [full]) self.logger.debug("Sending quit to server") else: action = 'unsubscribe' message = actionSerializer.serialize_request(action, []) self.logger.debug("Sending unsubscribe to server") self.send_queue.put(message) for host in self.mounted_hosts: self.logger.debug("Unmounting host %s" % host) self._unmount_host(host) self.keep_running = False
def kill_session_by_name(self, session_name): self.logger.debug("Serializing kill session by name") action = 'kill_session' payload = [session_name] message = actionSerializer.serialize_request(action, payload) self.send_queue.put(message)
def _interpret_message(self, action, args, connection): self.logger.debug("Action: %s, args: %s" % (action, args)) func = self.function_mapping.get(action) if action == 'unsubscribe': self.send_queues.pop(connection) self.sel.unregister(connection) self.logger.debug("Client %s unsubscribed" % connection.getpeername()[0]) connection.close() return response_type = self.receiver_mapping.get(action) if response_type: try: ret = func(*args) except TypeError: self.logger.error("Ignoring unrecognized action '%s'" % action) return action = '%s_response' % action message = actionSerializer.serialize_request(action, [ret]) if response_type == 'all': for key in self.send_queues: message_queue = self.send_queues.get(key) message_queue.put(message) elif response_type == 'single': self.send_queues[connection].put(message) else: try: func(*args) except TypeError: self.logger.error("Ignoring unrecognized action '%s'" % action) return
def check_component(self, comp_id, hostname, component_wait): self.logger.debug("Sending '%s' check request to %s" % (comp_id, hostname)) action = 'check' payload = [comp_id] connection_queue = None message = actionSerializer.serialize_request(action, payload) for connection in self.send_queues: if self.port_mapping.get(connection) == hostname: connection_queue = self.send_queues.get(connection) break self.check_buffer[comp_id] = None if connection_queue: connection_queue.put(message) end_t = time.time() + component_wait + 1 self.logger.debug("Waiting on '%s' response for %s seconds" % (hostname, component_wait)) while end_t > time.time(): if self.check_buffer[comp_id] is not None: break time.sleep(.5) else: self.logger.error("Slave on '%s' is not connected!" % hostname) ret = self.check_buffer[comp_id] if ret is not None: self.logger.debug("Slave answered check request with %s" % config.STATE_DESCRIPTION.get(ret)) return ret else: self.logger.error("No answer from slave - returning unreachable") return config.CheckState.UNREACHABLE
def start_component(self, comp, force_mode=False): self.logger.debug("Serializing component start") action = 'start' payload = [comp['id'], force_mode] message = actionSerializer.serialize_request(action, payload) self.send_queue.put(message)
def check_component(self, comp, broadcast=False): self.logger.debug("Serializing component check") action = 'check' payload = [comp['id']] message = actionSerializer.serialize_request(action, payload) self.send_queue.put(message)
def stop_component(self, comp): self.logger.debug("Serializing component stop") action = 'stop' payload = [comp['id']] message = actionSerializer.serialize_request(action, payload) self.send_queue.put(message)
def test_consistency(self): des = (self.action, self.payload) pick = actionSerializer.serialize_request(self.action, self.payload) fmt = '%ds %dx %ds' % (0, 4, len(pick) - 4) unused, lesser = struct.unpack(fmt, pick) res = actionSerializer.deserialize(lesser) self.assertEqual(des, res)
def _process_events(self): """Process events enqueued by the manager and send them to connected clients if necessary. :return: None """ while not self.event_queue.empty(): event = self.event_queue.get_nowait() # self.logger.debug("Forwarding event '%s' to slave manager server" % event) message = actionSerializer.serialize_request('queue_event', [event]) self.send_queue.put(message)
def stop_component(self, comp_id, hostname): action = 'stop' payload = [comp_id] connection_queue = None message = actionSerializer.serialize_request(action, payload) for connection in self.send_queues: if self.port_mapping.get(connection) == hostname: connection_queue = self.send_queues.get(connection) break if connection_queue: connection_queue.put(message) else: raise exceptions.SlaveNotReachableException("Slave at %s is not reachable!" % hostname)
def kill_slaves(self, full): """Send shutdown command to all connected slave client sockets. :param full: Whether the tmux session is killed too :type full: bool :return: None """ if full: action = 'quit' else: action = 'suspend' payload = [] message = actionSerializer.serialize_request(action, payload) for host in self.send_queues: slave_queue = self.send_queues.get(host) slave_queue.put(message)
def kill_slave_on_host(self, hostname): """Kill a slave session of the current master session running on the remote host. :param hostname: Host to kill the slave on :type hostname: str :return: None """ for conn in self.send_queues: if hostname == self.port_mapping.get(conn): self.logger.debug("Socket to %s still exists - Sending shutdown" % hostname) try: # Test if connection still alive select.select([conn], [], [conn], 1) message = actionSerializer.serialize_request('quit', []) self.send_queues.get(conn).put(message) except socket.error: self.logger.error("Existing connection to %s died. Could not send quit command" % hostname)
def _process_events(self): """Process events enqueued by the manager and send them to connected clients if necessary. :return: None """ # Put events received by slave manager into event queue to forward to clients while not self.cc.slave_server.notify_queue.empty(): event = self.cc.slave_server.notify_queue.get_nowait() self.event_queue.put(event) while not self.event_queue.empty(): event = self.event_queue.get_nowait() message = actionSerializer.serialize_request('queue_event', [event]) for key in self.send_queues: message_queue = self.send_queues.get(key) message_queue.put(message) if isinstance(event, events.DisconnectEvent): self.cc.host_states[event.host_name] = config.HostState.DISCONNECTED
def stop_all(self): action = 'stop_all' message = actionSerializer.serialize_request(action, []) self.send_queue.put(message)
def start_all(self, force_mode=False): action = 'start_all' message = actionSerializer.serialize_request(action, [force_mode]) self.send_queue.put(message)
def _send_auth(self): action = 'auth' payload = [socket.gethostname()] message = actionSerializer.serialize_request(action, payload) self.send_queue.put(message)
def start_remote_clone_session(self, comp): action = 'start_clone_session' payload = [comp['id']] message = actionSerializer.serialize_request(action, payload) self.send_queue.put(message)
def reconnect_with_host(self, hostname): action = 'reconnect_with_host' payload = [hostname] message = actionSerializer.serialize_request(action, payload) self.send_queue.put(message)
def reload_config(self): action = 'reload_config' payload = [] message = actionSerializer.serialize_request(action, payload) self.send_queue.put(message)