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)
