crabapples
/
websockify
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #110 from astrand/rename-self-client 

Rename self.client and new_client - prepare for #72 / #111
This commit is contained in:
astrand 2013-12-16 05:45:03 -08:00
parent 34a1b68d79 047ce47742
commit 17455afe4d
8 changed files with 29 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
other/websocket.rb
View File

@ -98,7 +98,7 @@ Sec-WebSocket-Accept: %s\r
begin
t[:client] = do_handshake(io)
new_client(t[:client])
new_websocket_client(t[:client])
rescue EClose => e
msg "Client closed: #{e.message}"
return

2
other/websockify.rb
View File

@ -39,7 +39,7 @@ Traffic Legend:
end
# Echo back whatever is received
def new_client(client)
def new_websocket_client(client)
msg "connecting to: %s:%s" % [@target_host, @target_port]
tsock = TCPSocket.open(@target_host, @target_port)

10
tests/echo.py
View File

@ -20,7 +20,7 @@ class WebSocketEcho(WebSocketServer):
client. """
buffer_size = 8096
def new_client(self):
def new_websocket_client(self):
"""
Echo back whatever is received.
"""
@ -28,21 +28,21 @@ class WebSocketEcho(WebSocketServer):
cqueue = []
c_pend = 0
cpartial = ""
rlist = [self.client]
rlist = [self.request]
while True:
wlist = []
if cqueue or c_pend: wlist.append(self.client)
if cqueue or c_pend: wlist.append(self.request)
ins, outs, excepts = select.select(rlist, wlist, [], 1)
if excepts: raise Exception("Socket exception")
if self.client in outs:
if self.request in outs:
# Send queued target data to the client
c_pend = self.send_frames(cqueue)
cqueue = []
if self.client in ins:
if self.request in ins:
# Receive client data, decode it, and send it back
frames, closed = self.recv_frames()
cqueue.extend(frames)

2
tests/echo.rb
View File

@ -12,7 +12,7 @@ require 'websocket'
class WebSocketEcho < WebSocketServer
# Echo back whatever is received
def new_client(client)
def new_websocket_client(client)
cqueue = []
c_pend = 0

4
tests/load.py
View File

@ -29,12 +29,12 @@ class WebSocketLoad(WebSocketServer):
WebSocketServer.__init__(self, *args, **kwargs)
def new_client(self):
def new_websocket_client(self):
self.send_cnt = 0
self.recv_cnt = 0
try:
self.responder(self.client)
self.responder(self.request)
except:
print "accumulated errors:", self.errors
self.errors = 0

2
tests/test_websocketproxy.py
View File

@ -124,4 +124,4 @@ class WebSocketProxyTest(unittest.TestCase):
return ins, outs, excepts
self.stubs.Set(select, 'select', mock_select)
self.assertRaises(Exception, web_socket_proxy.new_client)
self.assertRaises(Exception, web_socket_proxy.new_websocket_client)

26
websockify/websocket.py
View File

@ -68,7 +68,7 @@ if multiprocessing and sys.platform == 'win32':
class WebSocketServer(object):
"""
WebSockets server class.
Must be sub-classed with new_client method definition.
Must be sub-classed with new_websocket_client method definition.
"""
log_prefix = "websocket"
@ -477,7 +477,7 @@ Sec-WebSocket-Accept: %s\r
while self.send_parts:
# Send pending frames
buf = self.send_parts.pop(0)
sent = self.client.send(buf)
sent = self.request.send(buf)
if sent == len(buf):
self.print_traffic("<")
@ -499,7 +499,7 @@ Sec-WebSocket-Accept: %s\r
bufs = []
tdelta = int(time.time()*1000) - self.start_time
buf = self.client.recv(self.buffer_size)
buf = self.request.recv(self.buffer_size)
if len(buf) == 0:
closed = {'code': 1000, 'reason': "Client closed abruptly"}
return bufs, closed
@ -555,7 +555,7 @@ Sec-WebSocket-Accept: %s\r
msg = pack(">H%ds" % len(reason), code, reason)
buf, h, t = self.encode_hybi(msg, opcode=0x08, base64=False)
self.client.send(buf)
self.request.send(buf)
def do_websocket_handshake(self, headers, path):
h = self.headers = headers
@ -755,7 +755,7 @@ Sec-WebSocket-Accept: %s\r
# handler process
try:
try:
self.client = self.do_handshake(startsock, address)
self.request = self.do_handshake(startsock, address)
if self.record:
# Record raw frame data as JavaScript array
@ -770,11 +770,11 @@ Sec-WebSocket-Accept: %s\r
self.rec.write("var VNC_frame_data = [\n")
self.ws_connection = True
self.new_client()
self.new_websocket_client()
except self.CClose:
# Close the client
_, exc, _ = sys.exc_info()
if self.client:
if self.request:
self.send_close(exc.args[0], exc.args[1])
except self.EClose:
_, exc, _ = sys.exc_info()
@ -792,20 +792,20 @@ Sec-WebSocket-Accept: %s\r
self.rec.write("'EOF'];\n")
self.rec.close()
if self.client and self.client != startsock:
if self.request and self.request != startsock:
# Close the SSL wrapped socket
# Original socket closed by caller
self.client.close()
self.request.close()
def new_client(self):
def new_websocket_client(self):
""" Do something with a WebSockets client connection. """
raise("WebSocketServer.new_client() must be overloaded")
raise("WebSocketServer.new_websocket_client() must be overloaded")
def start_server(self):
"""
Daemonize if requested. Listen for for connections. Run
do_handshake() method for each connection. If the connection
is a WebSockets client then call new_client() method (which must
is a WebSockets client then call new_websocket_client() method (which must
be overridden) for each new client connection.
"""
lsock = self.socket(self.listen_host, self.listen_port, False,
@ -841,7 +841,7 @@ Sec-WebSocket-Accept: %s\r
while True:
try:
try:
self.client = None
self.request = None
startsock = None
pid = err = 0
child_count = 0

10
websockify/websocketproxy.py
View File

@ -157,7 +157,7 @@ Traffic Legend:
# will be run in a separate forked process for each connection.
#
def new_client(self):
def new_websocket_client(self):
"""
Called after a new WebSocket connection has been established.
"""
@ -241,23 +241,23 @@ Traffic Legend:
cqueue = []
c_pend = 0
tqueue = []
rlist = [self.client, target]
rlist = [self.request, target]
while True:
wlist = []
if tqueue: wlist.append(target)
if cqueue or c_pend: wlist.append(self.client)
if cqueue or c_pend: wlist.append(self.request)
ins, outs, excepts = select(rlist, wlist, [], 1)
if excepts: raise Exception("Socket exception")
if self.client in outs:
if self.request in outs:
# Send queued target data to the client
c_pend = self.send_frames(cqueue)
cqueue = []
if self.client in ins:
if self.request in ins:
# Receive client data, decode it, and queue for target
bufs, closed = self.recv_frames()
tqueue.extend(bufs)