def client_accept(client_handle_socket, app_name):
try:
while True:
private_socket = None
(client_socket, client_address) = client_handle_socket.accept()
logging.info(str(client_address) + ' Connected')
logging.debug('accept client: ' + str(client_address))
c_address = json.loads(json.dumps(client_address))
client_address_element = {'client_address': c_address, 'client_socket': client_socket}
CLIENT_ADDRESS_TABLE.append(client_address_element)
# private_socket_element = {'app_name': app_name, 'private_socket': private_socket}
# PRIVATE_SOCKET_TABLE.append(private_socket_element)
for element in PRIVATE_SOCKET_TABLE:
logging.debug(element)
if app_name == element['app_name']:
private_socket = element['private_socket']
build_connect_packet = json.dumps(packet.packet(op_enum.OP_BUILD_CONNECTION, op_enum.DES_BUILD_CONNECTION, '', app_name, client_address))
if private_socket != None:
core_transmit.send_operation(private_socket, build_connect_packet)
client_to_private_thread = Thread(target=client_to_private, args=(client_socket, client_address, private_socket, app_name), daemon=False, name=app_name + str(client_address))
client_to_private_thread.start()
except Exception as err:
logging.debug(err)
client_handle_socket.shutdown(socket.SHUT_RDWR)
client_handle_socket.close()
def register_app(app_name=None,
app_address=None,
app_port=None,
public_server_port=None):
if app_name == None or app_address == None or app_port == None or public_server_port == None:
return 'url must be \"/register_app/<app_name>/<app_address>/<app_port>/<public_server_port>\"'
for app in REGISTERED_APPS:
if app_name == app['app_name']:
return 'This app name has been registered.'
if app_address == app['app_address'] and app_port == app['app_port']:
return 'This port has been registered.'
register_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
register_socket.connect((PUBLIC_SERVER_ADDRESS, OP_PORT))
register_operation = packet.packet(op_enum.OP_REGISTER_APP,
op_enum.DES_REGISTER_APP,
str(public_server_port), app_name, None)
core_transmit.send_operation(register_socket,
json.dumps(register_operation))
public_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
public_socket.connect((PUBLIC_SERVER_ADDRESS, PROXY_PORT))
public_socket_element = {
'public_socket': public_socket,
'app_name': app_name
}
PUBLIC_SOCKET_TABLE.append(public_socket_element)
app_get_op_thread = Thread(target=get_operation,
args=(public_socket, ),
daemon=False,
name='get_operation:' + str(app_name))
app_get_op_thread.start()
register_app = {}
register_app['app_name'] = app_name
register_app['app_address'] = app_address
register_app['app_port'] = app_port
register_app['public_port'] = public_server_port
register_app['public_socket'] = public_socket
waiting_register_app = {
'register_app_name': register_app['app_name'],
'status': None,
'msg': ''
}
REGISTER_IN_WAIT.append(waiting_register_app)
waitcount = 200
while waiting_register_app['status'] == None:
time.sleep(0.1)
waitcount -= 1
if waitcount < 0:
waiting_register_app['status'] = False
waiting_register_app['msg'] = 'time out'
# logging.debug('waiting for register')
logging.debug(waiting_register_app)
if waiting_register_app['status'] == True:
REGISTER_IN_WAIT.remove(waiting_register_app)
elif waiting_register_app['status'] == False:
REGISTER_IN_WAIT.remove(waiting_register_app)
return 'Register failed because of \"' + waiting_register_app[
'msg'] + '\"'
REGISTERED_APPS.append(register_app)
return 'Register success'
def unregister_app(app_name=None):
if app_name == None:
return 'url must be \"unregister_app/<app_name>\"'
for app in REGISTERED_APPS:
if app_name == app['app_name']:
public_socket = app['public_socket']
public_socket_address = public_socket.getsockname()
unregister_op = json.dumps(
packet.packet(op_enum.OP_UNREGISTER_APP,
op_enum.DES_UNREGISTER_APP,
str(public_socket_address), app_name, None))
core_transmit.send_operation(public_socket, unregister_op)
REGISTERED_APPS.remove(app)
return 'Unregister success'
return 'There is no app named \"' + app_name + '\"'
def private_to_public(private_app_socket, client_address, app_name):
try:
public_socket = None
for element in PUBLIC_SOCKET_TABLE:
if app_name == element['app_name']:
public_socket = element['public_socket']
while True:
msg = core_transmit.get_data(private_app_socket)
if msg == '':
logging.debug(
'DETECT \'\'!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')
logging.debug(
'DETECT \'\'!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')
logging.debug(
'DETECT \'\'!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')
logging.debug(
'DETECT \'\'!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')
logging.debug(
'DETECT \'\'!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')
logging.debug(
'DETECT \'\'!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')
logging.debug(
'DETECT \'\'!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')
logging.debug(
'DETECT \'\'!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')
break
# After receive data
data_packet = packet.packet(op_enum.OP_TRANSMIT_DATA,
op_enum.DES_TRANSMIT_DATA, msg,
app_name, client_address)
data_packet_json = json.dumps(data_packet)
logging.debug('generate: ' + str(data_packet_json))
core_transmit.send_operation(public_socket, data_packet_json)
except Exception as err:
logging.debug(err)
finally:
private_app_socket.shutdown(socket.SHUT_RDWR)
private_app_socket.close()
disconn_packet = packet.packet(op_enum.OP_DISCONNECTED,
op_enum.DES_DISCONNECTED, '', app_name,
client_address)
disconn_json = json.dumps(disconn_packet)
logging.debug('generate: ' + str(disconn_json))
core_transmit.send_operation(public_socket, disconn_json)
for element in PRIVATE_SOCKET_TABLE:
if client_address == element['client_address']:
PRIVATE_SOCKET_TABLE.remove(element)
def client_to_private(c_sock, c_address, pri_sock, app_name):
try:
while True:
msg = core_transmit.get_data(c_sock)
if msg == '':
break
# After receive data
data_packet = packet.packet(op_enum.OP_TRANSMIT_DATA, op_enum.DES_TRANSMIT_DATA, msg, app_name, c_address)
data_packet_json = json.dumps(data_packet)
logging.debug('generate: ' + str(data_packet_json))
core_transmit.send_operation(pri_sock, data_packet_json)
except Exception as err:
logging.debug(err)
finally:
logging.info('Client disconnected')
c_sock.shutdown(socket.SHUT_RDWR)
c_sock.close()
disconn_packet = packet.packet(op_enum.OP_DISCONNECTED, op_enum.DES_DISCONNECTED, '', app_name, c_address)
disconn_json = json.dumps(disconn_packet)
logging.debug('generate: ' + str(disconn_json))
core_transmit.send_operation(pri_sock, disconn_json)
for element in CLIENT_ADDRESS_TABLE:
if c_address == element['client_address']:
CLIENT_ADDRESS_TABLE.remove(element)
def register_app(app_name=None, bind_port=None):
app_name_failed_op = None
if app_name in BIND_APP:
app_name_failed_op = json.dumps(packet.packet(op_enum.OP_REGISTER_FAILED, op_enum.DES_REGISTER_FAILED, 'APP \"' + app_name + '\" has already exist', app_name, None))
if app_name_failed_op == None:
BIND_APP[app_name] = bind_port
try:
(private_socket, private_address) = PROXY_SOCKET.accept()
logging.debug('accept address: ' + str(private_address))
private_socket_element = {'app_name': app_name, 'private_socket': private_socket}
PRIVATE_SOCKET_TABLE.append(private_socket_element)
get_op_thread = Thread(target=get_operation, args=(private_socket,), daemon=False, name='get_operation: ' + app_name)
get_op_thread.start()
if app_name_failed_op != None:
core_transmit.send_operation(private_socket, app_name_failed_op)
private_socket.shutdown(socket.SHUT_RDWR)
private_socket.close()
# If register failed, do not start client_handle_socket
client_handle_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_handle_socket.bind((PROXY_ADDRESS, bind_port))
client_handle_socket.listen(20)
client_handle_element = {'app_name': app_name, 'client_handle_socket': client_handle_socket}
CLIENT_HANDLE_TABLE.append(client_handle_element)
logging.debug(BIND_APP)
logging.debug(PRIVATE_SOCKET_TABLE)
client_accept_thread = Thread(target=client_accept, args=(client_handle_socket, app_name, ), daemon=False, name='client_accept_thread: ' + app_name)
client_accept_thread.start()
success_op = json.dumps(packet.packet(op_enum.OP_REGISTER_SUCCESS, op_enum.DES_REGISTER_SUCCESS, 'APP \"' + app_name + '\" created', app_name, None))
core_transmit.send_operation(private_socket, success_op)
except Exception as err:
failed_op = json.dumps(packet.packet(op_enum.OP_REGISTER_FAILED, op_enum.DES_REGISTER_FAILED, str(err), app_name, None))
core_transmit.send_operation(private_socket, failed_op)
del BIND_APP[app_name]
private_socket.shutdown(socket.SHUT_RDWR)
private_socket.close()
client_handle_socket.close()
def handle_operation():
while True:
operation = OP_QUEUE.get()
omatted_json = json.dumps(json.loads(operation), indent=4)
logging.debug(omatted_json)
operation_packet = json.loads(operation)
op_code = operation_packet['op_code']
op_describe = operation_packet['op_describe']
msg = operation_packet['msg']
app_name = operation_packet['app_name']
client_address = operation_packet['client_address']
private_socket = None
public_socket = None
for public_socket_element in PUBLIC_SOCKET_TABLE:
if app_name == public_socket_element['app_name']:
public_socket = public_socket_element['public_socket']
'''
proceduce operation
'''
if op_code == op_enum.OP_BUILD_CONNECTION:
tmp_private_socket = socket.socket(socket.AF_INET,
socket.SOCK_STREAM)
for app in REGISTERED_APPS:
if app_name == app['app_name']:
app_address = app['app_address']
app_port = app['app_port']
if app_name == None or app_port == None:
response = json.dumps(
packet.packet(op_enum.OP_FAILED, op_enum.DES_FAILED,
'No such app', app_name, client_address))
logging.debug(response)
core_transmit.send_operation(public_socket, response)
try:
tmp_private_socket.connect((app_address, app_port))
except Exception as err:
failed_op = json.dumps(
packet.packet(op_enum.OP_BUILD_CONNECTION_FAILED,
op_enum.DES_BUILD_CONNECTION_FAILED,
str(err), app_name, client_address))
core_transmit.send_operation(public_socket, failed_op)
unregister_app(app_name)
continue
private_socket_element = {
'client_address': client_address,
'private_socket': tmp_private_socket
}
PRIVATE_SOCKET_TABLE.append(private_socket_element)
private_to_public_thread = Thread(
target=private_to_public,
args=(tmp_private_socket, client_address, app_name),
daemon=False,
name='private_to_public:' + str(client_address))
private_to_public_thread.start()
elif op_code == op_enum.OP_SUCCESS:
logging.debug(
packet.packet(op_code, op_describe, msg, app_name,
client_address))
elif op_code == op_enum.OP_TRANSMIT_DATA:
for element in PRIVATE_SOCKET_TABLE:
if client_address == element['client_address']:
private_socket = element['private_socket']
if private_socket != None:
core_transmit.send_data(private_socket, msg)
# if client disconnected, close private socket of this client
elif op_code == op_enum.OP_DISCONNECTED:
logging.debug(str(op_describe) + ':' + str(client_address))
for element in PRIVATE_SOCKET_TABLE:
if client_address == element['client_address']:
private_socket = element['private_socket']
private_socket.shutdown(socket.SHUT_RDWR)
private_socket.close()
for element in PRIVATE_SOCKET_TABLE:
if client_address == element['client_address']:
PRIVATE_SOCKET_TABLE.remove(element)
elif op_code == op_enum.OP_REGISTER_SUCCESS:
for in_wait in REGISTER_IN_WAIT:
if app_name == in_wait['register_app_name']:
in_wait['status'] = True
elif op_code == op_enum.OP_REGISTER_FAILED:
for in_wait in REGISTER_IN_WAIT:
if app_name == in_wait['register_app_name']:
in_wait['status'] = False
in_wait['msg'] = msg