def set_worklist_execute_request_WLServer_check_response( self, response_type): """ 更新数据到发起工单执行的地方,表示工单执行check响应 """ if not (event.EV_WORKLIST_EXECUTE_RQST == self.msg_type): return if not self.dut_obj_handle: err_info = "dut_handle is None." log.debug_err(err_info) self.handle_request_except(self.msg, self.conn, err_info) return if not (isinstance(self.dut_obj_handle, DUTqueue.DUTQueue)): err_info = "dut_handle instance not DUTQueue object." log.debug_err(err_info) self.handle_request_except(self.msg, self.conn, err_info) return #send exec worklist event to WLserver response log.debug_info( "Set Worklist Server's response client request check suc") self.dut_obj_handle.set_worklist_execute_request_WLServer_check_response( response_type)
def handle_close_wait_rpc_response_control(self, response_suc_flag=False, response_message=None): """ 关闭等待PRC执行结果控制,根据ACS返回结果进程处理,并将消息发送回RPC请求端 """ if not self.rpc_request_node_message: return #[step-0] tmp_request_msg = self.rpc_request_node_message[0] tmp_request_client_conn = self.rpc_request_node_message[1] #[step-1] if (True == response_suc_flag and None != response_message): # send rpc response message to client ResponseClientHandle.handle_send_response(response_message, tmp_request_client_conn) log.debug_info("Agent send rpc response suc to client") else: # send rpc except message to client err_info = "ACS server's rpc response message type error" log.debug_err(err_info) ResponseClientHandle.handle_except(tmp_request_msg, tmp_request_client_conn, err_info) log.debug_info("Agent send rpc response error to client") #[step-2] #reset self.rpc_request_node_message value self.rpc_request_node_message = None
def start_queue_event_ctrl_thread(self, queue_type, request): """ 状态消息队列处理线程 """ if queue_type in self.dict_queue_expire_property: tmp_expire = self.dict_queue_expire_property[queue_type] if -1 == tmp_expire or 1 == tmp_expire: # changed queue expire property value self.dict_queue_expire_property[queue_type] = 0 # create one thread to call queue event control thread tmp_queue_event_ctr_thread = DUTQueueEventCtrlThread( self, queue_type) tmp_thread_name = "tname_" tmp_thread_name += str(queue_type) tmp_queue_event_ctr_thread.setName(tmp_thread_name) log.debug_err("new thread name=%s" % tmp_thread_name) # start queue event control thread tmp_queue_event_ctr_thread.start() else: pass else: err_info = "DUTQueue queue_type(=%d) not found!" % queue_type log.debug_err(err_info) message = request[0] conn = request[1] ResponseClientHandle.handle_except(message, conn, err_info) return DUTQueue.DUTQUEUE_FAIL return DUTQueue.DUTQUEUE_SUC
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 read_config(): ret, ret_data = config.read_cfg(path=CONFIG_PATH, keys="worklist") if ret == config.FAIL: err_info = "read config file failed, err info:%s!" % ret_data log.debug_err(err_info) ret_data = {} return ret_data
def get_all_parameters_type(self): """ parse all files in self.file_path, and save the parse result in self.dict_parameters_type """ try: # parse custom xml file self.file_path = os.path.join(os.path.dirname(__file__), "customdatadef", "motive") self.get_all_motive_parameters_type() # parse datamodeldef self.file_path = os.path.join(os.path.dirname(__file__), "datamodeldef") # first parse "tr-106-1-0-0-types.xml" self.parse_data_type() # get all files name in self.file_path list_all_file = os.listdir(self.file_path) # removed the parsed file "tr-106-1-0-0-types.xml" list_all_file.remove("tr-106-1-0-0-types.xml") count = 0 while list_all_file != []: count += 1 log.debug_info("count:", str(count)) # backup files name list tmp_list_all_file = list_all_file[:] for i in range(len(tmp_list_all_file)): # ignore directory if os.path.isdir( os.path.join(self.file_path, tmp_list_all_file[i])): list_all_file.remove(tmp_list_all_file[i]) continue # parse each file in tmp_list_all_file res = self.parse_tr069_parameters_definition( tmp_list_all_file[i]) if res == PARSE_UNFINISH: continue else: log.debug_info("parse suc:", tmp_list_all_file[i]) # remove the parsed successfully file list_all_file.remove(tmp_list_all_file[i]) # update dict_parameters_type self.dict_parameters_type.update(res) log.debug_info("parse motive xml file end") except Exception, e: log.debug_err(e)
def send_http_msg(in_message, in_timeout=300, in_try_count=0, in_url="127.0.0.1", in_method="POST"): """ send http request to WorkList Server Server or Worklist Server, and wait for response, if timeout, return time out, if response is not 200 OK, return errorno. """ tmp_try_count = 0 if in_try_count >= 0: tmp_try_count = in_try_count while 1: #in_try_count>0: conn = None try: conn = httplib2.Http(timeout=in_timeout) res, content = conn.request(in_url, method=in_method, body=in_message) except Exception, e: if e.message == "timed out": log.debug_info("Wait for HTTP server's response timeout!") if tmp_try_count > 0: log.debug_info( "Try(try_count=%d) send HTTP request event" % tmp_try_count) tmp_try_count -= 1 continue else: return ("error", "time out") else: err_info = "Send HTTP request occurs exception:%s" % e log.debug_err(err_info) return ("error", err_info) else: #交互正常结束,客户端主动断开连接 #add by wangjun 20130726 if conn: conn.close() log.debug_info( "Close agent created to ACS Server's or WorkList Server's HTTP client connect" ) status = res.get('status') if status == "200": return ("response", content) else: return ("fail", status)
def handle_event_worklistserver2agent(self, msg_type, msg_priority_level, request, msg_key_sender): """ 分发从WorklistServer端来的消息,主要分为RPC请求和执行工单消息响应。 """ if not (event.KEY_SENDER_WORKLIST == msg_key_sender): return False msg_group = int(msg_type) & 0xFF00 if (msg_group == event.EVENT_RPC_GROUP): #工单过程中的RPC方法,将它分发到 WLrpc_queue self.dispath_event_to_WLrpc(msg_type, request) elif (msg_group == event.EVENT_WORKLIST_GROUP): #工单执行的消息响应,工单执行结果 # intercept worklist server response worklist execute data if msg_type == event.EV_WORKLIST_EXECUTE_RSP_RQST: #防止工单执行线程在服务器返回信息以后,由于处理时间差仍然超时的问题。 #add by wangjun 20130627 self.reset_check_WLexec_status_totalcount() log.debug_info("Reset check_WLexec_status_totalcount=%d" % self.check_WLexec_status_totalcount) #[step-1] response EV_WORKLIST_EXECUTE_RSP_PSP to worklist server message = request[0] conn = request[1] ResponseClientHandle.handle_response_worklistserver_WLexec_response_post( message, conn) #[step-2] response EV_WORKLIST_EXECUTE_PSP to acs server if not self.WLexec_request_node_message: err_info = "DUTQueue not found running worklist request" log.debug_err(err_info) ResponseWLexecHandle.handle_WLexec_request_except( message, err_info) return True # set worklist exec response to ACS ResponseWLexecHandle.handle_WLexec_finish_request( self.WLexec_request_node_message[0], message, conn) #[step-3] #reset self.WLexec_request_node_message value self.WLexec_request_node_message = None else: log.debug_err("DUTQueue not found event type request") return False else: return False return True
def process_event(self, queue_type): """ 队列消息处理线程回调接口,这里根据队列类型完成了不同消息队列消息节点的处理。 """ log.debug_err("process_event start, queue type=(%d)." % queue_type) # used to counter how long there is no request send to current DUTQueue counter = 0 # check queue expire property and loop read queue message request while (0 == self.get_queue_expire_property(queue_type)): request_node = None # get queue header node if self.DUT_QUEUE_MODULE_TYPE_QUERY == queue_type: request_node = self.get_query_event_queue_header_node() elif self.DUT_QUEUE_MODULE_TYPE_REQUEST == queue_type: request_node = self.get_request_event_queue_header_node() #add by wangjun 20120522 elif self.DUT_QUEUE_MODULE_TYPE_WL_REQUEST == queue_type: request_node = self.get_WLrpc_event_queue_header_node() else: request_node = None if None == request_node: # when self.request_queue is [], set self.cur_handle_request to [] if self.DUT_QUEUE_MODULE_TYPE_REQUEST == queue_type: self.cur_handle_request = [] counter += 1 # when there is no request , counter add 1 # if current dut don't have request in max idle time , set expire to 1 if counter >= (MAX_IDLE_TIME / 2): self.set_queue_expire_property(queue_type, 1) else: sleep(2) continue else: counter = 0 if self.DUT_QUEUE_MODULE_TYPE_REQUEST == queue_type: self.cur_handle_request = request_node message = request_node[0] conn = request_node[1] self.send_event(queue_type, message, conn) log.debug_err("process_event exit, queue type=(%d)." % queue_type)
def create_soap_envelope(self, rpc_name, cwmp_version="cwmp-1-0", rpc_args="", cwmp_id=""): """ create soap envelope, and convert the structure to xml rpc_name: RPC name need to create cwmp_version: CPE supported cwmp version, default is cwmp-1-0 rpc_args: RPC arguments, default is "" """ log.debug_info("create_soap_envelope") try: dict_envelope_attrib = { 'xmlns:SOAP-ENV': 'http://schemas.xmlsoap.org/soap/envelope/', 'xmlns:SOAP-ENC': 'http://schemas.xmlsoap.org/soap/encoding/', 'xmlns:xsd': 'http://www.w3.org/2001/XMLSchema', 'xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance' } dict_envelope_attrib[ 'xmlns:cwmp'] = '' + 'urn:dslforum-org:' + cwmp_version # create an element self.soap_envelope = Element('SOAP-ENV:Envelope', dict_envelope_attrib) # set root of tree self.soap._setroot(self.soap_envelope) # create sub elemnts of soap_envelop self.soap_header = Element('SOAP-ENV:Header') self.soap_body = Element('SOAP-ENV:Body') # add soap_header and soap_body to soap_envelope self.soap_envelope.append(self.soap_header) self.soap_envelope.append(self.soap_body) # create sub elements of soap header self.create_soap_header(cwmp_id) # create sub elements of soap body self.create_soap_body(rpc_name, rpc_args) # convert structure to xml self.str_xml = tostring(self.soap_envelope) except Exception, e: log.debug_err(e) return CONSTRUCT_FAIL, e
def start_service(): """ start service of useragent """ log.debug_info("Start agent service...") # start SocketServer to wait for client connection try: ss_obj = agenthttpserver.start_http_server() except Exception, e: err_info = "Agent service occurs expection: %s" % e log.debug_err(err_info)
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 join_WLrpc_event_queue(self, request): """ 将消息加入到工单RPC队列,该队列是用来处理执行工单过程中,工单的RPC请求。 """ log.debug_err("join_WLrpc_event_queue") # start dut queue event ctrl thread rc = self.start_queue_event_ctrl_thread( self.DUT_QUEUE_MODULE_TYPE_WL_REQUEST, request) if DUTQueue.DUTQUEUE_FAIL == rc: return rc # get lock to update self.qurey_queue self.WLrpc_queue_lock.acquire() self.WLrpc_queue.append(request) self.WLrpc_queue_lock.release() return DUTQueue.DUTQUEUE_SUC
def set_rpc_request_ACSServer_check_response(self, response_type): if not self.dut_obj_handle: err_info = "dut_handle is None." log.debug_err(err_info) self.handle_request_except(self.msg, self.conn, err_info) return if not (isinstance(self.dut_obj_handle, DUTqueue.DUTQueue)): err_info = "dut_handle instance not DUTQueue object." log.debug_err(err_info) self.handle_request_except(self.msg, self.conn, err_info) return #send exec worklist event to WLserver response log.debug_info("Set ACS Server's response client request check suc") self.dut_obj_handle.set_rpc_request_ACSServer_check_response( response_type)
def dispath_event_to_WLrpc(self, msg_type, request): """ 将工单RPC方法加入到WLrpc_queue队列 """ # dispatch try: if not self.WLexec_request_node_message: log.debug_err("DUTQueue not found running worklist request.") self.reset_check_WLexec_status_totalcount() log.debug_info("Reset check_WLexec_status_totalcount=%d" % self.check_WLexec_status_totalcount) self.join_WLrpc_event_queue(request) except Exception, e: err_info = "DUTQueue dispath_event_to_WLrpc function occurs exception:%s" % e log.debug_err(err_info) message = request[0] conn = request[1] ResponseClientHandle.handle_except(message, conn, err_info)
def keepalive_request_response(request_message, conn): """ 处理守护进程的心跳包数据 """ message_type = request_message.get(event.KEY_MESSAGE) if message_type != event.EV_QUERY_IS_HANG_RQST: return False try: msg_obj = request_message.get(event.KEY_OBJECT) strio = StringIO(msg_obj) recv_data_obj = pickle.load(strio) except Exception, e: err_info = "keepalive_request_response: Unpickle event.KEY_OBJECT occurs error:%s" % e log.debug_err(err_info) request_message[event.KEY_MESSAGE] = message_type + 2 #发送响应消息 ResponseClientHandle.handle_send_response(request_message, conn) return True
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_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 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 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 get_all_motive_parameters_type(self): """ parse all files in motive directory, and save the parse result in self.dict_parameters_type """ try: # get all files name in self.file_path list_all_file = os.listdir(self.file_path) while list_all_file != []: # backup files name list tmp_list_all_file = list_all_file[:] for i in range(len(tmp_list_all_file)): # ignore directory if os.path.isdir( os.path.join(self.file_path, tmp_list_all_file[i])): list_all_file.remove(tmp_list_all_file[i]) continue # parse each file in tmp_list_all_file res = self.parse_motive_xml_definition( tmp_list_all_file[i]) if res == PARSE_UNFINISH: continue else: log.debug_info("parse suc:", tmp_list_all_file[i]) # remove the parsed successfully file list_all_file.remove(tmp_list_all_file[i]) # update dict_parameters_type self.dict_parameters_type.update(res) log.debug_info("parse end") except Exception, e: log.debug_err(e)
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 send_http_msg_notry(in_message, in_timeout=300, in_try_count=0, in_url="127.0.0.1", in_method="POST"): """ send http request to WorkList Server Server or Worklist Server, and wait for response, if timeout, return time out, if response is not 200 OK, return errorno. """ try: conn = httplib2.Http(timeout=in_timeout) res, content = conn.request(in_url, method=in_method, body=in_message) except Exception, e: if e.message == "timed out": log.debug_info("Wait for HTTP server's response timeout!") return ("error", "time out") else: err_info = "Send HTTP request occurs exception:%s" % e log.debug_err(err_info) return ("error", err_info)
def join_query_event_queue(self, msg_priority_level, request): """ 将消息加入到查询队列,如果消息的优先级高,则放入队列头 """ log.debug_err("join_query_event_queue") # start dut queue event ctrl thread rc = self.start_queue_event_ctrl_thread( self.DUT_QUEUE_MODULE_TYPE_QUERY, request) if DUTQueue.DUTQUEUE_FAIL == rc: return rc # get lock to update self.qurey_queue self.query_queue_lock.acquire() if msg_priority_level == event.PRIORITY_HIGH: self.query_queue.insert(0, request) else: # msg_priority_level default value:event.PRIORITY_DEFAULT self.query_queue.append(request) self.query_queue_lock.release() return DUTQueue.DUTQUEUE_SUC
def join_request_event_queue(self, msg_priority_level, request): """ 将消息加入到请求队列,如果消息的优先级高,则将消息加入到HIGH队列,该队列会优先执行 """ log.debug_err("join_request_event_queue") # start dut request event ctrl thread rc = self.start_queue_event_ctrl_thread( self.DUT_QUEUE_MODULE_TYPE_REQUEST, request) if DUTQueue.DUTQUEUE_FAIL == rc: return rc # get lock to update self.request_queue self.request_queue_lock.acquire() if msg_priority_level == event.PRIORITY_HIGH: self.request_queue_priority_high.append(request) else: # msg_priority_level default value:event.PRIORITY_DEFAULT self.request_queue_priority_normal.append(request) self.request_queue_lock.release() return DUTQueue.DUTQUEUE_SUC
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 handle_WLexec_request(dut_handle, request_event_msg, message, conn): """ 构建工单执行消息,并将消息发送到Worklist Server """ log.debug_err("handle_WLexec_request start") # construct worklist execute request tmp_WLexecute_msg = constructWLrequesthandle.ConstructWLRequestHandle.construct_WLexec_request( message) if None == tmp_WLexecute_msg: err_info = "Construct WLexecute request fail." log.debug_err(err_info) ResponseClientHandle.handle_except(request_event_msg, conn, err_info) return else: # send worklist execture request to worklist Server if not dut_handle: err_info = "dut_handle is None." log.debug_err(err_info) ResponseClientHandle.handle_except(request_event_msg, conn, err_info) return if not (isinstance(dut_handle, DUTQueue)): err_info = "dut_handle instance not DUTQueue object." log.debug_err(err_info) ResponseClientHandle.handle_except(request_event_msg, conn, err_info) return dut_handle.send_worklist_execute_event_to_WLserver( dut_handle, tmp_WLexecute_msg, conn) return
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