def handle(self, sock, addr):
logging.debug(u'connection from %s:%s' % addr)
# 调用各个 handler 尝试生成 client
# 检查结果，如果生成了就表示本次客户端请求的是这个协议。
# 剩下的就交由这个协议处理。
_handler = None
_reset_peek_offset = False
mysocket = MySocket(sock)
for Handler in handler.get_handler():
mysocket.reset_peek_offset()
(_handler, _reset_peek_offset) = Handler.create(mysocket, self)
if _handler is not None:
break
if _handler is None:
mysocket.close(safe=False)
logging.warn(u'[Handler]收到未识别的协议，关闭连接。')
return
try:
if _reset_peek_offset:
mysocket.reset_peek_offset()
mysocket.set_peek(False)
# handler 有可能是异步调用
_handler.handler()
except:
logging.exception(u'client.handle()')
mysocket.close(safe=False)
def connect(self):
strings = self.entry.get()
if (self.is_connected):
messagebox.showwarning("FAIL TO ATTEMPT", "Already Connected")
return
#print(strings)
try:
self.socket = MySocket((strings, PORT))
messagebox.showinfo("SUCCESS", "Connected")
self.is_connected = True
except:
messagebox.showerror("ERROR", "Can not connect")
def inicializarServidor():
# Programa comienza aquí.
# ref: https://docs.python.org/3/howto/sockets.html
# Se define el socket del servidor.
print("Creando socket")
socket_servidor = MySocket()
socket_servidor.bind(hostname='localhost',port=8081)
socket_servidor.listen(number_connections=5)
print("Socket creado, asociado al hostname '{}', puerto '{}' y número de conexiones '{}'".format('localhost',8081,5))
while True:
# Apenas se establece una conexión, se maneja apropiadamente.
(socket_cliente, address) = socket_servidor.accept()
# El socket obtenido en socket_cliente establece la conexión punto a punto
# con el estacionamiento que va a enviarnos la información. Es una instancia
# de socket.py
# Recibir e imprimir lo que obtenemos del socket.
print("Dirección IP: {}".format(address))
# mensaje = socket_cliente.myreceive()
mensaje_dict = socket_cliente.receive()
print("Mensaje: {}".format(mensaje_dict))
def connect(self, infos):
self.socket = MySocket(infos["machine"], int(infos["port"]))
return (self.socket.connect())
#0000 acceso no restringido
#pdb.set_trace()
# Funciones
def leer_placa():
placa = input("Placa: ")
return placa
def leer_ticket():
ticket = input("ticket: ")
resgistrado = input("registrado(True,False): ")
return ticket, resgistrado
# Programa comienza aquí.
# ref: https://docs.python.org/3/howto/sockets.html
# Crear un socket como cliente.
print("Creando socket")
socket_cliente = MySocket()
socket_cliente.connect(host=HOST, port=PORT)
print("Socket conectado.")
# Enviar primer mensaje:
# Estructura del primer mensaje:
# * RIF: lleno
# * ticket: None.
# * placa: llena.
# * tipo: llena ('placa_leida')
# * puerta: llena.
# * lectura_automatica: llena, sus posibles valores son:
# True: lectura realizada de forma automática
# False: lentura realizada de forma manual
# None: No aplica la información (ejemplo, mensajes servidor-cliente)
# * registrado: llena, true o false
def handler(self):
# 开启 socket peek 功能。
msock = MySocket(self.sock, True)
# 解析 http 协议头
request = httptool.HttpRequest(self.msock)
request.parse_head()
upgrade = request.headers.get('Upgrade').lower()
if upgrade == "websocket":
# websocket 协议
# TODO: 这里不处理，收到服务器升级成功的回复后在处理
request.del_conntype(retain=['Upgrade'])
elif upgrade is not None:
# 存在未知的升级协议
if self.porxy is False and self.remote_host and self.remote_port:
# 非代理模式，对未知的协议直接转发。
msock.reset_peek_offset()
msock.set_peek(False)
# 对外发起请求
try:
remote_sock = self.server.upstream.create_connection(
(self.remote_host, self.remote_port), )
except:
logging.exception(u'连接 tcp host:%s port:%s 失败。' %
(self.remote_host, self.remote_port))
self.msock.close()
return
self.forward(self.sock, remote_sock, 5 * 60)
return
else:
# 代理模式，删除各种未知的协议
request.del_conntype(retain=[])
del request.headers['Upgrade']
try:
remote_sock = self.server.upstream.get_http_conn(
request.get_http_host_address())
except:
logging.exception(u'所有线路连接 tcp host:%s port:%s 失败。' %
(self.remote_host, self.remote_port))
self.msock.close()
return
remote_sock.sendall(request.get_head_string())
#TODO: 另开一个线程接受回应。
#TODO: 这里就要开始接受回应，有可能客户端在等待 100-continue 回应。
body = request.get_body()
while True:
data = body.recv(2**16)
if data:
remote_sock.sendall(data)
else:
break
# 大概做法，接收请求，建立新连接并发出请求，然后将回应丢到回应队列里面去
# 回应队列限制长度，如果满了就阻塞添加到队列操作。
# 需要注意，碰到post请求就需要另开一个新连接，不要使用线程池里面的。
# 同时需要等待之前的请求完结之后在处理post请求。
raise NotImplementedError(u'未完成')
remote_sock
