def rpc(self, remote_procedure, args, kwargs):
self.lock.acquire()
try:
msg = message.Request(self.next_id, remote_procedure,
[args, kwargs])
self.next_id += 1
# Attempt sending and connection if neccessary
try:
msg.serialize(self.socket)
except socket.error as e:
# Connection error, try to connect and send
if e.args[0] == 32:
try:
self.socket.connect((self.host, self.port))
msg.serialize(self.socket)
except socket.error as e:
raise exception.JRPCError(
"Unable to connect to remote service", e)
else:
raise e
response = message.deserialize(self.socket)
if not type(response) is message.Response:
raise exception.JRPCError("Received a message of uknown type")
if response.id != msg.id:
raise exception.JRPCError(
0, "Got a response for a different request ID")
if hasattr(response, "result"):
return response.result
elif hasattr(response, "error"):
raise exception.JRPCError.from_error(response.error)
raise Exception("Deserialization failure!!")
finally:
self.lock.release()
def run(self):
recvd = ""
while self.running:
try:
msg = message.deserialize(self.socket)
if type(msg) is message.Request:
response = message.Response(msg.id)
if msg.method in self.service_obj.jbus_methods:
self.service_obj.lock.acquire()
try:
response.result = self.service_obj.jbus_methods[msg.method](msg.params)
self.log.info("{0} called \"{1}\" returning {2}".format(self.addr, msg.method, json.dumps(response.result)))
except Exception as e:
self.log.info("An exception occured while calling {0}: {1}".format(msg.method, e))
response.error = exception.exception_to_error(e)
finally:
self.service_obj.lock.release()
else:
response.error = {"code": -32601, "message": "No such method {0}".format(msg.method)}
response.serialize(self.socket)
else:
self.log.info("Got a message of uknown type")
except socket.timeout:
continue
except Exception as e:
self.log.info("Client socket exception: {0}".format(e))
break
self.close()
def rpc(self, remote_procedure, args):
self.lock.acquire()
try:
msg = message.Request(self.next_id, remote_procedure)
self.next_id += 1
msg.params = args
# Attempt sending and connection if neccessary
try:
msg.serialize(self.socket)
except socket.error as e:
# Connection error, try to connect and send
if e.args[0] == 32:
try:
self.socket.settimeout(60)
self.socket.connect((self.host, self.port))
self.socket.settimeout(60)
msg.serialize(self.socket)
except socket.error as e:
raise exception.JRPCError("Unable to connect to remote service", e)
else: raise e
response = message.deserialize(self.socket)
if not type(response) is message.Response:
raise exception.JRPCError("Received a message of uknown type")
if response.id != msg.id: raise exception.JRPCError(0, "Got a response for a different request ID")
if hasattr(response, "result"):
return response.result
elif hasattr(response, "error"):
raise exception.JRPCError.from_error(response.error)
raise Exception("Deserialization failure!!")
finally:
self.lock.release()
def serve_forever(self):
while not self.stop:
name, team, dest, data = deserialize(self.sock.recv(1024))
if data == '/drop' and self.drop != None:
sock.sendall(self.drop)
self.drop = None
if self.jammed:
logger.info('jammed -> {}: {}'.format(dest, data))
else:
logger.info('{} ({}) -> {}: {}'.format(name, team, dest, data))
def handle(self):
message = self.rfile.readline()
name, team, dest, data = deserialize(message)
while data != '/close':
# Handle wiretap enabling.
if re.match('/wiretap (.+)', data):
target = re.match('/wiretap (.+)', data).group(1)
logger.info('{} now wiretapping {}'.format(name, target))
if target in self.server.wiretaps:
self.server.wiretaps[target].append(name)
else:
self.server.wiretaps[target] = [name]
# Redirect wiretapped messages. This can be easily moved into the private message block below.
if name in self.server.wiretaps:
targets = [self.server.names[x] for x in self.server.wiretaps[name]]
self.server.send_to_group(message, set(targets))
del self.server.wiretaps[name]
logger.info('{} ({}) -> {}: {}'.format(name, team, dest, data))
# Resend packet.
if dest == 'all':
self.server.send_to_group(message, self.server.russians.union(self.server.americans))
elif dest == 'russians':
self.server.send_to_group(message, self.server.russians)
elif dest == 'americans':
self.server.send_to_group(message, self.server.americans)
elif dest in self.server.names:
self.server.send_to_group(message, set([self.server.names[dest]]))
else:
raise ValueError('Invalid dest: {}'.format(dest))
# Get the next message.
message = self.rfile.readline()
name, team, dest, data = deserialize(message)
def rpc(self, remote_procedure, args):
self.lock.acquire()
try:
msg = message.Request(self.next_id, remote_procedure)
self.next_id += 1
msg.params = args
msg.serialize(self.socket)
response = message.deserialize(self.socket)
if not type(response) is message.Response:
raise exception.JRPCError("Received a message of uknown type")
if response.id != msg.id: raise exception.JRPCError(0, "Got a response for a different request ID")
if hasattr(response, "result"):
return response.result
elif hasattr(response, "error"):
raise exception.JRPCError.from_error(response.error)
raise Exception("Deserialization failure!!")
finally:
self.lock.release()
def setup(self):
socketserver.StreamRequestHandler.setup(self)
# Wait for the /open message.
name, team, dest, data = deserialize(self.rfile.readline())
if data != '/open':
raise ValueError('First message ({}) to game server was not a /open'.format(data))
# Add the client to the appropriate groups.
self.server.connections[self.client_address] = self.wfile
self.server.names[name] = self.client_address
self.server.names[self.client_address] = name
if team == 'russians':
self.server.russians.add(self.client_address)
elif team == 'americans':
self.server.americans.add(self.client_address)
else:
raise ValueError('Invalid team: {}'.format(team))
logger.info('{} ({}) connected to: {}'.format(name, team, self.client_address))
def run(self):
recvd = ""
while self.running:
try:
msg = message.deserialize(self.socket)
if type(msg) is message.Request:
response = message.Response(msg.id)
method_target = self.service_obj.get_method(
msg.method.split('.'))
if method_target != None:
self.service_obj.lock.acquire()
try:
response.result = method_target(
*msg.params[0], **msg.params[1])
self._log.info(
"{0} called \"{1}\" returning {2}".format(
self.addr, msg.method,
json.dumps(response.result)))
except Exception as e:
self._log.info(
"An exception occured while calling {0}: {1}".
format(msg.method, e))
response.error = exception.exception_to_error(e)
finally:
self.service_obj.lock.release()
else:
response.error = {
"code": -32601,
"message": "No such method {0}".format(msg.method)
}
response.serialize(self.socket)
else:
self._log.info("Got a message of uknown type")
except socket.timeout:
continue
except Exception as e:
self._log.info("Client socket exception: {0}".format(e))
break
self.close()
