def send_event_rpc_methond(self, message, conn):
"""
发送RPC消息请求到ACS
"""
# reset flag to default value
self.request_rpc_suc_flag = False
self.rpc_request_node_message = [message, conn]
log.debug_err("send_event_rpc_methond")
# send rpc request to ACS Server
RequestClientHandle.send_event_to_acsserver(self, message, conn, True)
# check send http request response
if False == self.request_rpc_suc_flag:
log.app_info(
"(Request from client %s)ACS server's http request response except"
% ResponseClientHandle.get_client_ipaddress(conn))
else:
log.app_info(
"(Request from client %s)Begin wait ACS server's rpc response data."
% ResponseClientHandle.get_client_ipaddress(conn))
self.check_RPC_status_totalcount = int(
self.wait_request_response_timeout_length / 10)
while self.rpc_request_node_message and self.check_RPC_status_totalcount > 0:
self.check_RPC_status_totalcount -= 1
log.debug_err("self.check_RPC_status_totalcount=%d" %
self.check_RPC_status_totalcount)
sleep(10)
if 0 == self.check_RPC_status_totalcount:
err_info = (
"(Request from client %s)Wait ACS server's rpc event response timeout"
% ResponseClientHandle.get_client_ipaddress(conn))
log.debug_err(err_info)
ResponseClientHandle.handle_except(message, conn, err_info)
#send rpc request timeout to ACS Server #add by wangjun 20130624
tmp_rpc_timeout_message = self.build_rpc_request_timeout_message(
message)
RequestClientHandle.send_event_to_acsserver(
None, tmp_rpc_timeout_message, None, True)
log.app_info(
"(Request from client %s)End wait ACS server's rpc response data."
% ResponseClientHandle.get_client_ipaddress(conn))
#reset self.rpc_request_node_message value
self.rpc_request_node_message = None
def send_worklist_execute_event_to_WLserver(self, dut_handle, message,
conn):
"""
发送执行工单消息请求到Worklist Server
"""
# reset flag to default value
self.WLexec_request_node_message = [message, conn]
self.request_WLexec_worklist_suc_flag = False
# send worklist execture request to worklist Server
RequestClientHandle.send_event_to_WLserver(dut_handle, message, conn,
True)
# check send http request response
if False == self.request_WLexec_worklist_suc_flag:
log.app_info(
"(Request from client %s)WorkList server's http request response except."
% ResponseClientHandle.get_client_ipaddress(conn))
else:
log.app_info(
"(Request from client %s)Begin wait WorkList server's execute worklist response data."
% ResponseClientHandle.get_client_ipaddress(conn))
self.reset_check_WLexec_status_totalcount()
while (self.WLexec_request_node_message
and self.check_WLexec_status_totalcount > 0):
self.check_WLexec_status_totalcount -= 1
log.debug_err("self.check_WLexec_status_totalcount=%d" %
self.check_WLexec_status_totalcount)
sleep(10)
if 0 == self.check_WLexec_status_totalcount:
err_info = (
"(Request from client %s)Wait WorkList server's exec worklist event response timeout"
% ResponseClientHandle.get_client_ipaddress(conn))
log.debug_err(err_info)
ResponseWLexecHandle.handle_WLexec_request_except(
message, err_info)
log.app_info(
"(Request from client %s)End wait WorkList server's execute worklist response data."
% ResponseClientHandle.get_client_ipaddress(conn))
#reset self.WLexec_request_node_message value
self.WLexec_request_node_message = None
def handle_dispath_request(request):
"""
处理所有消息入口
"""
try:
msg = request.content.read()
conn = request
if msg:
try:
log.app_info(
"(Request from client %s)agent httserver recv message.\n" %
ResponseClientHandle.get_client_ipaddress(conn))
"""
log.debug_info("-------httserver handle_dispath_request----------")
log.debug_info(msg)
log.debug_info("-------------------------------------------------")
"""
msg = eval(msg)
except Exception, e:
err_info = "The structure of recv message is invalid!"
log.debug_err(err_info)
return
responseclient.g_http_client_count += 1
log.app_info(
"acceptConnection: Agent HTTP connected client count: %d" %
responseclient.g_http_client_count)
t = threading.Thread(target=root_dispath_evetn, args=(msg, conn))
t.setDaemon(True)
t.start()
def send_event_to_WLserver(dut_obj_handle, message, conn, block=True):
"""
used to send tcp request to Worklist Server
"""
try:
thread_i = httpclienttoworklist.HttpClientToWorklistServer(
dut_handle=dut_obj_handle,
url=agentcfg.WL_HTTP_SERVER_URL,
timeout=agentcfg.AGENT2WL_HTTP_CLIENT_TIMEOUT)
thread_i.msg = ResponseClientHandle.switch_msg_stream_type_dict2str(
message)
thread_i.msg_type = (
ResponseClientHandle.switch_msg_stream_type_str2dict(message)
).get(event.KEY_MESSAGE)
thread_i.conn = conn
thread_i.start()
if True == block:
thread_i.join()
except Exception, e:
err_info = (
"(Request from client %s)Start http client to WorkList's occurs exception:%s"
% (ResponseClientHandle.get_client_ipaddress(conn), e))
log.debug_err(err_info)
ResponseClientHandle.handle_except(message, conn, err_info)
def send_event(self, queue_type, message, conn):
"""
处理消息请求，并将消息分发到具体的功能服务器。
"""
err_info = ("(Request from client %s)DUTQueue send_event message(%s)" %
(ResponseClientHandle.get_client_ipaddress(conn),
event.get_event_desc(message.get(event.KEY_MESSAGE))))
log.debug_info(err_info)
#查询消息队列查询消息节点
if self.DUT_QUEUE_MODULE_TYPE_QUERY == queue_type:
msg_type = message.get(event.KEY_MESSAGE)
if msg_type == event.EV_WORKLIST_DOWNLOAD_RQST:
RequestClientHandle.send_event_to_WLserver(self, message, conn)
elif msg_type == event.EV_WORKLIST_EXEC_FINISH_RQST:
RequestClientHandle.send_event_to_acsserver(
self, message, conn, True)
else:
RequestClientHandle.send_event_to_acsserver(
self, message, conn)
#请求消息队列消息节点
elif self.DUT_QUEUE_MODULE_TYPE_REQUEST == queue_type:
if not WAIT_RPC_RESPONSE_POST_FALG:
RequestClientHandle.send_event_to_acsserver(
self, message, conn, True)
else:
msg_group = int(message.get(event.KEY_MESSAGE)) & 0xFF00
if msg_group == event.EVENT_RPC_GROUP:
self.send_event_rpc_methond(message, conn)
else:
RequestClientHandle.send_event_to_acsserver(
self, message, conn, True)
#工单RPC消息队列消息节点
elif self.DUT_QUEUE_MODULE_TYPE_WL_REQUEST == queue_type:
if not WAIT_RPC_RESPONSE_POST_FALG:
RequestClientHandle.send_event_to_acsserver(
self, message, conn, True)
else:
self.send_event_rpc_methond(message, conn)
else:
pass
return
def handle_event_user2agent(self, msg_type, msg_priority_level, request,
msg_key_sender):
"""
分发从USER端来的消息
"""
if not (event.KEY_SENDER_USER == msg_key_sender):
return False
#特殊处理EV_RPC_GETRPCMETHODS_RQST方法
#当有工单正在执行时，将该方法插入到工单RPC队列，等待马上执行
#当无工单正在执行时，将该方法加入到RPC HIGH队列，优先执行
if msg_type == event.EV_RPC_GETRPCMETHODS_RQST:
if self.WLexec_request_node_message:
log.debug_info(
"(Request from client %s)Insert EV_RPC_GETRPCMETHODS_RQST msg to worklist running rpc queue"
% ResponseClientHandle.get_client_ipaddress(request[1]))
#dispath event to WLrpc_queue
self.dispath_event_to_WLrpc(msg_type, request)
return True
else:
#up request KEY_PRIORITY_LEVEL value
request[0][event.KEY_PRIORITY_LEVEL] = event.PRIORITY_HIGH
msg_priority_level = event.PRIORITY_HIGH
#特殊处理从USER端来的请求执行工单消息
elif msg_type == event.EV_WORKLIST_EXECUTE_RQST:
log.debug_info(
"(Request from client %s)Agent response user exec worklist request event"
% ResponseClientHandle.get_client_ipaddress(request[1]))
self.intercept_client_worklist_execute_post(msg_type, request)
else:
pass
#将消息分发到具体的消息队列query_queue or request_queue
self.dispath_event_to_normal(msg_type, msg_priority_level, request)
return True
def dispath_event(self, msg_type, msg_priority_level, request,
msg_key_sender):
"""
分发消息总入口
"""
log.debug_info(
"(Request from client %s)DUTQueue dispath event key_sender=%s" %
(ResponseClientHandle.get_client_ipaddress(
request[1]), msg_key_sender))
tmp_intercept_flag = False
if (event.KEY_SENDER_USER == msg_key_sender
or event.KEY_SENDER_AGENT == msg_key_sender):
#处理AGENT自己构建的消息 #add by wangjun 20130717
if event.KEY_SENDER_AGENT == msg_key_sender:
msg_key_sender = event.KEY_SENDER_USER
tmp_intercept_flag = self.handle_event_user2agent(
msg_type, msg_priority_level, request, msg_key_sender)
elif (event.KEY_SENDER_ACS == msg_key_sender):
tmp_intercept_flag = self.handle_event_acsserver2agent(
msg_type, msg_priority_level, request, msg_key_sender)
elif (event.KEY_SENDER_WORKLIST == msg_key_sender):
tmp_intercept_flag = self.handle_event_worklistserver2agent(
msg_type, msg_priority_level, request, msg_key_sender)
else:
log.debug_info(
"(Request from client %s)DUTQueue dispath event error,unsupport message key_sender"
% ResponseClientHandle.get_client_ipaddress(request[1]))
if not tmp_intercept_flag:
err_info = "DUTQueue dispath event error"
log.debug_err(err_info)
message = request[0]
conn = request[1]
ResponseClientHandle.handle_except(message, conn, err_info)
def handle_event_acsserver2agent(self, msg_type, msg_priority_level,
request, msg_key_sender):
"""
分发从ACS端来的消息,消息来源分为执行逻辑工单和RPC方法响应。
"""
if not (event.KEY_SENDER_ACS == msg_key_sender):
return False
msg_group = int(msg_type) & 0xFF00
if (msg_group == event.EVENT_WORKLIST_GROUP):
#特殊处理从ACS端来的请求执行工单消息
if msg_type == event.EV_WORKLIST_EXECUTE_RQST:
log.debug_info(
"(Request from client %s)Agent response ACS's exec worklist request event"
% ResponseClientHandle.get_client_ipaddress(request[1]))
self.intercept_client_worklist_execute_post(msg_type, request)
#dispath event to query_queue or request_queue
self.dispath_event_to_normal(msg_type, msg_priority_level,
request)
else:
return False
elif (msg_group == event.EVENT_RPC_GROUP):
#特殊处理从ACS端来的RPC响应消息
if not WAIT_RPC_RESPONSE_POST_FALG:
return True
#[step-1]
message = request[0]
conn = request[1]
if not self.rpc_request_node_message:
log.debug_err(
"(Request from client %s)DUTQueue not found running rpc request"
% ResponseClientHandle.get_client_ipaddress(request[1]))
dict_ret = {}
dict_ret[
'str_result'] = "DUTQueue not found running rpc request"
dict_ret['dict_data'] = {}
ResponseClientHandle.handle_send_rpc_check_toACS_request_reponse(
message, conn, True, dict_ret)
return True
#防止RPC线程在服务器返回信息以后，由于处理时间差仍然超时的问题。
#add by wangjun 20130627
self.reset_check_rpc_status_totalcount()
log.debug_err("Reset check_RPC_status_totalcount=%d" %
self.check_RPC_status_totalcount)
#[step-2]
# check response from ACS server's(client rpc request)
tmp_request_msg_type = self.rpc_request_node_message[0].get(
event.KEY_MESSAGE)
log.debug_info(
"(Request from client %s)ACS server's rpc response RPC request(message=%s)"
% (ResponseClientHandle.get_client_ipaddress(
request[1]), event.get_event_desc(tmp_request_msg_type)))
#[step-3]
if not self.handle_response_message_type_verify(
tmp_request_msg_type, msg_type):
#[step-3-1]
# send response to user or ACS and reset self.rpc_request_node_message value
self.handle_close_wait_rpc_response_control()
#[step-3-2]
# send resoponse rpc check message to ACS
dict_ret = {}
dict_ret[
'str_result'] = "ACS server's rpc response message type error"
dict_ret['dict_data'] = {}
ResponseClientHandle.handle_send_rpc_check_toACS_request_reponse(
message, conn, True, dict_ret)
log.debug_info(
"(Request from client %s)ACS server's rpc response message fail"
% ResponseClientHandle.get_client_ipaddress(request[1]))
else:
#[step-3-1]
# send response to user or ACS and reset self.rpc_request_node_message value
self.handle_close_wait_rpc_response_control(
response_suc_flag=True, response_message=message)
#[step-3-2]
# send resoponse rpc check message to ACS
ResponseClientHandle.handle_send_rpc_check_toACS_request_reponse(
message, conn)
log.debug_info(
"(Request from client %s)ACS server's rpc response message suc"
% ResponseClientHandle.get_client_ipaddress(request[1]))
else:
log.app_info(
"(Request from client %s)ACS server's query or configure response message suc"
% ResponseClientHandle.get_client_ipaddress(request[1]))
return False
return True
def insert_dut_obj(request):
"""
解析消息，根据消息类型，分发到DUT_ID对应的DUTQueue对象消息队列中
"""
#检查消息的完整性
tmp_msg_is_complete = ResponseClientHandle.check_message_complete(
request[0])
if False == tmp_msg_is_complete:
err_info = "Recv client request event data incomplete"
log.debug_err(err_info)
ResponseClientHandle.handle_except(request[0], request[1],
err_info)
return
DUTQueueManagement.delete_expired_dut_obj()
message = request[0]
message_type = message.get(event.KEY_MESSAGE)
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#add by wangjun 20131024
#拦截守护进程的心跳包数据并发送响应结果
if (message_type == event.EV_QUERY_IS_HANG_RQST):
rc_status = DUTQueueManagement.keepalive_request_response(
message, request[1])
if True == rc_status:
#消息不在往下分发
return
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#add by wangjun 20130716
#获取消息的sequence id
message_sequence_id = message.get(event.KEY_SEQUENCE)
#将消息加入到MessageSequenceManagement管理队列中,如果该消息已经处理过了，
#则直接向client发送处理结果，并返回False标志，否则，返回True，继续消息分发流程
insert_sequence_rc = MessageSequenceManagement.insert_message_sequence_obj(
message_sequence_id, request[1])
if False == insert_sequence_rc:
return
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
log.app_info(
"(Request from client %s)Insert request(message==%s) to DUTQueue" %
(ResponseClientHandle.get_client_ipaddress(
request[1]), event.get_event_desc(message_type)))
dut_id = DUTQueueManagement.get_dut_id(message)
if None == dut_id:
err_info = "Not found message request sn data"
log.debug_err(err_info)
if (message_type == event.EV_WORKLIST_EXECUTE_RSP_RQST
): #add by wangjun 20130531
DUTqueue.ResponseWLexecHandle.handle_WLexec_request_except(
request[0], err_info)
else:
ResponseClientHandle.handle_except(request[0], request[1],
err_info)
return
log_dut_id = "insert_dut_obj get_dut_id=" + dut_id
log.debug_err(log_dut_id)
dut_obj_handle = DUTQueueManagement.get_dut_obj_handle(dut_id)
if None == dut_obj_handle:
if (message_type == event.EV_WORKLIST_EXECUTE_RSP_RQST
): #add by wangjun 20130531
err_info = "Not found execute worklist DUTQueue running process"
log.debug_err(err_info)
DUTqueue.ResponseWLexecHandle.handle_WLexec_request_except(
request[0], err_info)
else:
dut_obj_handle = DUTQueueManagement.new_dut_obj(dut_id)
if None == dut_obj_handle:
return
conn = request[1]
#add by wangjun 20130523
message_key_sender = message.get(event.KEY_SENDER)
if (None == message_key_sender):
message_key_sender = event.KEY_SENDER_USER
#open QUEUE_INIT key control to GUI #change by wangjun 20130826
if (event.KEY_SENDER_USER == message_key_sender):
dut_obj_request_queue_busy = DUTQueueManagement.handle_dutqueue_request_queue_status_check(
dut_obj_handle, message, conn)
if True == dut_obj_request_queue_busy:
log.debug_err("DUTQueue request queue busy")
return
else:
pass
#log.debug_err("insert_dut_obj call dispath_event")
message_priority_level = message.get(event.KEY_PRIORITY_LEVEL)
dut_obj_handle.dispath_event(message_type, message_priority_level,
request, message_key_sender)
def run(self):
"""
override run
"""
#更新从Agent发送出去消息的KEY_SEQUENCE属性 #add by wangjun 20130722
self.construct_agent_send_message_sequence_property()
# send http request and recv response
log.app_info(
"(Request from client %s)Send request(message=%s) to WorkList server's"
% (ResponseClientHandle.get_client_ipaddress(
self.conn), event.get_event_desc(self.msg_type)))
res, self.response = httpclienthandle.HttClientHandle.send_http_msg(
in_message=self.msg,
in_timeout=self.timeout,
in_try_count=3,
in_url=self.url,
in_method=self.method)
log.app_info(
"(Request from client %s)Recv WorkList Server server's response(request message=%s)"
% (ResponseClientHandle.get_client_ipaddress(
self.conn), event.get_event_desc(self.msg_type)))
# parse response data
try:
if res == "error":
err_info = "Agent to WorkList server's http client error:" + self.response
log.debug_err(err_info)
self.handle_request_except(self.msg, self.conn, err_info)
return
elif res == "fail":
err_info = "Agent to WorkList server's http client fail:" + self.response
log.debug_err(err_info)
self.handle_request_except(self.msg, self.conn, err_info)
return
elif res == "response":
#检查消息的完整性
check_complete_flag = ResponseClientHandle.check_message_complete(
self.response)
if False == check_complete_flag:
err_info = "Recv HTTP server's response incomplete"
log.debug_info(err_info)
self.handle_request_except(self.msg, self.conn, err_info)
return
else:
self.hanale_worklistserver_response(
self.response, self.conn)
return
except Exception, e:
err_info = "Pickle object occurs exception: %s" % e
log.debug_err(err_info)
self.handle_request_except(self.msg, self.conn, err_info)
return
