def handle(self):
sock = self.request
sock.setsockopt(socket.SOL_TCP, socket.TCP_NODELAY, 1)
with KnowledgeServer.client_lock:
client_id = KnowledgeServer.next_client_number
if not KnowledgeServer.verbose:
SynchronizedPrint.important.put_nowait(current_time()[11:-3] + ' Client ' + str(client_id) + ' connected')
KnowledgeServer.incoming_queue.put_nowait((KnowledgeServer.CENTRAL_CLIENT, '/central/client_connected ' + str(client_id), current_time()))
KnowledgeServer.connected_clients[client_id] = [sock, 'unknown', 'unknown', current_time(), 'secondary']
KnowledgeServer.next_client_number += 1
self.MessageSender(client_id).start()
buf = ''
while True:
try:
t = sock.recv(4096)
if t == '':
break
else:
buf += t
while True:
pos = buf.find('\n')
if pos == -1:
break
s = buf[:pos].rstrip()
if s != '':
KnowledgeServer.incoming_queue.put_nowait((client_id, s, current_time()))
buf = buf[pos + 1:]
except socket.error, (errno, _):
if errno == 10035 or errno == 11:
time.sleep(0.001)
continue
break
except:
def run(self):
server = self.ThreadingTCPServer((self.host, self.port), self.TCPHandler)
server.daemon_threads = True
server_thread = threading.Thread(target = server.serve_forever)
server_thread.daemon = True
server_thread.start()
self.ready = True
SynchronizedPrint.important.put_nowait(current_time()[11:-3] + ' Listening on ' + self.host + ':' + str(self.port))
while self.ready and server_thread.isAlive():
time.sleep(0.05)
self.ready = False
def _handle_msg(self, from_id, msg):
my_group = MultiIOServer.client_group[from_id]
parts = msg.split(' ', 2)
if len(parts) == 2 and parts[0] == '/general/multi_io_server/identify':
MultiIOServer.client_group[from_id] = parts[1].strip()
self._broadcast(from_id, '/multi_io_server/client_identified ' + str(from_id) + ' ' + parts[1].strip() + ' ' + current_time())
else:
for (client_id, client_group) in MultiIOServer.client_group.items():
if from_id == client_id or client_group == None or my_group == client_group:
continue
if MultiIOServer.verbose:
SynchronizedPrint.queue.put_nowait(current_time()[11:-3] + ' ' + str(from_id) + '->' + str(client_id) + ': ' + msg)
MultiIOServer.message_queues[client_id].put_nowait(msg)
def identify_client(self, client_id, msg):
parts = msg.split(' ', 4)
if len(parts) != 5 or parts[0] != '/general/identify':
return
types = []
for key in KnowledgeServer.LISTENERS.keys():
types.append(re.escape(key))
match = re.match('/general/identify\s+(' + '|'.join(types) + ')\s+(primary|secondary)\s+([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})\.([0-9]+)\s+(.+)$', msg)
if match == None:
return
SynchronizedPrint.important.put_nowait(current_time()[11:-3] + ' Client ' + str(client_id) + ' recognised as type ' + match.group(1) + '(' + match.group(2) + ', ' + match.group(10) + ')')
KnowledgeServer.connected_clients[client_id][1] = match.group(1)
KnowledgeServer.connected_clients[client_id][2] = match.group(10)
KnowledgeServer.connected_clients[client_id][4] = match.group(2)
def run(self):
for client_type in self.LISTENERS.keys():
KnowledgeServer.received_messages_for[client_type] = []
self.MessagePasser().start()
server = self.ThreadingTCPServer((self.host, self.port), self.MyTCPHandler)
server.daemon_threads = True
server_thread = threading.Thread(target = server.serve_forever)
server_thread.daemon = True
server_thread.start()
self.ready = True
SynchronizedPrint.important.put_nowait(current_time()[11:-3] + ' Listening on ' + self.host + ':' + str(self.port))
while self.ready and server_thread.isAlive():
time.sleep(0.05)
self.ready = False
def handle(self):
sock = self.request
sock.setsockopt(socket.SOL_TCP, socket.TCP_NODELAY, 1)
with MultiIOServer.client_lock:
client_id = MultiIOServer.next_client_number
self._broadcast(client_id, '/multi_io_server/client_connected ' + str(client_id) + ' ' + current_time())
MultiIOServer.message_queues[client_id] = Queue.Queue()
MultiIOServer.client_group[client_id] = None
MultiIOServer.next_client_number += 1
sender = self.MessageSender(client_id, sock)
sender.start()
buf = ''
while sender.keep_running:
try:
t = sock.recv(4096)
if t == '':
break
else:
buf += t
while True:
pos = buf.find('\n')
if pos == -1:
break
s = buf[:pos].rstrip()
if s != '':
self._handle_msg(client_id, s)
buf = buf[pos + 1:]
except socket.error, (errno, _):
if errno == 10035 or errno == 11:
time.sleep(0.001)
continue
break
except:
def _broadcast(self, from_id, msg):
for (client_id, client_group) in MultiIOServer.client_group.items():
if from_id == client_id or client_group == None:
continue
SynchronizedPrint.important.put_nowait(current_time()[11:-3] + ' Broadcast ' + str(from_id) + '->' + str(client_id) + ': ' + msg)
MultiIOServer.message_queues[client_id].put_nowait(msg)
pos = buf.find('\n')
if pos == -1:
break
s = buf[:pos].rstrip()
if s != '':
self._handle_msg(client_id, s)
buf = buf[pos + 1:]
except socket.error, (errno, _):
if errno == 10035 or errno == 11:
time.sleep(0.001)
continue
break
except:
break
self._broadcast(client_id, '/multi_io_server/client_disconnected ' + str(client_id) + ' ' + current_time())
MultiIOServer.client_group[client_id] = None
sender.keep_running = False
def run(self):
server = self.ThreadingTCPServer((self.host, self.port), self.TCPHandler)
server.daemon_threads = True
server_thread = threading.Thread(target = server.serve_forever)
server_thread.daemon = True
server_thread.start()
self.ready = True
SynchronizedPrint.important.put_nowait(current_time()[11:-3] + ' Listening on ' + self.host + ':' + str(self.port))
while self.ready and server_thread.isAlive():
time.sleep(0.05)
def run(self):
while True:
client_type = KnowledgeServer.connected_clients[self.client_id][1]
if client_type in KnowledgeServer.received_messages_for.keys():
break
time.sleep(0.001)
msg_list = KnowledgeServer.received_messages_for[client_type]
log_prefix = '/central/sent_message ' + client_type + ' ' + str(self.client_id) + ' '
pos = 0
while True:
try:
num = 0
old_pos = pos
messages = ''
while num < 5 and pos < len(msg_list):
msg = msg_list[pos]
if msg.is_valid() and (msg.target_id == -1 or msg.target_id == self.client_id):
if client_type != 'logger':
KnowledgeServer.received_messages_for['logger'].append(Message(log_prefix + current_time() + ' ' + msg.msg, -1, current_time(), None))
messages += msg.msg + '\n'
pos += 1
num += 1
if pos == old_pos:
time.sleep(0.001)
else:
KnowledgeServer.connected_clients[self.client_id][0].send(messages)
except:
break
def is_valid(self):
if self._expires == None:
return True
return current_time() < self._expires
if pos == -1:
break
s = buf[:pos].rstrip()
if s != '':
KnowledgeServer.incoming_queue.put_nowait((client_id, s, current_time()))
buf = buf[pos + 1:]
except socket.error, (errno, _):
if errno == 10035 or errno == 11:
time.sleep(0.001)
continue
break
except:
break
if not KnowledgeServer.verbose:
SynchronizedPrint.important.put_nowait(current_time()[11:-3] + ' Client ' + str(client_id) + ' disconnected')
KnowledgeServer.incoming_queue.put_nowait((KnowledgeServer.CENTRAL_CLIENT, '/central/client_disconnected ' + str(client_id), current_time()))
KnowledgeServer.connected_clients[client_id][0] = None
class MessagePasser(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
self.daemon = True
def mask_matches(self, mask, msg):
if mask[-1:] == '*':
return msg[:len(mask) - 1] == mask[:-1]
elif msg[:len(mask)] == mask:
return len(msg) == len(mask) or msg[len(mask)] == ' '
return False
import time
import os
if __name__ == "__main__":
parser = OptionParser()
parser.add_option('--multi_host', dest = 'multi_host', help = 'simulator server host MULTI_HOST (default read from host.txt line 1, otherwise machine name)',
default = common.host_finder.get_host())
parser.add_option('--multi_port', dest = 'multi_port', help = 'simulator server port MULTI_PORT (default 19999)', type = 'int', default = 19999)
parser.add_option('-v', '--verbose', dest = 'verbose', help = 'show more information', action = 'store_true', default = False)
options = parser.parse_args()[0]
SynchronizedPrint(options.verbose).start()
multi_io_server = multi_io_server.MultiIOServer(options.multi_host, options.multi_port, options.verbose)
multi_io_server.start()
SynchronizedPrint.important.put_nowait(current_time()[11:-3] + ' Waiting for the MultiIOServer to start')
while not multi_io_server.ready:
time.sleep(0.001)
SynchronizedPrint.important.put_nowait(current_time()[11:-3] + ' MultiIOServer started')
simulator_cmd = ['python', 'proxy.py']
simulator_cmd.append('--host')
simulator_cmd.append(options.multi_host)
simulator_cmd.append('--port')
simulator_cmd.append(str(options.multi_port))
simulator_cmd.append('--add_outgoing')
simulator_cmd.append('/general/multi_io_server/identify vision')
simulator_cmd.append('./simulator/simulator' + ('.exe' if os.name == 'nt' else ''))
try:
simulator = common.module_starter.ModuleStarter(simulator_cmd)
import time
if __name__ == "__main__":
parser = OptionParser()
parser.add_option('--host', dest = 'host', help = 'central server HOST (default read from host.txt line 1, otherwise machine name)',
default = common.host_finder.get_host())
parser.add_option('-p', '--port', dest = 'port', help = 'central server PORT (default 9999)', type = 'int', default = 9999)
parser.add_option('-z', '--zoom', dest = 'zoom', help = 'pitch zoom (positive integers only); default is 4', type = 'int', default = 4)
parser.add_option('-v', '--verbose', dest = 'verbose', help = 'show more information', action = 'store_true', default = False)
options = parser.parse_args()[0]
SynchronizedPrint(options.verbose).start()
knowledge_server = central.KnowledgeServer(options.host, options.port, options.verbose)
knowledge_server.start()
SynchronizedPrint.important.put_nowait(current_time()[11:-3] + ' Waiting for the knowledge server to start')
while not knowledge_server.ready:
time.sleep(0.001)
SynchronizedPrint.important.put_nowait(current_time()[11:-3] + ' Knowledge server started')
modules = {
'logger': ['python proxy.py --host ' + options.host + ' -p ' + str(options.port) + ' python logger.py', None],
'kicker': ['python proxy.py --host ' + options.host + ' -p ' + str(options.port) + ' python kicker.py', None],
}
try:
common.module_starter.ModuleStarter('python visualiser.py --host ' + options.host + ' -p ' + str(options.port) + ' -z ' + str(options.zoom)).start()
while knowledge_server.isAlive():
for (module, module_data) in modules.items():
if knowledge_server.have_module(module):
