class BlockServer():
def __init__(self, mysocket = None, MsgHandler = None):
if mysocket is None:
self.mysocket = MySocket()
else:
self.mysocket = mysocket
self.msg_handler = MsgHandler
def __init__(self, host, port, MsgHandler = None):
self.mysocket = MySocket()
self.host = host
self.port = port
self.msg_handler = MsgHandler
def run_forever(self):
print u'listening on ', self.host,':', self.port
self.mysocket.bind(self.host, self.port)
self.mysocket.listen(1)
while True:
sock, addr = self.mysocket.accept()
if sock is not None:
print 'connected by ', addr
cli = MySocket(sock)
requestHandler = RequestHandle(cli)
requestHandler.Run()
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
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 __init__(self, machine, machine_list):
self.pid = machine
self.pid_list = machine_list
self.ltime = 0
self.reqtime = 0
self.local_queue = []
self.ack_list = {}
self.mysocket = MySocket(self)
self.mysocket.start_server(machine=machine)
def main():
serverList = cf.GetServerList('./serverlist.txt')
print u'找到',len(serverList), u'个服务器地址:'
for addr in serverList:
print addr
print ''
for addr in serverList:
try:
s = MySocket()
s.connect(addr[0], addr[1])
svrSockets.append(s)
except:
print u'Error: 连接', addr, u'失败'
# print 'golbal queue:', g_messageQueues
# print 'global socket list size', len(svrSockets)
# print 'svrsocklist ', svrSockets
network_thread = threading.Thread(target = networkThreadHandler, args = (g_messageQueues, svrSockets))
userInput_thread = threading.Thread(target = userInputThreadHandler, args =(g_messageQueues, svrSockets))
network_thread.start()
userInput_thread.start()
while True:
OnQueueMsg(g_messageQueues['main'].get())
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))
class Node(SockListener):
FILENAME = "out"
def __init__(self, machine, machine_list):
self.pid = machine
self.pid_list = machine_list
self.ltime = 0
self.reqtime = 0
self.local_queue = []
self.ack_list = {}
self.mysocket = MySocket(self)
self.mysocket.start_server(machine=machine)
def check_ack_list(self):
flag = True
for p in self.pid_list:
if p==self.pid:
continue
ack_time = self.ack_list.get(p, -1)
if ack_time<=self.reqtime:
flag = False
return flag
def onReceive(self, data):
ltime, pid, typ = data
ltime = int(ltime)
self.ltime = 1+max(self.ltime, int(ltime))
if typ=='Request':
heapq.heappush(self.local_queue, [str(ltime), pid, "Request"])
self.mysocket.send_message(pid, '%d,%s,%s'%(self.ltime,self.pid,"ACK"), "ACK")
print >>sys.stderr, "\nChanging the local timestamp to %d"%self.ltime
elif typ=='ACK':
self.ack_list[pid] = ltime
if self.check_ack_list()==True:
ltime, p, evt = heapq.heappop(self.local_queue)
if p==self.pid:
print "\n*****Granted resource access to current process(%s)*****"%p
else:
heapq.heappush(self.local_queue, [ltime, p, evt])
print >>sys.stderr, "\nChanging the local timestamp to %d"%self.ltime
elif typ=='Release':
#release the pid accessing critical section which will be on the top
self.ack_list[pid] = ltime
if self.local_queue:
heapq.heappop(self.local_queue)
#check if next pid on the heap is current pid, if it is current pid then grant access
if self.local_queue:
ltime, p, evt = heapq.heappop(self.local_queue)
if p==self.pid and self.check_ack_list()==True:
print "\n*****Granted resource access to current process(%s)*****"%p
else:
heapq.heappush(self.local_queue, [ltime, p, evt])
print >>sys.stderr, "\nLocal timestamp to %d"%self.ltime
sys.stderr.write('\n[PROMPT]Input(rq:Request, rl:Release)# ')
return
def onStandardInput(self, data):
inp = data.strip()
if inp=="rq":
self.request_resource("out")
elif inp=='rl':
self.release_resource("out")
def request_resource(self,filename):
for pid in self.pid_list:
l = [str(self.ltime), self.pid, 'Request']
if pid==self.pid:
self.reqtime = self.ltime
heapq.heappush(self.local_queue, l)
else:
heapq.heappush(self.local_queue, l)
self.mysocket.send_message(pid, ','.join(l), l[2])
self.ltime = self.ltime + 1
print >>sys.stderr, "\nLocal timestamp to %d"%self.ltime
def release_resource(self,filename):
for pid in self.pid_list:
if pid==self.pid:
heapq.heappop(self.local_queue)
else:
self.mysocket.send_message(pid, '%d,%s,%s'%(self.ltime,self.pid,"Release"), "Release")
self.ltime = self.ltime + 1
print >>sys.stderr, "\nLocal timestamp to %d"%self.ltime
self.ack_list.clear()
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)
class Player:
def __init__(self):
self.socket = 0
self.level = 1
self.food = 1260
self.stones = {
"linemate": 0,
"deraumere": 0,
"sibur": 0,
"mendiane": 0,
"phiras": 0,
"thystame": 0
}
self.team_name = ""
self.dir = -1
self.needed_list = []
self.last_move = ""
self.inventory = []
self.following = 0
self.next_dir = []
def connect(self, infos):
self.socket = MySocket(infos["machine"], int(infos["port"]))
return (self.socket.connect())
def init_player(self, infos):
self.team_name = infos["name"]
self.connect(infos)
def preliminaries(self):
self.parse_rcv_msg(None)
self.socket.send_msg(self.team_name)
if self.parse_rcv_msg(None) == "ko":
exit(0)
def Look(self):
self.socket.send_msg("Look")
map = self.parse_rcv_msg("Look")
return (map)
def check_needed_object(self):
self.needed_list = []
for stone in all_stones:
if self.stones[stone] < need_stones[self.level][stone]:
self.needed_list.append(stone)
def make_move(self):
directions = self.next_dir
for direction in directions:
self.socket.send_msg(direction)
msg = self.parse_rcv_msg("Join Player")
while msg != "ok":
msg = self.parse_rcv_msg("Join Player")
self.next_dir = []
def handle_broadcast(self, tab_msg):
for msg in tab_msg:
if (("ready" in msg) and (self.dir != 0)):
tab = msg.split(":")
if (int(tab[1]) == self.level):
if (int(tab[2]) == self.following):
tmp = tab[0].split(" ")[1]
self.dir = int(tmp.split(",")[0])
self.next_dir = dir_tab[self.dir]
if debug:
print("JE SUIS LE JOUEUR AVEC L'ID",
self.following, "Tab =", self.next_dir,
"Dir =", self.dir)
elif (self.following == 0):
self.following = int(tab[2])
tmp = tab[0].split(" ")[1]
self.dir = int(tmp.split(",")[0])
self.next_dir = dir_tab[self.dir]
if debug:
print("JE COMMENCE A SUIVRE", tab[2], "Tab =",
self.next_dir, "Dir =", self.dir)
elif ("start" in msg):
tab = msg.split(":")
if (int(tab[1]) == self.level):
tmp = tab[0].split(" ")[1]
if (int(tab[2]) == self.following and self.dir != 0):
self.dir = -1
self.following = 0
elif (int(tab[2]) == self.following):
self.dir = int(tmp.split(",")[0])
def parse_rcv_msg(self, command):
msg = self.socket.rcv_msg()
tab_msg = msg.split("\n")
broadcast = []
msg_final = ""
for tab in tab_msg:
if (len(tab) == 0):
continue
elif "message" in tab:
broadcast.append(tab)
elif "Current level" in tab:
self.level = self.level + 1
self.dir = -1
msg_final = tab
else:
msg_final = tab
self.handle_broadcast(broadcast)
if (len(msg_final) == 0):
msg_final = self.parse_rcv_msg(command)
elif (command != None
and (("Look" in command) or ("Inventory" in command))
and (msg_final[0] != "[")):
msg_final = self.parse_rcv_msg(command)
return msg_final
def move(self, i):
if debug:
print("Je vais vers une pierre")
average = 0
j = 0
moves = []
for vision in visions:
if (i > vision):
j = j + 1
if (((visions[j] + (visions[j - 1])) % 2) == 1):
average = (visions[j] + (visions[j - 1] + 1)) / 2
else:
average = (visions[j] + (visions[j - 1])) / 2
while j > 0:
moves.append("Forward")
j = j - 1
if (i < average):
moves.append("Left")
while i < average:
moves.append("Forward")
i = i + 1
elif (i > average):
moves.append("Right")
while i > average:
moves.append("Forward")
i = i - 1
self.next_dir = moves
def take_food(self, view):
tabs = view.split(", ")
nb_food = 0
while tabs[0].find("food") != -1 and self.dir == -1:
self.socket.send_msg("Take food")
msg = self.parse_rcv_msg("Join Player")
if msg == "ko" or nb_food > 10:
break
nb_food += 1
def choose_action(self, view):
tabs = view.split(", ")
for need in self.needed_list:
i = 0
for tab in tabs:
if (tab.find(need) != -1 and self.dir == -1):
if (i == 0):
self.socket.send_msg("Take " + need)
self.parse_rcv_msg("Take")
return
else:
self.move(i)
return
i = i + 1
self.move_random()
def check_inventory(self):
self.socket.send_msg("Inventory")
self.inventory = self.parse_rcv_msg("Inventory")
tab = self.inventory.split(", ")
for stone in tab:
stone_name = stone.split(" ")
if ((stone_name[0] != "food") and (stone_name[0] != "[")):
self.stones[stone_name[0]] = int(stone_name[1])
def move_random(self):
if debug:
print("Move random")
rnd = random.Random()
if (self.last_move == "Left"):
move = rnd.choice(["Forward", "Right"])
elif (self.last_move == "Right"):
move = rnd.choice(["Forward", "Left"])
else:
move = rnd.choice(["Forward", "Left", "Right"])
self.last_move = move
self.next_dir = [move]
def drop_inventory(self):
for stone in all_stones:
needed = need_stones[self.level][stone]
while needed > 0:
self.socket.send_msg("Set " + stone)
msg = self.parse_rcv_msg("Set")
if msg == "ok":
needed = needed - 1
else:
break
def take_other_stones(self):
view = self.Look()
tabs = view.split(", ")
for stone in all_stones:
while tabs[0].find(stone) != -1:
self.socket.send_msg("Take " + stone)
if self.parse_rcv_msg("Take") == "ko":
break
def make_incantation(self):
self.following = randint(1000, 10000)
if (self.level >= 2):
while (self.check_nb_player_tile() == 0):
if debug:
print("self.level = ", self.level)
print("(need_stones[self.level][\"player\"] - 1) = ",
(need_stones[self.level]["player"] - 1))
self.socket.send_msg("Broadcast ready for incantation :" +
str(self.level) + ":" +
str(self.following))
self.parse_rcv_msg("Broadcast")
self.socket.send_msg("Broadcast start incantation :" +
str(self.level) + ":" + str(self.following))
self.parse_rcv_msg("Broadcast")
self.take_other_stones()
self.drop_inventory()
self.eject_player()
view = self.Look()
if (self.check_nb_player_tile() == 1):
self.socket.send_msg("Incantation")
msg = self.parse_rcv_msg("Incantation")
msg = self.parse_rcv_msg("Incantation")
self.following = 0
self.dir = -1
def check_nb_player_tile(self):
view = self.Look()
player_tile = view.split(",")[0][1:]
all_objects = player_tile.split(" ")
need_player = need_stones[self.level]["player"]
for obj in all_objects:
if obj == "player":
if (need_player > 0):
need_player -= 1
if (need_player == 0):
return (1)
elif (need_player > 0):
return (0)
def eject_player(self):
view = self.Look()
player_tile = view.split(",")[0][1:]
all_objects = player_tile.split(" ")
need_player = need_stones[self.level]["player"]
for obj in all_objects:
if obj == "player":
if (need_player > 0):
need_player -= 1
else:
self.socket.send_msg("Eject")
msg = self.socket.rcv_msg()
self.socket.send_msg("Forward")
self.parse_rcv_msg("Forward")
return
def wait_incantation(self):
msg = ""
if self.dir == 0:
lvl = self.level
while ((self.level == lvl)):
msg = self.parse_rcv_msg("wait incantation")
if ("ko" in msg):
break
self.dir = -1
self.following = 0
def play(self):
self.preliminaries()
while 1:
if debug:
print(">> play LEVEL =", self.level, "\n\n\n")
self.wait_incantation()
self.check_inventory()
self.check_needed_object()
if ((not self.needed_list) and self.following == 0):
self.make_incantation()
else:
view = self.Look()
self.take_food(view)
if (self.dir == -1):
self.choose_action(view)
if ((len(self.next_dir) != 0)
and (len(self.next_dir[0]) != 0)):
print("Make move : ", self.next_dir)
self.make_move()
def connect(self, infos):
self.socket = MySocket(infos["machine"], int(infos["port"]))
return (self.socket.connect())
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)
#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 __init__(self, host, port, MsgHandler = None): self.mysocket = MySocket() self.host = host self.port = port self.msg_handler = MsgHandler
def __init__(self, mysocket = None, MsgHandler = None):
if mysocket is None:
self.mysocket = MySocket()
else:
self.mysocket = mysocket
self.msg_handler = MsgHandler
class Main(tk.Frame):
def __init__(self, master=None):
super().__init__(master)
self.master = master
self.is_connected = False
self.master.title("Client")
self.master.grid_rowconfigure(0, weight=1)
self.master.grid_columnconfigure(0, weight=1)
self.master.resizable(False, False)
self.grid()
self.socket = None
self.is_running = False
self.subroot = [None] * 6
self.create_widgets()
def create_widgets(self):
self.entry = tk.Entry(self, width=50)
self.entry.grid(row=0, column=0, columnspan=5, padx=10, pady=10)
self.contents = tk.StringVar(self)
self.contents.set("Nhập địa chỉ IP")
self.entry["textvariable"] = self.contents
self.Connect = tk.Button(self, text="Connect", width=10, height=1)
self.Connect.grid(row=0, column=5, sticky=tk.NE, padx=10, pady=10)
self.Connect['command'] = self.connect
self.Screenshot = tk.Button(self,
text="ScreenShot",
height=2,
width=10)
self.Screenshot.grid(row=1, column=0, sticky=tk.NW, padx=10, pady=10)
self.Screenshot["command"] = self.create_screenshot
self.Keystroke = tk.Button(self, text="KeyStroke", width=10, height=2)
self.Keystroke.grid(row=2, column=0, sticky=tk.NW, padx=10, pady=10)
self.Keystroke['command'] = self.create_keystroke
self.Process_Running = tk.Button(self,
text="Process Running",
width=10,
height=10,
wraplength=50)
self.Process_Running.grid(row=1, column=1, rowspan=2, padx=10, pady=10)
self.Process_Running["command"] = self.create_process_running
self.App_Running = tk.Button(self,
text="App Running",
width=10,
height=10,
wraplength=50)
self.App_Running.grid(row=1, column=2, rowspan=2, padx=10, pady=10)
self.App_Running["command"] = self.create_app_running
self.Registry = tk.Button(self, text='Registry', width=10, height=2)
self.Registry.grid(row=1, column=4, padx=10, pady=10, sticky=tk.NE)
self.Registry["command"] = self.create_registry_running
self.master.protocol("WM_DELETE_WINDOW", self.on_exit)
self.Shutdown = tk.Button(self, text="Shut down", width=10, height=2)
self.Shutdown.grid(row=2, column=4, pady=10, padx=10, sticky=tk.NE)
self.Shutdown["command"] = self.create_shutdown
def create_shutdown(self):
if not self.is_connected:
messagebox.showerror("FAIL TO ATTEMPT", "NOT CONNECTED YET")
return
self.socket.client.sendall(bytes("SHUTDOWN", "utf8"))
def create_registry_running(self):
if self.check():
return
if not self.is_connected:
messagebox.showerror("FAIL TO ATTEMPT", "NOT CONNECTED YET")
return
self.socket.client.sendall(bytes("REGISTRY", "utf8"))
registryroot = tk.Toplevel(self.master)
self.subroot[4] = Registry_UI(registryroot, self.socket)
self.subroot[4].mainloop()
def create_app_running(self):
if self.check():
return
if not self.is_connected:
messagebox.showerror("FAIL TO ATTEMPT", "NOT CONNECTED YET")
return
self.socket.client.sendall(bytes("APP", "utf8"))
approot = tk.Toplevel(self.master)
self.subroot[3] = Manager_ui(approot, self.socket, "App")
self.subroot[3].mainloop()
def create_process_running(self):
if self.check():
return
if not self.is_connected:
messagebox.showerror("FAIL TO ATTEMPT", "NOT CONNECTED YET")
return
self.socket.client.sendall(bytes("PROCESS", "utf8"))
processroot = tk.Toplevel(self.master)
self.subroot[2] = Manager_ui(processroot, self.socket, "Process")
self.subroot[2].mainloop()
def create_keystroke(self):
if self.check():
return
if not self.is_connected:
messagebox.showerror("FAIL TO ATTEMPT", "NOT CONNECTED YET")
return
self.socket.client.sendall(bytes("KEYSTROKE", "utf8"))
keystrokeroot = tk.Toplevel(self.master)
self.subroot[0] = keystroke_ui(keystrokeroot, self.socket)
self.subroot[0].mainloop()
def create_screenshot(self):
if self.check():
return
if not self.is_connected:
messagebox.showerror("FAIL TO ATTEMPT", "NOT CONNECTED YET")
return
self.socket.client.sendall(bytes("SCRSHOT", "utf8"))
screenshotroot = tk.Toplevel(self.master)
self.subroot[1] = scrshot_ui(screenshotroot, self.socket)
self.subroot[1].mainloop()
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 on_exit(self):
if self.check():
return
if self.socket is None:
self.master.destroy()
return
try:
self.socket.client.sendall(bytes("exit", "utf8"))
except:
dem = 1
self.socket.close()
self.master.destroy()
def check(self):
for i in range(6):
if self.subroot[i] is not None and self.subroot[i].winfo_exists():
return True
return 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
