def __dispatch_data(self, data, allow2other):
ip_packages = IPProtocolHandler.parse_ip_package(data)
ip_msg_map = {}
for package in ip_packages:
if package[0] == self.__tun_ip:
send_bytes = self.__tun_connector.send(package[1])
if send_bytes <= 0:
logger.error(
"InnerWorker %d trans bytes <=0 change state to CLOSED",
self.__id)
self.__state = self.State.CLOSED
return
else:
if not ip_msg_map.has_key(package[0]):
ip_msg_map[package[0]] = package[1]
else:
ip_msg_map[package[0]] += package[1]
if not allow2other:
return
for ip, data in ip_msg_map.items():
trans_data = forward_data.ForwardData(
forward_data.DATA_TYPE.TRANS_DATA, 0, ip, data)
trans_data_event = forward_event.TransDataEvent(ip, trans_data)
self.__north_interface_channel(trans_data_event)
def __recv_data(self, event):
error_happen = False
if event.fd_event & select.EPOLLIN:
recv_msg = self._connector.recv()
if len(recv_msg) > 0:
# trans data
# print 'recv outer %d msg:'%(self._worker_id)
# tools.print_hex_buf(recv_msg)
try:
trans_data = forward_data.ForwardData(
forward_data.DATA_TYPE.TRANS_DATA, self._worker_id,
self.__inner_ip, self.__inner_port, recv_msg)
trans_data_event = forward_event.TransDataEvent(
self._worker_id, trans_data)
self.__sourth_interface_channel(trans_data_event)
self._recv_flow_static.add_flow(len(recv_msg))
except Exception, e:
error_happen = True
logger.error(
"OuterWorker %d current state:WORKING send data error"
% (self._worker_id))
logger.debug(traceback.format_exc())
else:
if self._connector.con_state != connector.CON_STATE.CON_CONNECTED:
error_happen = True
logger.error(
"OuterWorker %d current state:WORKING recv data error" %
(self._worker_id))
def __handle_data(self):
datas = self.__data_handler.get_forward_datas(self.__ring_buffer)
for data in datas:
if data.data_type in (forward_data.DATA_TYPE.CONNECTION_SUCCESS,
forward_data.DATA_TYPE.TRANS_DATA):
trans_event = forward_event.TransDataEvent(data.id, data)
self.__north_interface_channel(trans_event)
elif data.data_type == forward_data.DATA_TYPE.CLOSE_CONNECTION:
close_event = forward_event.CloseConEvent(data.id)
self.__north_interface_channel(close_event)
elif data.data_type == forward_data.DATA_TYPE.HEART_BEAT:
self.send_heart_beat_reply()
logger.info("InnerWorker %d send heartbeat reply " %
(self._worker_id))
def __handle_data(self):
datas = self.__data_handler.get_forward_datas(self.__ring_buffer)
for data in datas:
if data.data_type in (forward_data.DATA_TYPE.NEW_CONNECTION,
forward_data.DATA_TYPE.TRANS_DATA):
trans_event = forward_event.TransDataEvent(data.id, data)
self.__sourth_interface_channel(trans_event)
elif data.data_type == forward_data.DATA_TYPE.PRE_WORKING:
self.__data_handler.send_preworking_reply(self.__connector)
elif data.data_type == forward_data.DATA_TYPE.CLOSE_CONNECTION:
close_event = forward_event.CloseConEvent(data.id)
self.__sourth_interface_channel(close_event)
elif data.data_type == forward_data.DATA_TYPE.HEART_BEAT:
logger.debug('OuterWorker recv heartbeat reply')
self.__last_hear_beat_reply_time = time.time()
def __handle_data(self):
datas = self.__data_handler.get_forward_datas(self.__ring_buffer)
if len(datas) <= 0:
return
if self.__state == self.State.LOGIN:
for data in datas:
if data.data_type == forward_data.DATA_TYPE.LOGIN_PUBKEY:
pubkey_data = json.loads(str(data.data))
pubkey = pubkey_data['public_key']
user_info = {
'user_name': cfg.CONF.USER_NAME,
'password': cfg.CONF.PASSWORD
}
encode_event = forward_event.RSAEvent(
forward_event.RSAEvent.Rsa_type.ENCODE,
(pubkey, json.dumps(user_info)))
encode_info = self.__sourth_interface_channel(encode_event)
self.__data_handler.login_to_server(
encode_info, self.__connector)
elif data.data_type == forward_data.DATA_TYPE.LOGIN_SUCCESS:
self.__worker_id = data.id
ip_info = json.loads(str(data.data))
allocate_ip_event = forward_event.AllocateIPEvent(
ip_info['tun_ip'])
self.__sourth_interface_channel(allocate_ip_event)
self.__state = self.State.WORKING
logger.info(
'OuterWorker change state from LOGIN to WORKING')
elif data.data_type == forward_data.DATA_TYPE.LOGIN_FAILED:
logger.error(
'OuterWorker login to server failed,change state to CLOSED'
)
self.__state = self.State.CLOSED
elif self.__state == self.State.WORKING:
for data in datas:
if data.data_type == forward_data.DATA_TYPE.TRANS_DATA:
trans_event = forward_event.TransDataEvent(data.id, data)
self.__sourth_interface_channel(trans_event)
elif data.data_type == forward_data.DATA_TYPE.HEART_BEAT:
logger.debug('OuterWorker recv heartbeat reply')
def __handle_working_event(self, event):
error_happen = False
if event.fd_event & select.EPOLLIN:
recv_msg = self.__connector.recv()
if len(recv_msg) > 0:
# trans data
try:
trans_data = forward_data.ForwardData(forward_data.DATA_TYPE.TRANS_DATA, self.__id,
self.__inner_ip, self.__inner_port, bytearray(recv_msg))
trans_data_event = forward_event.TransDataEvent(self.__id, trans_data)
self.__north_interface_channel(trans_data_event)
except Exception, e:
error_happen = True
logger.error("InnerWorker %d current state:WORKING send data error" % (self.__id))
logger.debug(traceback.format_exc())
else:
if self.__connector.con_state != connector.CON_STATE.CON_CONNECTED:
error_happen = True
logger.error("InnerWorker %d current state:WORKING recv data error" % (self.__id))
def __handle_working_event(self, event):
error_happen = False
if event.fd_event & select.EPOLLIN:
recv_msg = self.__tun_connector.recv()
if len(recv_msg) > 0:
# trans data
try:
# ip_packages = IPProtocolHandler.parse_ip_package(bytearray(recv_msg))
# ip_msg_map = {}
# for package in ip_packages:
#
# if not ip_msg_map.has_key(package[0]):
# ip_msg_map[package[0]] = package[1]
# else:
# ip_msg_map[package[0]] += package[1]
#
# for ip,data in ip_msg_map.items():
# trans_data = forward_data.ForwardData(forward_data.DATA_TYPE.TRANS_DATA, 0,ip,data)
# trans_data_event = forward_event.TransDataEvent(ip, trans_data)
# self.__north_interface_channel(trans_data_event)
trans_data = forward_data.ForwardData(
forward_data.DATA_TYPE.TRANS_DATA, 0, '',
bytearray(recv_msg))
trans_data_event = forward_event.TransDataEvent(
'', trans_data)
self.__north_interface_channel(trans_data_event)
except Exception, e:
error_happen = True
logger.error(
"InnerWorker current state:WORKING send data error")
logger.debug(traceback.format_exc())
else:
if self.__tun_connector.con_state != CON_STATE.CON_CONNECTED:
error_happen = True
logger.error(
"InnerWorker current state:WORKING recv data error")
self.__connector)
self.__state = self.State.WORKING
logger.info(
'OuterWorker %d login success,change state to WORKING'
% (self.__worker_id))
else:
self.__data_handler.send_login_reply(
False, self.__worker_id, '', self.__connector)
self.__state = self.State.CLOSED
logger.info(
'OuterWorker %d login failed,change state to CLOSED'
% (self.__worker_id))
elif self.__state == self.State.WORKING:
for data in datas:
if data.data_type == forward_data.DATA_TYPE.TRANS_DATA:
trans_event = forward_event.TransDataEvent(data.id, data)
self.__sourth_interface_channel(trans_event)
elif data.data_type == forward_data.DATA_TYPE.HEART_BEAT:
self.send_heart_beat_reply()
logger.debug("OuterWorker %d send heartbeat reply " %
(self.__worker_id))
def __scheduler_event(self, event):
if not isinstance(event, forward_event.SchedulerEvent):
return
if self.__state == self.State.NONE:
self.__state = self.State.LOGIN
self.__login_begin_time = time.time()
#self.__state = self.State.WORKING
elif self.__state == self.State.LOGIN:
def create_connection(self,forward_id,inner_ip,inner_port,sourth_interface):
forw_data = forward_data.ForwardData(forward_data.DATA_TYPE.NEW_CONNECTION, forward_id,
inner_ip, inner_port, '')
forw_event = forward_event.TransDataEvent(forward_id,forw_data)
sourth_interface(forw_event)
def __connecte_success(self):
connected_data = forward_data.ForwardData(forward_data.DATA_TYPE.CONNECTION_SUCCESS, self.__id,
self.__inner_ip, self.__inner_port, '')
connected_event = forward_event.TransDataEvent(self.__id, connected_data)
self.__north_interface_channel(connected_event)
self.__connector_change_callback(self.__connector, self.handler_event)