def create_soap_header(self, header_cwmp_id): """ create soap header """ log.debug_info("create_soap_header") # create sub element of soap header cwmp_id = Element('cwmp:ID', {'SOAP-ENV:mustUnderstand': '1'}) cwmp_hold_requests = Element('cwmp:HoldRequests', {'SOAP-ENV:mustUnderstand': '1'}) # set sub element's text # for cwmp:ID,create random num int_rand_num = random.randint(CWMP_ID_RANDOM_NUM_START, CWMP_ID_RANDOM_NUM_END) # element cwmp:ID's text need string type if header_cwmp_id: cwmp_id.text = header_cwmp_id else: cwmp_id.text = str(int_rand_num) # set cwmp:HoldRequests's text as 0 for default.maybe need to change later. cwmp_hold_requests.text = str(0) # add sub elments to soap_header self.soap_header.append(cwmp_id) self.soap_header.append(cwmp_hold_requests) return CONSTRUCT_SUC
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 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_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 handle_response_message_type_verify(self, msg_group, response_msg_type, message): """ """ # check response message type if (msg_group == event.EVENT_RPC_GROUP): if not DUTqueue.WAIT_RPC_RESPONSE_POST_FALG: if ((self.msg_type + 1) == response_msg_type or (self.msg_type + 2) == response_msg_type): return True else: return False tmp_obj = message.get(event.KEY_OBJECT) strio = StringIO(tmp_obj) tmp_msg_key_obj = pickle.load(strio) if not (isinstance(tmp_msg_key_obj, event.MsgUserRpcCheck)): return False tmp_event_request = tmp_msg_key_obj.event_rqst #log.debug_info(response_msg_type) log.debug_info("request message=%s" % event.get_event_desc(self.msg_type)) log.debug_info("response message=%s" % event.get_event_desc(tmp_event_request)) if (response_msg_type == event.EV_RPC_CHECK_RSP): if (self.msg_type == tmp_event_request): return True else: return False elif (response_msg_type == event.EV_RPC_CHECK_FAIL): return False else: return False elif (msg_group == event.EVENT_QUERY_GROUP or msg_group == event.EVENT_CONFIGURE_GROUP or msg_group == event.EVENT_WORKLIST_GROUP): if ((self.msg_type + 1) == response_msg_type or (self.msg_type + 2) == response_msg_type): return True else: return False return False
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 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 start_http_server(): try: ip = agentcfg.AGENT_HTTP_SERVER_IP port = agentcfg.AGENT_HTTP_SERVER_PORT g_webserver = AgentHttpServer(port) log.debug_info("Agent (ip=%s, port=%s) start." % (ip, port)) g_webserver.start() except Exception, e: err_info = "Agent http service occurs expection: %s" % e log.debug_info(err_info)
def get_children_value(self, element_object): """ get value of element_object's children_element recursively, return all children_element's [name,value] by list """ tmp_list = [] children_element_list = element_object.getchildren() if len(children_element_list) == 0: log.debug_info("element_object have no children") return None for element in children_element_list: sub_children_list = element.getchildren() if len(sub_children_list) == 0: tmp_list.append([element.tag, element.text, element.attrib]) else: tmp_list.append([element.tag, get_children_value(element)]) return tmp_list
def get_element_attribute(self, element_object, element_name): """ get the attribute of element_name under element_object. if element_name is not existed or there are more than one element_name,return none """ element_list = list(element_object.getiterator(tag=element_name)) if len(element_list) == 1: return element_list[0].attrib elif len(element_list) > 1: log.debug_info("There are more then one", element_name, "under", element_object) return None else: log.debug_info("There is no", element_name, "under", element_object) return None
def parse_motive_xml_definition(self, xml_file): """ parsed custom define motive xml file. return dict contain xml file's parameters' full name(keys) and parameters type(values) xml_file: be parsed xml file name """ log.debug_info("parsing ", xml_file) dict_results = {} # save current file parse parameter type results # parse xml file, and get the root object file_full_path = os.path.join(self.file_path, xml_file) root = ElementTree.parse(file_full_path).getroot() # get root children object list_root_children = root.getchildren() # go through all root children elements for root_children in list_root_children: # find dataModel node if root_children.tag == "dataModel": # find parameters node list_datamodel_children = root_children.getchildren() for datamodel_children in list_datamodel_children: if datamodel_children.tag == "parameters": # parse parameters's children node parameter list_parameters_children = datamodel_children.getchildren( ) for parameters_children in list_parameters_children: tmp_dict_parameter = self.parse_motive_parameter( parameters_children) # save parsed result to dict_results dict_results.update(tmp_dict_parameter) # ignore the node not parameters break # ignore the node not dataModel break return dict_results
def get_xmlschema_obj(): """ parse xmlschema xsd files, and return the object to verify xml file's validate """ # get the xsd files path path = os.path.dirname(__file__) + '\\schema\\' # get all files name list_all_file = os.listdir(path) for filename in list_all_file: try: full_path = path + filename xmlschema_doc = ElementTree.parse(full_path).getroot() xmlschema = ElementTree.XMLSchema(xmlschema_doc) Parse.m_xmlschema_list.append(xmlschema) except Exception, e: err_info = "Parse xml schema files occures error:%s" % e log.debug_info(err_info)
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 intercept_client_worklist_execute_post(self, msg_type, request): """ 当接收到client请求执行工单消息,立即回工单check消息给client,后续工单的执行状态,由client自己负责查询 """ if msg_type == event.EV_WORKLIST_EXECUTE_RQST: log.debug_info("Agent response client exec worklist request event") #init data message = request[0] conn = request[1] tmp_WLexec_request_msg = message.copy() #response user exec worklist request event ResponseClientHandle.handle_response_client_WLexec_request( tmp_WLexec_request_msg, conn) #clear client connected handle request[1] = None 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 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 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_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 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 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_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 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 parse_data_type(self): """ parse "tr-106-1-0-0-types.xml", get TR-069 Data Model Data Types save all defined data type in data_type dict. """ log.debug_info("parsing tr-106-1-0-0-types.xml") # get file full path file_full_path = os.path.join(self.file_path, "tr-106-1-0-0-types.xml") # parse xml file, and get the root object root = ElementTree.parse(file_full_path).getroot() # get all "dataType" object iterator iter_data_type = root.getiterator(tag="dataType") for object in iter_data_type: # get attributes of object dict_object_attrib = object.attrib # get name attribute value object_name = dict_object_attrib['name'] # if dataType have 'base' attribute, get data type from base dataType if 'base' in dict_object_attrib: object_base_name = dict_object_attrib['base'] # check 'base' name whether save in self.data_type or not if object_base_name in self.data_type: self.data_type[object_name] = self.data_type[ object_base_name] else: log.debug_info( object_name, "base", object_base_name, "but the base type is not exist, something is wrong!") else: # get data type from the second child element of dataType,the first is description list_object_children = object.getchildren() if len(list_object_children) == 2: # dataType have children object difined its data type self.data_type[object_name] = list_object_children[1].tag else: log.debug_info( object_name, "dataType struct is error, \ it have more than two children.")
def parse_tr069_parameters_definition(self, xml_file): """ parsed tr069 parameters definition xml file. return dict contain xml file's parameters' full name(keys) and parameters type(values) xml_file: be parsed xml file name """ log.debug_info("parsing ", xml_file) dict_results = {} # save current file parse parameter type results dict_components = {} # save current file parse components results # parse xml file, and get the root object file_full_path = os.path.join(self.file_path, xml_file) root = ElementTree.parse(file_full_path).getroot() # get root children object list_root_children = root.getchildren() # go through all root children elements for root_children in list_root_children: # get import components, save to dict_components if root_children.tag == "import": list_import_children = root_children.getchildren() if list_import_children != []: import_file_name = root_children.attrib['file'] check_flag = 1 # whether need to check imported file parsed or not for import_children in list_import_children: if import_children.tag == "component": if check_flag == 1: check_flag = 0 # just check one times if import_file_name not in self.dict_component: log.debug_info( "parse unfinish, need file ", import_file_name) return PARSE_UNFINISH component_name = import_children.attrib['name'] # component is rename in this file, get component definition from 'ref' if 'ref' in import_children.attrib: ref_name = import_children.attrib['ref'] dict_components[component_name] = \ self.dict_component[import_file_name][ref_name] else: dict_components[component_name] = \ self.dict_component[import_file_name][component_name] elif root_children.tag == "component": component_name = root_children.attrib['name'] # parse component's object-parameter struct dict_tmp_component = self.parse_parameter_struct(root_children) # get sub "component" defined in "component" list_children_component = root_children.getchildren() for children_component in list_children_component: if children_component.tag == "component": ref_name = children_component.attrib['ref'] dict_tmp_component.update(dict_components[ref_name]) # save parsed result to dict_components, use component_name as key dict_components[component_name] = dict_tmp_component elif root_children.tag == "model": # parse model's object-parameter struct dict_tmp_model = self.parse_parameter_struct(root_children) # save parsed result to dict_results dict_results.update(dict_tmp_model) # parse model's component struct list_model_children = root_children.getchildren() for model_children in list_model_children: if model_children.tag == "component": path_name = model_children.attrib['path'] ref_name = model_children.attrib['ref'] # get ref component dict dict_ref_component = dict_components[ref_name] # add path_name prefix to each key of dict_ref_component for key in dict_ref_component.keys(): full_name = path_name + key # add full_name and key corresponding value to dict_results dict_results[full_name] = dict_ref_component[key] # save all components of current file self.dict_component[xml_file] = dict_components return dict_results
def test(): get_all_parameters_type() list_values = g_object.dict_parameters_type.values() set_values = set(list_values) res2 = [(value, list_values.count(value)) for value in set_values] log.debug_info(res2)
def dispath_event_to_normal(self, msg_type, msg_priority_level, request): """ 将消息分发到默认的处理队列query_queue或request_queue """ # dispatch try: msg_group = int(msg_type) & 0xFF00 if (msg_group == event.EVENT_QUERY_GROUP or msg_group == event.EVENT_CONFIGURE_GROUP): self.join_query_event_queue(msg_priority_level, request) elif (msg_group == event.EVENT_RPC_GROUP): self.join_request_event_queue(msg_priority_level, request) elif (msg_group == event.EVENT_WORKLIST_GROUP): #特殊处理工单消息,进入agent自己构建的工单执行逻辑模块。reserve->start->execute->finish if msg_type == event.EV_WORKLIST_EXECUTE_RQST: #进入工单预约流程 log.debug_info( "msg_type == event.EV_WORKLIST_RESERVE_RQST") ResponseWLexecHandle.handle_WLreserve_request(request) elif msg_type == event.EV_WORKLIST_EXEC_START_RQST: #进入工单开始流程,这里开始加入RPC队列等待执行。 log.debug_info( "msg_type == event.EV_WORKLIST_EXEC_START_RQST") self.join_request_event_queue(msg_priority_level, request) else: # /******************************************************** #msg_type is: # event.EV_WORKLIST_BUILD_RQST or # event.EV_WORKLIST_BIND_PHISIC_RQST or # event.EV_WORKLIST_BIND_LOGIC_RQST or # event.EV_WORKLIST_RESERVE_RQST or # event.EV_WORKLIST_EXEC_FINISH_RQST # event.EV_WORKLIST_DOWNLOAD_RQST # event.EV_WORKLIST_QUERY_RQST # ********************************************************* self.join_query_event_queue(msg_priority_level, request) else: err_info = "DUTQueue dispath_event_to_normal: user message group(=%d) not support." % msg_group log.debug_err(err_info) message = request[0] conn = request[1] ResponseClientHandle.handle_except(message, conn, err_info) except Exception, e: err_info = "DUTQueue dispath_event_to_normal function occurs exception:%s" % e log.debug_err(err_info) message = request[0] conn = request[1] ResponseClientHandle.handle_except(message, conn, err_info)
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() except Exception, e: err_info = "DUTQueueManagement dispath request event occurs exception:%s" % e log.debug_info(err_info) ResponseClientHandle.handle_except(msg, conn, err_info) class AgentHandleRequest(http.Request): """ """ # 定义了路径映射功能 dict_page_handlers = { agentcfg.AGENT_HTTP_SERVER_PATH: handle_dispath_request, } def process(self): """ """ self.setHeader("Content-Type", "text/html")
def parse_parameter_struct(self, element): """ parse parameter struct and object-parameter struct, return dict contain parameters' full name and parameters type element: the parents element of parameter or object """ dict_results = {} # get all children object of element list_children_element = element.getchildren() for children_element in list_children_element: # when children_element is 'parameter' if children_element.tag == 'parameter': dict_para_attrib = children_element.attrib if "name" in dict_para_attrib: parameter_name = dict_para_attrib['name'] elif "base" in dict_para_attrib: parameter_name = dict_para_attrib['base'] else: log.debug_info( "This parameter have no name or base, unknown definition!" ) # get parameter children object list_para_children = children_element.getchildren() # if parameter have no children, don't need to save it, it have saved in base model if list_para_children == []: continue else: parameter_type = "" for para_children in list_para_children: # if parameter have 'syntax' element if para_children.tag == 'syntax': # get syntax's children list list_syntax_children = para_children.getchildren() # get parameter's type from syntax children element for syntax_children in list_syntax_children: if syntax_children.tag == "list": continue elif syntax_children.tag == "default": continue elif syntax_children.tag == "dataType": # get dataType's 'ref' attribute value data_type_ref = syntax_children.attrib[ 'ref'] # find parameter_type from self.data_type dict parameter_type = self.data_type[ data_type_ref] else: parameter_type = syntax_children.tag # add parameter and its type to dict dict_results[parameter_name] = parameter_type elif children_element.tag == 'object': # get object name from object attribute 'name' or 'base' dict_object_attrib = children_element.attrib if "name" in dict_object_attrib: object_name = dict_object_attrib['name'] elif "base" in dict_object_attrib: object_name = dict_object_attrib['base'] else: log.debug_info( "The object have no name or base, unknown definition!") # get children of 'object' list_children_object = children_element.getchildren() # if object have no parameter sub element, ignore this object if list_children_object == []: continue for children_object in list_children_object: # ignore the others sub element,eg: 'uniqueKey', 'description' # just parse 'parameter' if children_object.tag == 'parameter': # get parameter name from parameter attribute 'name' or 'base' dict_para_attrib = children_object.attrib if "name" in dict_para_attrib: parameter_name = dict_para_attrib['name'] elif "base" in dict_para_attrib: parameter_name = dict_para_attrib['base'] else: log.debug_info( "The parameter have no name or base, unknown definition!" ) # get parameter children object list_para_children = children_object.getchildren() # if parameter have no children, don't need to save it, it have saved in base model if list_para_children == []: continue else: # build parameter's full name full_name = object_name + parameter_name parameter_type = "" for para_children in list_para_children: # if parameter have 'syntax' element if para_children.tag == 'syntax': # get syntax's children list list_syntax_children = para_children.getchildren( ) # get parameter's type from syntax children element for syntax_children in list_syntax_children: if syntax_children.tag == "list": continue elif syntax_children.tag == "default": continue elif syntax_children.tag == "dataType": # get dataType's 'ref' attribute value data_type_ref = syntax_children.attrib[ 'ref'] # find parameter_type from self.data_type dict parameter_type = self.data_type[ data_type_ref] else: parameter_type = syntax_children.tag # add parameter and its type to dict dict_results[full_name] = parameter_type else: pass return dict_results