def on_recv(self):
""" recieve request and return reply. """
try:
protocol = Protocol()
head_size = protocol.get_head_size()
head = self.recvall(head_size)
if len(head) != head_size:
raise CommunicateException("Connection closed by peer")
_type, size, codec = protocol.parse_head(head)
if size > 0 and size < MAX_MESSAGE_LENGTH:
body = self.recvall(size) # raise CommunicateException
try:
print("recv raw: %s" % body)
body = codec.decode(body[:-4])
log.info("recv: %s" % body)
except Exception as ex:
e = "Decode Request Message Body Error: %s" % ex
log.error(e)
raise ProtocolException(e)
else:
raise CommunicateException("size error: " + str(size))
if _type == MSG_TYPE_REQUEST:
# break up the request
req_id, func_name, params = body["id"], body["func"], body["params"]
log.info("in %s(%s)" % (func_name, params))
self.reply_cli(req_id, func_name, params)
log.info("out %s(%s)" % (func_name, params))
except Exception as e:
log.warning("on_recv: %s" % str(traceback.format_exc()))
def on_recv(self):
""" recieve request and return reply. """
try:
protocol = Protocol()
head_size = protocol.get_head_size()
head = self.recvall(head_size)
if len(head) != head_size:
raise CommunicateException("Connection closed by peer")
_type, size, codec = protocol.parse_head(head)
if size > 0 and size < MAX_MESSAGE_LENGTH:
body = self.recvall(size) # raise CommunicateException
try:
body = codec.decode(body[:-4])
except Exception as ex:
e = "Decode Request Message Body Error: %s" % ex
log.error(e)
raise ProtocolException(e)
else:
raise CommunicateException("size error: " + str(size))
if _type == MSG_TYPE_REPLY:
log.info("recv : %s" % body)
else:
log.error("Unknown Message Ignoring...")
return body
except Exception as e:
log.warning("on_recv: %s" % str(traceback.format_exc()))
def on_recv(self):
""" recieve request and return reply. """
protocol = Protocol()
_type, body = self._on_recv_body(protocol)
if _type == MSG_TYPE_REQUEST:
reply_code = code.SUCCESS
# break up the request
sub_data = None
reply_msg = None
recv_data = None
try:
req_id, func_name, params = body["id"], body["func"], body[
"params"]
log.info("in %s(%s)" % (func_name, params))
# get the result for the request
cab_cli = Client(cab_host, cab_port)
cab_cli.send(
json.dumps({
"func": func_name,
"params": params
}).encode())
recv_data = cab_cli.recv(80960)
recv_data_dic = json.loads(recv_data)
reply_code = recv_data_dic.get("code")
sub_data = recv_data_dic.get("sub_data", None)
reply_msg = recv_data_dic.get("reply_msg", None)
except ConnectionRefusedError as e:
reply_code = code.UNAVALIABLE_SERVICE
except Exception as ex:
log.warning(str(traceback.format_exc()))
reply_code = code.FAILED
_msg = str(ex)
reply_msg = reply_msg if reply_msg else code.CODE2MSG.get(
reply_code, "Unknown Error")
log.info("raw out: %s" % recv_data)
sub_data = json.dumps({}) if not sub_data else json.dumps(sub_data)
reply = Reply(req_id, get_machine_id(), reply_code, reply_msg,
sub_data)
msg = protocol.reply_to_raw(reply)
# print "reply msg: ", msg
self.send_to_remote(msg)
else:
log.error("Unknown Message Ignoring...")
def reply_cli(self):
try:
reply_id = "000001"
reply_code = 0
reply_msg = "Success"
data = {"sub_code": 1, "msg": "ok"}
reply = Reply(reply_id, reply_code, reply_msg, data)
protocol = Protocol()
msg = protocol.reply_to_raw(reply)
self.send(msg)
except Exception as e:
log.warning("reply_cli: %s" % str(e))
def reply_cli(self, req_id, func, params):
try:
reply_id = req_id
reply_code = 0
reply_msg = "Success"
simulate_func = getattr(self, func, None)
data = simulate_func(params) if simulate_func else {}
reply = Reply(reply_id, reply_code, reply_msg, data)
protocol = Protocol()
msg = protocol.reply_to_raw(reply)
self.send(msg)
print("send: %s" % msg)
log.info("send: %s" % msg)
except Exception as e:
log.warning("reply_cli: %s" % str(e))
def _heart_beat(self):
try:
with self.lock:
r = HeartBeat(get_machine_id())
data = Protocol().heart_to_raw(r)
self.cli.send(data)
except Exception as e:
log.warning("heatbeat: %s" % str(e))
def call_once(func, params=None, timeout=60):
cli = Client(c2r_server, c2r_port)
r = Request(func, params)
_id, data = Protocol().request_to_raw(r)
cli.send(data)
cli.recv(80960)
cli.close()
return
def run(self):
self._heart_beat()
while True:
try:
request = self.task.get(timeout=60)
_id, data = Protocol().request_to_raw(request)
with self.lock:
while True:
try:
self.cli.send(data)
break
except Exception as e:
log.warning(str(e))
time.sleep(1)
self.on_recv()
except queue.Empty:
self._heart_beat()
except Exception as e:
log.warning(str(e))
def _send_heardbeat(self):
r = HeartBeat(get_machine_id())
data = Protocol().heart_to_raw(r)
self.send_to_remote(data)
def call(self, func, params=None, timeout=60):
with self.lock:
r = Request(func, params)
_id, data = Protocol().request_to_raw(r)
self.cli.send(data)
return self.on_recv()