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
