def write_data_to_client(in_conn_handle, in_response_data): """ 通过Client连接句柄发送响应数据到连接客户端 """ global g_tcp_client_count global g_tcp_client_count_lock #写数据 if in_conn_handle: #检查当前系统中有效的连接接句柄总数 log.debug_err("Client connected handle count number=%d" % ClientConnectCount.get_tcp_client_count()) if 0 == ClientConnectCount.get_tcp_client_count(): in_conn_handle = None log.debug_info("write_data_to_client FAIL") return False try: in_conn_handle.send(str(in_response_data)) in_conn_handle.close() log.debug_info("write_data_to_client SUC") return True except Exception, e: err_info = "write_data_to_client occurs expection: %s" % e log.debug_err(err_info) log.debug_info("write_data_to_client FAIL") return False finally:
def _dispath_top_request(): """ 下发消息到处理线程接口 """ try: #获取存在的request处理线程对象总数 temp_request_control_thread_total_count=DispathMethodRequest.get_method_request_control_thread_total_count() #获取空闲的request处理线程对象总数,当有处理线程空闲时,直接下发消息节点 temp_request_control_thread_idle_count=DispathMethodRequest.get_method_request_control_thread_idle_count() #存在空闲的request处理线程对象,直接下发消息节点 if temp_request_control_thread_idle_count>0: log.debug_info("Dispath client request to idle control thread") #获取客户端消息节点缓存队列最前面的消息节点 client_request_node=MethodNodeManagement.\ pop_client_request_node_from_wait_run_buffer_list() if not client_request_node: log.debug_info("BUFLIST: Not exist waiting method request") return False #存在空闲的request处理线程对象,直接下发消息节点到该对象 DispathMethodRequest.dispath_method_request_to_control_thread(client_request_node) return True elif temp_request_control_thread_total_count<OPEN_CONTROL_THREAD_MAX_COUNT: log.debug_info("Create new thread and dispath messages to the object") #获取客户端消息节点缓存队列最前面的消息节点 client_request_node=MethodNodeManagement.\ pop_client_request_node_from_wait_run_buffer_list() if not client_request_node: log.debug_info("BUFLIST: Not exist waiting method request") return False #request线程对象都处于忙状态或者不存在request线程对象,创建新的处理线程节点并直接下发消息节点到该对象 DispathMethodRequest.dispath_method_request_to_control_thread(client_request_node) return True except Exception, e: err_info = "Dispath client request to idle control thread occurs expection: %s" % e log.debug_err(err_info) #返回错误消息 in_conn_handle=client_request_node.get_client_conn_handle() ClientResponseHandle.send_error_info_data_to_client(in_conn_handle,err_info)
def start_service(): """ 启动服务器模块 """ try: StartMethodAgentServer(METHOD_AGENT_SERVER_IP, METHOD_AGENT_SERVER_PORT) except Exception, e: err_info = "iTest agent service occurs expection: %s" % e log.debug_err(err_info)
def StartMethodAgentServer(in_ip, in_port): log.debug_info("Start method agent service...") #启动MethodAgentServer监听来自TCL客户端的消息请求 try: log.debug_info("Method Agent (ip=%s, port=%s) start." % (in_ip, in_port)) ss_obj = MethodAgentServer(in_ip, in_port) ss_obj.start_socket_server() except Exception, e: err_info = "Method agent service occurs expection: %s" % e log.debug_err(err_info)
def start_socket_server(self): """ 启动TCP连接服务器,处理来自TCL客户端发送的连接请求,同时将请求的处理分发给子进程处理。 """ #检查SOCKET连接对象是否存在,如果存在则端口连接,并且重置SOCKET句柄。 if self.sock: self.sock.close() self.sock = None #创建TCP SOCKET 服务器。 try: self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.bind((self.addr, self.port)) self.sock.listen(MAX_LISTEM_CONNECT_NUMBER) except Exception, e: err_info = "Create socket server occurs exception:%s" % e log.debug_err(err_info) return
def send_response_data_to_client(in_conn_handle, in_response_data): """ 给Client回响应数据已更新消息处理状态 """ try: #发送响应到当前保存Client句柄 rc = ClientResponseHandle.write_data_to_client( in_conn_handle, in_response_data) #保存消息处理结果已经消息处理状态 from methodsequencemanagement import MethodSequenceManagement MethodSequenceManagement.finish_method_sequence_obj( in_conn_handle, in_response_data, rc) log.debug_info("send_response_data_to_client SUC") except Exception, e: err_info = "send_response_data_to_client occurs expection: %s" % e log.debug_err(err_info) log.debug_info("send_response_data_to_client FAIL")
def write_keepalive_data_to_client(in_conn_handle, in_response_data): """ 通过Client连接句柄发送心跳响应到连接客户端 """ #写心跳包数据 if in_conn_handle: try: #in_conn_handle.send(str(in_response_data)) log.debug_info("write_keepalive_data_to_client SUC") return True except Exception, e: err_info = "write_keepalive_data_to_client occurs expection: %s" % e log.debug_err(err_info) log.debug_info("write_keepalive_data_to_client FAIL") return False
def handle_message(self, message): """ 处理消息 """ #log.debug_info("Recv total data:%s\n" % message) try: #解析消息体数据 tmp_sequence, \ tmp_method_name, \ tmp_cpe_id, \ tmp_method_parameters_list=ParseRecvData.parse_recv_data(message) except Exception, e: #解析消息体数据异常 err_info = "Parse recv message data occurs expection: %s" % e log.debug_err(err_info) #返回错误消息 ClientResponseHandle.send_error_info_data_to_client( self.conn, err_info) return False
def set_method_request_control_thread_management_property_data(in_thread_handle,in_method_data): """ 更新请求处理method相关数据内容 """ if not in_thread_handle: return False #更新请求处理method相关数据内容 temp_push_data_suc_flag=in_thread_handle.push_request_method_data_to_property(in_method_data) #数据处理对象句柄无效,错误处理 if not temp_push_data_suc_flag: err_info = "Dispath method request to control thread fail. Method control object handle is Invalid." log.debug_err(err_info) #返回错误消息 in_conn_handle=in_method_data.get_client_conn_handle() ClientResponseHandle.send_error_info_data_to_client(in_conn_handle,err_info) return False return True
def test_parse(): try: message = """<?xml version='1.0' encoding='UTF-8'?> <root> <messageid>0123456</messageid> <function>test_method</function> <parameters> <parameter name='data1' type="basictype"> <value type="string">dGVzdGluZzE=</value> </parameter> <parameter name='data2' type="basictype"> <value type="string">dGVzdGluZzI=</value> </parameter> <parameter name='data3' type="list"> <value type="int">124</value> <value type="bool">True</value> <value type="string">dGVzdGluZzE=</value> </parameter> <parameter name='data4' type="dict"> <item> <key>test</key> <value type="string">dGVzdGluZzE=</value> </item> </parameter> </parameters> </root> """ tmp_sequence, \ tmp_method_name, \ tmp_method_parameters_list=ParseRecvData.parse_recv_data(message) log.debug_info( '\n\nmessage_id=%s, method_name=%s, parameters_list=%s' % (tmp_sequence, tmp_method_name, tmp_method_parameters_list)) except Exception, e: log.debug_err('\n\n%s' % e)
def send_error_info_data_to_client(in_conn_handle, in_error_info): """ 构造错误信息并将错误返回给Client """ try: #获取消息message_id from methodsequencemanagement import MethodSequenceManagement in_sequence_id = MethodSequenceManagement.get_method_connect_handle_link_object_sequence_id_property( in_conn_handle) if None == in_sequence_id: in_sequence_id = 0 #构建返回XML数据 from dataprocess import ConstructResponseData out_data = ConstructResponseData.construct_response_data( in_sequence_id, ClientResponseHandle.RESPONSE_STATUS_FAILE, in_error_info) except Exception, e: err_info = "Construct response message data occurs expection: %s" % e log.debug_err(err_info) log.debug_info("send_error_info_data_to_client FAIL") return
def get_message_total_length(self, in_message_head): """ 取消息体有效数据长度 """ message_total_length = 0 split_data_pos = 0 #取消息体有效数据长度 split_pos = in_message_head.find( MESSAGE_TOTAL_LENGTH_DATA_SPLIT_STRING) if split_pos: message_len_str = in_message_head[0:split_pos] try: message_total_length = string.atoi(message_len_str) log.debug_info("Client send message data total length=%d" % message_total_length) except Exception, e: err_info = "get_message_total_length occurs expection: %s" % e log.debug_err(err_info) message_total_length = 0
class MethodAgentServer(object): """ TCP SOCKET服务器,处理来自TCL客户端发送的连接请求,同时将请求的处理分发给子进程处理。 """ def __init__(self, addr='localhost', port=50000): """ 初始化 """ self.addr = addr # listen addr self.port = port # listen port self.sock = None # socket server object def start_socket_server(self): """ 启动TCP连接服务器,处理来自TCL客户端发送的连接请求,同时将请求的处理分发给子进程处理。 """ #检查SOCKET连接对象是否存在,如果存在则端口连接,并且重置SOCKET句柄。 if self.sock: self.sock.close() self.sock = None #创建TCP SOCKET 服务器。 try: self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.bind((self.addr, self.port)) self.sock.listen(MAX_LISTEM_CONNECT_NUMBER) except Exception, e: err_info = "Create socket server occurs exception:%s" % e log.debug_err(err_info) return log.debug_info("Socket server is start!") while 1: log.debug_info("Socket server:wait for client connection...") try: #阻塞等待客户端触发连接请求 connection, address = self.sock.accept() log.debug_info("Socket server:accept client client connection") #更新连接接句柄总数,接收到一个client连接,接接句柄总数加一 ClientConnectCount.updata_tcp_client_count_value(True) log.debug_info("Client connected handle count number=%d" % ClientConnectCount.get_tcp_client_count()) except Exception, e: err_info = "Socket server accept occurs exception: %s" % e log.debug_err(err_info) break #接受一个连接 try: #创建线程处理Client发送的消息数据 thread_i = AcceptClientConnectControlThread( connection, address) thread_i.start() except Exception, e: #启动处理线程异常 err_info = "Start accept client connect control thread occurs exception:%s" % e log.debug_err(err_info) #返回错误消息并继续等待其他客户端的连接 ClientResponseHandle.send_error_info_data_to_client( connection, err_info) continue
def log_out(string): log.debug_err(string)
except Exception, e: #解析消息体数据异常 err_info = "Parse recv message data occurs expection: %s" % e log.debug_err(err_info) #返回错误消息 ClientResponseHandle.send_error_info_data_to_client( self.conn, err_info) return False if None == tmp_sequence or None == tmp_method_name: #解析消息体数据异常 err_info = "Parse recv message data fail" log.debug_err(err_info) #返回错误消息 ClientResponseHandle.send_error_info_data_to_client( self.conn, err_info) return False try: #保存addr,conn数据 tmp_client_addr = self.addr[0] tmp_client_port = self.addr[1] tmp_client_conn_handle = self.conn #创建MethondData数据节点 client_method_node_data_object = MethondData() client_method_node_data_object.set_method_data(
def run(self): """ 接收Client发送的消息数据,并且做初步解析,将消息请求分发到具体的消息处理模块 """ log.debug_info( "\nClient connection request from address=%s,client port=%d" % (self.addr[0], self.addr[1])) data_all = None time_out_try_count = 3 log.debug_info("Begin recv data.") #接收第一个BUG MAX_ONE_RECV_BUF_LENGTH长度的数据 data = self.conn.recv(MAX_ONE_RECV_BUF_LENGTH) log.debug_info("\nRecv data buffer length=%d\n" % len(data)) #从第一个BUG中读取消息的有效数据长度 message_total_length, split_data_pos = self.get_message_total_length( data) if (message_total_length > 0 and split_data_pos < len(data)): #保存接收到的数据 data_all = data[split_data_pos:] #检查是否有更多的数据需要接收 self.conn.settimeout(RECV_TIMEOUT_LENGTH) while 1: #检查消息是否接收完成 if (len(data_all)) >= message_total_length: log.debug_info("Recv data complete.") log.debug_info("Recv total data:%s\n" % data_all) break try: data = self.conn.recv(MAX_ONE_RECV_BUF_LENGTH) # 检查数据长度 if len(data): log.debug_info("\nRecv data buffer length=%d\n" % len(data)) #保存接收到的数据 data_all += data else: continue except socket.timeout, e: if time_out_try_count > 0: time_out_try_count = time_out_try_count - 1 log.debug_info("Reset recv data timeout length") self.conn.settimeout(RECV_TIMEOUT_LENGTH) continue else: log.debug_err("Recv data timeout") break except Exception, e: err_info = "Recv data occurs exception:%s" % e log.debug_err(err_info) break
try: #in_conn_handle.send(str(in_response_data)) log.debug_info("write_keepalive_data_to_client SUC") return True except Exception, e: err_info = "write_keepalive_data_to_client occurs expection: %s" % e log.debug_err(err_info) log.debug_info("write_keepalive_data_to_client FAIL") return False else: log.debug_err( "write_keepalive_data_to_client in_conn_handle is None") return False @staticmethod def write_data_to_client(in_conn_handle, in_response_data): """ 通过Client连接句柄发送响应数据到连接客户端 """ global g_tcp_client_count global g_tcp_client_count_lock #写数据 if in_conn_handle: #检查当前系统中有效的连接接句柄总数 log.debug_err("Client connected handle count number=%d" %
def dispath_method_request_to_control_thread(in_method_data): """ 将method分发到空闲的线程去处理 """ global client_request_control_thread_object_list global client_request_control_thread_object_list_lock try: client_request_control_thread_object_list_lock.acquire() thread_object_count=len(client_request_control_thread_object_list) client_request_control_thread_object_list_lock.release() if 0 == thread_object_count:#len(client_request_control_thread_object_list): log.debug_info("New Method Request Control Thread and start run thread") #创建新的处理线程,并将消息分发到该线程 thread_node=_MethodRequestControlThread() #更新请求处理method相关数据内容 temp_set_data_suc_flag=DispathMethodRequest.set_method_request_control_thread_management_property_data(thread_node,in_method_data) if not temp_set_data_suc_flag: del thread_node return #启动线程,开始处理数据 thread_node.start() #保存有效线程对象句柄到处理线程对象句柄列表 client_request_control_thread_object_list.append(thread_node) else: idle_thread_node_handle=DispathMethodRequest.get_idle_method_request_control_thread_handle() if not idle_thread_node_handle: log.debug_info("New Method Request Control Thread and start run thread") #创建新的处理线程,并将消息分发到该线程 thread_node=_MethodRequestControlThread() #更新请求处理method相关数据内容 temp_set_data_suc_flag=DispathMethodRequest.set_method_request_control_thread_management_property_data(thread_node,in_method_data) if not temp_set_data_suc_flag: del thread_node return #启动线程,开始处理数据 thread_node.start() #保存有效线程对象句柄到处理线程对象句柄列表 client_request_control_thread_object_list.append(thread_node) else: log.debug_info("Push Method Request data to idle thread control module") #将消息分发到刚获取的空闲处理线程 idle_thread_node_handle.push_request_method_data_to_property(in_method_data) except Exception, e: err_info = "Dispath method request to control thread occurs expection: %s" % e log.debug_err(err_info) #返回错误消息 in_conn_handle=in_method_data.get_client_conn_handle() ClientResponseHandle.send_error_info_data_to_client(in_conn_handle,err_info)