def build_rpc_request_timeout_message(self, request_message):
"""
构建等待RPC响应超时消息
"""
new_message = copy.deepcopy(request_message)
msg = ResponseClientHandle.switch_msg_stream_type_str2dict(new_message)
#new MsgRpcTimeout object
msg_cpe_sn = msg.get(event.KEY_SN)
#delete by wangjun 20130627
#msg_event=msg.get(event.KEY_MESSAGE)
#add by wangjun 20130627
tmp_obj = msg.get(event.KEY_OBJECT)
strio = StringIO(tmp_obj)
msg_user_rpc_obj = pickle.load(strio)
#changed by wangjun 20130627
new_msg_timeout_obj = event.MsgRpcTimeout(msg_cpe_sn, msg_user_rpc_obj)
#up new message type and event
msg[event.KEY_MESSAGE_TYPE] = event.EVENT_RPC_GROUP
msg[event.KEY_MESSAGE] = event.EV_RPC_AGENT_TIMEOUT_POST
msg[event.KEY_SENDER] = event.KEY_SENDER_AGENT
#up new message key object
strio = StringIO()
pickle.dump(new_msg_timeout_obj, strio)
msg[event.KEY_OBJECT] = strio.getvalue()
return msg
def get_WLexec_worklist_sn(WL_event_message):
"""
获取工单SN
"""
tmp_message = (ResponseClientHandle.switch_msg_stream_type_str2dict(
WL_event_message))
tmp_wl_obj = tmp_message.get(event.KEY_OBJECT)
strio = StringIO(tmp_wl_obj)
tmp_msg_key_obj = pickle.load(strio)
if (isinstance(tmp_msg_key_obj, event.MsgWorklistBuild)):
return None
tmp_key_sn = None
if (isinstance(tmp_msg_key_obj, event.MsgWorklist)):
tmp_key_sn = tmp_message.get(event.KEY_SN)
if not tmp_key_sn:
tmp_key_sn = tmp_msg_key_obj.sn
if tmp_key_sn:
log.debug_err(tmp_key_sn)
else:
log.debug_err("Not found worklist sn data")
return tmp_key_sn
else:
log.debug_err("Not found worklist sn data")
return tmp_key_sn
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 handle_WLexec_start_request(request_event_msg, message, conn):
"""
构建工单开始消息，并分发到DUTQueue对象，加入到request_queue队列排队，等待处理
"""
log.debug_err("handle_WLexec_start_request start")
# construct worklist execute start request
tmp_WLexecutestart_msg = constructWLrequesthandle.ConstructWLRequestHandle.construct_WLexec_start_request(
message)
if None == tmp_WLexecutestart_msg:
err_info = "Construct WLexecute start request fail."
log.debug_err(err_info)
ResponseClientHandle.handle_except(request_event_msg, conn,
err_info)
return
else:
try:
#dispath worklist exectrue start request to queue object
tmp_dict_msg = ResponseClientHandle.switch_msg_stream_type_str2dict(
tmp_WLexecutestart_msg)
DUTqueuemanagement.DUTQueueManagement.insert_dut_obj(
[tmp_dict_msg, conn])
except Exception, e:
err_info = "DUTQueueManagement dispath request event occurs exception:%s" % e
log.debug_err(err_info)
ResponseClientHandle.handle_except(request_event_msg, conn,
err_info)
def handle_WLreserve_request(request):
"""
构建工单预约消息，并分发到DUTQueue对象
"""
log.debug_err("handle_WLreserve_request start")
message = request[0]
conn = request[1]
# construct worklist reseve request
tmp_WLreserve_msg = constructWLrequesthandle.ConstructWLRequestHandle.construct_WLreserve_request(
message)
if None == tmp_WLreserve_msg:
err_info = "DUTQueue construct WLreserve request fail."
log.debug_err(err_info)
ResponseClientHandle.handle_except(message, conn, err_info)
else:
try:
#dispath message to queue object
tmp_dict_msg = ResponseClientHandle.switch_msg_stream_type_str2dict(
tmp_WLreserve_msg)
DUTqueuemanagement.DUTQueueManagement.insert_dut_obj(
[tmp_dict_msg, conn])
except Exception, e:
err_info = "DUTQueueManagement dispath request event occurs exception:%s" % e
log.debug_err(err_info)
ResponseClientHandle.handle_except(message, conn, err_info)
def handle_ACS_worklist_info_response(self, message, conn):
"""
check acs server response worklist info data and call continue event
"""
response = ResponseClientHandle.switch_msg_stream_type_str2dict(
message)
msg_type = response.get(event.KEY_MESSAGE)
msg_group = int(msg_type) & 0xFF00
if (msg_group == event.EVENT_WORKLIST_GROUP):
# check worklist reseve response
if (msg_type == event.EV_WORKLIST_RESERVE_RSP):
log.debug_info("ACS server's response worklist reserve suc")
# call worklist execute start request
DUTqueue.ResponseWLexecHandle.handle_WLexec_start_request(
self.msg, response, None)
elif (msg_type == event.EV_WORKLIST_RESERVE_FAIL):
log.debug_info("ACS server's response worklist reserve fail")
ResponseClientHandle.handle_send_response(response, conn)
# check worklist start response
elif (msg_type == event.EV_WORKLIST_EXEC_START_RSP):
log.debug_info(
"ACS server's response worklist execute start suc")
# call worklist execute request
DUTqueue.ResponseWLexecHandle.handle_WLexec_request(
self.dut_obj_handle, self.msg, response, conn)
elif (msg_type == event.EV_WORKLIST_EXEC_START_FAIL):
log.debug_info(
"ACS server's response worklist execute start fail")
ResponseClientHandle.handle_send_response(response, conn)
# check worklist finish response
elif (msg_type == event.EV_WORKLIST_EXEC_FINISH_RSP):
log.debug_info(
"ACS server's response worklist execute finish suc")
elif (msg_type == event.EV_WORKLIST_EXEC_FINISH_FAIL):
log.debug_info(
"ACS server's response worklist execute finish fail")
# check worklist build/bind/download response
else:
ResponseClientHandle.handle_send_response(response, conn)
else:
err_info = "Unsupport msg event group:%d" % msg_group
log.debug_info(err_info)
ResponseClientHandle.handle_except(self.msg, self.conn, err_info)
def hanale_worklistserver_response(self, message, conn):
"""
check worklist server response data and call continue event
"""
#检查消息的完整性
tmp_msg_is_complete = ResponseClientHandle.check_message_complete(
message)
if False == tmp_msg_is_complete:
log.debug_info(message)
err_info = "Recv WorkList server's response incomplete"
log.debug_info(err_info)
self.handle_request_except(self.msg, self.conn, err_info)
return
else:
response = ResponseClientHandle.switch_msg_stream_type_str2dict(
message)
msg_group = int(response.get(event.KEY_MESSAGE)) & 0xFF00
if (msg_group == event.EVENT_WORKLIST_GROUP):
#检查返回消息与请求消息的匹配关系
if not self.handle_response_message_type_verify(
response.get(event.KEY_MESSAGE)):
err_info = "WorkList server's response message type error"
log.debug_info(err_info)
self.handle_request_except(self.msg, self.conn, err_info)
return
#当请求消息是执行工单时，特殊处理，
if (event.EV_WORKLIST_EXECUTE_RQST == self.msg_type):
#更新工单等待执行状态，表示发起工单成功
self.set_worklist_execute_request_WLServer_check_response(
"request_suc")
else: #worklist download
#其他消息正常处理
# send worklist down to user or ACS
ResponseClientHandle.handle_send_response(response, conn)
else:
err_info = "Unsupport msg event group:%d" % msg_group
log.debug_info(err_info)
self.handle_request_except(self.msg, self.conn, err_info)
return
def construct_agent_send_message_sequence_property(self):
"""
更新从Agent发送出去消息的KEY_SEQUENCE属性
"""
new_message = ResponseClientHandle.switch_msg_stream_type_str2dict(
self.msg)
#生成sequence_id
in_sequence_id = MessageProcessing.construct_sequence_id(
event.KEY_SENDER_AGENT)
#更新sequence属性数据
new_message[event.KEY_SEQUENCE] = in_sequence_id
log_info = ("HttpClientToWorklistServer construct sequence id: %s" %
in_sequence_id)
log.debug_info(log_info)
self.msg = ResponseClientHandle.switch_msg_stream_type_dict2str(
new_message)
def handle_WLexec_finish_request(WLexec_r_message, message,
conn): #request_event_msg
"""
构建工单执行结果消息
"""
# construct worklist execute start request
tmp_WLexecutefinish_msg = constructWLrequesthandle.ConstructWLRequestHandle.construct_WLexec_finish_request(
message)
#log.debug_err(tmp_WLexecutefinish_msg)
if not tmp_WLexecutefinish_msg:
err_info = "Construct WLexecute finish request fail."
log.debug_err(err_info)
ResponseWLexecHandle.handle_WLexec_request_except(
WLexec_r_message, err_info)
else:
tmp_dict_msg = ResponseClientHandle.switch_msg_stream_type_str2dict(
tmp_WLexecutefinish_msg)
DUTqueuemanagement.DUTQueueManagement.insert_dut_obj(
[tmp_dict_msg, conn])
def handle_WLexec_request_except(WLexec_r_message, except_info):
"""
执行工单异常处理
"""
if not WLexec_r_message:
err_info = "WLexec request message is None."
return
tmp_worklistid = ResponseWLexecHandle.get_WLexec_worklist_id(
WLexec_r_message)
if None == tmp_worklistid:
return
tmp_dict_ret = {}
tmp_dict_ret['str_result'] = except_info
tmp_dict_ret['dict_data'] = {
"FaultCode": agentcfg.AGENT_ERROR_CODE,
"FaultString": "Agent error"
}
tmp_WLexecute_except_msg = constructWLrequesthandle.ConstructWLRequestHandle.construct_WLexec_request_except(
tmp_worklistid, tmp_dict_ret)
log.debug_err(tmp_WLexecute_except_msg)
if None == tmp_WLexecute_except_msg:
err_info = "Construct WLexecute request except fail."
log.debug_err(err_info)
else:
try:
#log.debug_err(tmp_WLexecute_except_msg)
#dispath worklist exectrue finish request to queue object
tmp_dict_msg = ResponseClientHandle.switch_msg_stream_type_str2dict(
tmp_WLexecute_except_msg)
DUTqueuemanagement.DUTQueueManagement.insert_dut_obj(
[tmp_dict_msg, None])
except Exception, e:
err_info = "DUTQueueManagement dispath request event occurs exception:%s" % e
log.debug_err(err_info)
def get_WLexec_worklist_id(WL_event_message):
"""
获取工单ID或SN
"""
"""
MSG_WL_DATA_STRUCT_LIST=[event.MsgWorklist,
event.MsgWorklistBuild,
event.MsgWorklistBindPhysical,
event.MsgWorklistBindLogical,
event.MsgWorklistExecute,
event.MsgWorklistExecStart,
event.MsgWorklistExecRsp,
event.MsgWorklistExecFinish,
event.MsgWorklistReserve,
event.MsgWorklistQuery]
"""
tmp_message = (ResponseClientHandle.switch_msg_stream_type_str2dict(
WL_event_message))
tmp_wl_obj = tmp_message.get(event.KEY_OBJECT)
strio = StringIO(tmp_wl_obj)
tmp_msg_key_obj = pickle.load(strio)
#print tmp_msg_key_obj
#print event.MsgWorklist
tmp_wl_id = None
if (isinstance(tmp_msg_key_obj, event.MsgWorklist)):
tmp_wl_id = tmp_msg_key_obj.id_
if tmp_wl_id:
log.debug_err(tmp_wl_id)
else:
log.debug_err("Not found worklist id data")
else:
log.debug_err("Not found worklist id data")
return tmp_wl_id
def handle_acsserver_response(self, message, conn):
"""
check acs server response data and call continue event
"""
response = ResponseClientHandle.switch_msg_stream_type_str2dict(
message)
msg_type = response.get(event.KEY_MESSAGE)
msg_group = int(msg_type) & 0xFF00
#特殊处理AGENT 构建的给ACS的TIMOUT消息响应
if self.msg_type == event.EV_RPC_AGENT_TIMEOUT_POST:
if msg_type == event.EV_RPC_AGENT_TIMEOUT_RSP:
log.debug_info(
"ACS server's response check agent timeout rpc request suc"
)
else:
log.debug_info(
"ACS server's response check agent timeout rpc request fail"
)
return
#检查消息的合法性
#response message type error
if not self.handle_response_message_type_verify(
msg_group, msg_type, response):
#check EV_RPC_CHECK_FAIL response
if (msg_type == event.EV_RPC_CHECK_FAIL):
tmp_obj = response.get(event.KEY_OBJECT)
strio = StringIO(tmp_obj)
tmp_msg_key_obj = pickle.load(strio)
if not (isinstance(tmp_msg_key_obj, event.MsgUserRpcCheck)):
err_info = "ACS server's rpc response message type error"
log.debug_info(err_info)
else:
tmp_response_dict_ret = tmp_msg_key_obj.dict_ret
if "str_result" in tmp_response_dict_ret:
rc_str_result = tmp_response_dict_ret.get("str_result")
err_info = "ACS server's rpc response check message fail, str_result: " + rc_str_result
log.debug_info(err_info)
else:
err_info = "ACS server's rpc response message not found dict_ret data"
log.debug_info(err_info)
else:
err_info = "ACS server's rpc response message type error"
log.debug_info(err_info)
ResponseClientHandle.handle_except(self.msg, self.conn, err_info)
return
#response rpc post
if (msg_group == event.EVENT_QUERY_GROUP
or msg_group == event.EVENT_CONFIGURE_GROUP):
# send response to user or ACS
ResponseClientHandle.handle_send_response(response, conn)
elif (msg_group == event.EVENT_RPC_GROUP):
if not DUTqueue.WAIT_RPC_RESPONSE_POST_FALG:
# send response to user or ACS
ResponseClientHandle.handle_send_response(response, conn)
else:
self.set_rpc_request_ACSServer_check_response("request_suc")
#response worklist build/bind/reserve/start/finish info post
elif (msg_group == event.EVENT_WORKLIST_GROUP):
self.handle_ACS_worklist_info_response(response, conn)
else:
err_info = "Unsupport msg event group:%d" % msg_group
log.debug_info(err_info)
ResponseClientHandle.handle_except(self.msg, self.conn, err_info)