def run():
recver = epoll_recever.Epoll_receiver()
_outer_con = ConnectorClient(cfg.CONF.SERVER_IP,cfg.CONF.SERVER_PORT)
_outer_con.connect()
if _outer_con.con_state != CON_STATE.CON_CONNECTED:
logger.error('connect to remote failed')
return
_outer_con.set_blocking(False)
# init inner_worker
_tun_con = TunConnector('yt_tun')
_tun_con.connect()
if _tun_con.con_state != CON_STATE.CON_CONNECTED:
logger.error('tun connector failed')
return
_worker_manager = worker_manager.WorkerManager()
_outer_worker = _worker_manager.set_outer_worker(_outer_con)
_inner_worker = _worker_manager.set_inner_worker(_tun_con)
recver.add_receiver(_outer_con.get_fileno(), select.EPOLLIN, _outer_worker.handler_event)
recver.add_receiver(_tun_con.get_fileno(), select.EPOLLIN, _inner_worker.handler_event)
while True:
try:
_worker_manager.all_worker_do()
recver.run()
except worker_manager.WorkerDoneException,e:
logger.info('Process exit')
return
def main(cfg_file):
cfg = ConfigParser.ConfigParser()
cfg.readfp(open(cfg_file, 'rb'))
log_config(cfg.get('DEFAULT', 'LOG_LEVEL'))
logger.info("Process start!")
outer_ip = cfg.get('DEFAULT', 'SERVER_IP')
outer_port = int(cfg.get('DEFAULT', 'SERVER_PORT'))
out_worker = outer_worker.OuterWorker(outer_ip, outer_port)
recver = epoll_recever.Epoll_receiver()
logger.info("Outer ip:%s:%d" % (outer_ip, outer_port))
__inner_worker_manager = inner_worker_manager.InnerWorkerManager()
while True:
out_worker.do_work(recver, __inner_worker_manager)
__inner_worker_manager.all_do(recver, out_worker.get_connector())
events = recver.run()
for fileno, event in events:
#print 'get event:' + str(fileno)
if fileno == out_worker.get_fileno():
out_worker.handle_event(recver, event)
else:
__inner_worker = __inner_worker_manager.get_worker_by_fileno(
fileno)
if __inner_worker != None:
__inner_worker.handle_event(recver, event,
out_worker.get_connector())
else:
logger.error(
"Can't get fileno:%d inner_worker,unregister it" %
(fileno))
epoll_recever.del_receiver(fileno)
def run():
recver = epoll_recever.Epoll_receiver()
outer_ip = cfg.CONF.SERVER_IP
outer_port = cfg.CONF.SERVER_PORT
logger.info("Outer ip:%s:%d" % (outer_ip, outer_port))
global ID
logger.info(str(ID))
ID = ID +1
_worker_manager = worker_manager.WorkerManager(recver)
_worker_manager.add_outer_worker(outer_ip,outer_port)
while True:
_worker_manager.all_do()
recver.run()
def run():
recver = epoll_recever.Epoll_receiver()
outer_port = cfg.CONF.LISTEN_PORT
outer_acceptor = acceptor.Acceptor('0.0.0.0', outer_port)
logger.info('Outer port listen:' + str(outer_port))
def outer_acceptor_handler_event(event):
_outer_socket, address = outer_acceptor.accept()
_outer_socket.setblocking(0)
_outer_worker = _worker_manager.add_outer_worker(_outer_socket,address)
if not _outer_worker:
logger.error('Create OuterWorker failed ' + ' client_address' + str(address))
return
recver.add_receiver(_outer_socket.fileno(), select.EPOLLIN,_outer_worker.handler_event)
logger.info('outer worker accept fileno:' + str(_outer_socket.fileno()) + 'client_address:' + str(address) +
' tun_ip:' + _outer_worker.get_tun_ip())
# init inner_worker
_tun_con = TunConnector('yt_tun')
_tun_con.connect()
if _tun_con.con_state != CON_STATE.CON_CONNECTED:
logger.error('tun connector failed')
return
recver.add_receiver(outer_acceptor.get_fileno(), select.EPOLLIN, outer_acceptor_handler_event)
_worker_manager = worker_manager.WorkerManager(recver)
_inner_worker = _worker_manager.set_inner_worker(_tun_con)
recver.add_receiver(_tun_con.get_fileno(), select.EPOLLIN,_inner_worker.handler_event)
while True:
try:
_worker_manager.all_worker_do()
recver.run()
except worker_manager.WorkerDoneException,e:
logger.info('Process exit')
return
def run():
recver = epoll_recever.Epoll_receiver()
inner_port = int(cfg.CONF.INNER_PORT)
inner_acceptor = acceptor.Acceptor('0.0.0.0', inner_port)
logger.info('Inner port listen:' + str(inner_port))
out_acceptors = {}
# there are many outer acceptor
def build_outer_acceptors2(new_ports=[], deld_ports=[], changed_ports=[]):
for port in deld_ports + changed_ports:
recver.del_receiver(out_acceptors[port].get_fileno())
out_acceptors[port].close()
out_acceptors.pop(port)
logger.info("Out port deled:" + str(port))
for port in new_ports + changed_ports:
_inner_ip, _inner_port, _inner_tag = _port_mapper.get_inner_info_by_out_port(
port)
_outer_acceptor = acceptor.PortMapperAcceptor(
'0.0.0.0', port, _inner_ip, _inner_port, _inner_tag)
recver.add_receiver(_outer_acceptor.get_fileno(), select.EPOLLIN,
outer_acceptor_handler_event(_outer_acceptor))
out_acceptors[port] = _outer_acceptor
logger.info("Out port listen:" + str(port) + '->' +
str((_inner_ip, _inner_port, _inner_tag)))
def inner_acceptor_handler_event(event):
_inner_socket, address = inner_acceptor.accept()
_inner_socket.setblocking(0)
_inner_worker = _worker_manager.add_inner_worker(
_inner_socket, address)
recver.add_receiver(_inner_socket.fileno(), select.EPOLLIN,
_inner_worker.handler_event)
logger.info('inner worker accept fileno:' +
str(_inner_socket.fileno()))
def outer_acceptor_handler_event(acceptor):
def handler(event):
_outer_socket, address = acceptor.accept()
_outer_socket.setblocking(0)
try:
_outer_worker = _worker_manager.add_outer_worker(
_outer_socket, acceptor.get_listen_port(), address,
acceptor.mapper_ip, acceptor.mapper_port,
acceptor.mapper_tag)
recver.add_receiver(_outer_socket.fileno(), select.EPOLLIN,
_outer_worker.handler_event)
logger.info(
"Outer socket accept, worker_id:%d fileno:%d to inner port:%s:%d"
% (_outer_worker.get_worker_id(), _outer_socket.fileno(),
acceptor.mapper_ip, acceptor.mapper_port))
except Exception, e:
_outer_socket.close()
logger.error(e.message)
logger.debug(traceback.format_exc())
return handler
if len(recv_msg) > 0:
#pass data
self.__ring_buffer.put(bytearray(recv_msg))
#self.__ring_buffer.print_buf()
else:
if self.__connector.con_state != connector.CON_STATE.CON_CONNECTED:
error_happen = True
logger.error(
"OuterWorker current state:WORKING recv data error")
elif event & select.EPOLLHUP:
error_happen = True
if error_happen:
self.__connector.close()
self.__state = self.State.DISCONNECTED
logger.debug(
"OuterWorkercurrent state:WORKING change state to DISCONNECTED"
)
if __name__ == '__main__':
out_worker = OuterWorker('192.168.184.1', 1234)
recver = epoll_recever.Epoll_receiver()
while True:
out_worker.do_work(recver, None)
events = recver.run()
for fileno, event in events:
out_worker.handle_event(event)
def run(cfg):
recver = epoll_recever.Epoll_receiver()
# just one inner acceptor
inner_port = int(cfg.get('DEFAULT', 'INNER_PORT'))
inner_acceptor = acceptor.Acceptor('0.0.0.0', inner_port)
recver.add_receiver(inner_acceptor.get_fileno(), select.EPOLLIN)
logger.info('Inner port listen:' + str(inner_port))
# there are many outer acceptor
_port_mapper = port_mapper.PortMapper(
cfg.get('DEFAULT', 'OUTER_PORTS_FILE'), port_mapper_change_callback)
_worker_manager = worker_manager.WorkerManager()
out_acceptors = {}
build_outer_acceptors(out_acceptors, _port_mapper, recver)
global port_mapper_changed
while True:
_port_mapper.watch_event(10)
if port_mapper_changed:
for acc_fileno, acc in out_acceptors.items():
recver.del_receiver(acc_fileno)
_port_mapper.del_fileno_to_port(acc_fileno)
acc.close()
out_acceptors.clear()
logger.info(
'Port mapper changed,clear current outport listeners,recreating'
)
build_outer_acceptors(out_acceptors, _port_mapper, recver)
port_mapper_changed = False
_worker_manager.all_worker_do()
events = recver.run()
for fileno, event in events:
if fileno == inner_acceptor.get_fileno():
# recv inner connection
_inner_socket, address = inner_acceptor.accept()
_inner_socket.setblocking(0)
_worker_manager.add_inner_worker(_inner_socket)
recver.add_receiver(_inner_socket.fileno(), select.EPOLLIN)
logger.info('Inner socket accept')
elif out_acceptors.has_key(fileno):
# recv outer connection
_outer_socket, address = out_acceptors[fileno].accept()
_outer_socket.setblocking(0)
_inner_ip, _inner_port = _port_mapper.get_inner_info_by_fileno(
fileno)
if not _inner_ip or not _inner_port:
_outer_socket.close()
continue
try:
_outer_worker = _worker_manager.add_outer_worker(
_outer_socket, _inner_ip, _inner_port)
recver.add_receiver(_outer_socket.fileno(), select.EPOLLIN)
logger.info(
"Outer socket accept, worker_id:%d fileno:%d to inner port:%s:%d"
% (_outer_worker.get_worker_id(),
_outer_socket.fileno(), _inner_ip, _inner_port))
except Exception, e:
_outer_socket.close()
continue
else:
_inner_worker = _worker_manager.get_inner_worker_by_fileno(
fileno)
if _inner_worker:
_inner_worker.handle_event(event)
continue
_out_worker = _worker_manager.get_outer_worker_by_fileno(
fileno)
if _out_worker:
_inner_worker = _worker_manager.get_pair_inner_worker(
_out_worker.get_worker_id())
if _inner_worker == None:
logger.error(
"OuterWorker %d get paired InnerWorker failed,remove"
% (_out_worker.get_worker_id()))
_out_worker.close()
_worker_manager.remove_outer_worker(
_out_worker.get_worker_id())
continue
_out_worker.handle_event(event,
_inner_worker.get_connector())
continue