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)
