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

Rename self.client and new_client - prepare for #72 / #111

8 files changed, 29 insertions, 29 deletions

diff --git a/other/websocket.rb b/other/websocket.rb
index d4551a6..bb287ea 100644
--- a/other/websocket.rb
+++ b/other/websocket.rb
@@ -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
diff --git a/other/websockify.rb b/other/websockify.rb
index d6310f3..e54d0dd 100755
--- a/other/websockify.rb
+++ b/other/websockify.rb
@@ -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)
diff --git a/tests/echo.py b/tests/echo.py
index 1d46d50..ad83296 100755
--- a/tests/echo.py
+++ b/tests/echo.py
@@ -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)
diff --git a/tests/echo.rb b/tests/echo.rb
index 6a5493c..8db7dd3 100755
--- a/tests/echo.rb
+++ b/tests/echo.rb
@@ -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
diff --git a/tests/load.py b/tests/load.py
index e1354c9..fdff106 100755
--- a/tests/load.py
+++ b/tests/load.py
@@ -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
diff --git a/tests/test_websocketproxy.py b/tests/test_websocketproxy.py
index 0fdd0fb..cf940ae 100644
--- a/tests/test_websocketproxy.py
+++ b/tests/test_websocketproxy.py
@@ -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)
diff --git a/websockify/websocket.py b/websockify/websocket.py
index d5ea96b..add0337 100644
--- a/websockify/websocket.py
+++ b/websockify/websocket.py
@@ -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
diff --git a/websockify/websocketproxy.py b/websockify/websocketproxy.py
index 8e5d3fe..3525df8 100755
--- a/websockify/websocketproxy.py
+++ b/websockify/websocketproxy.py
@@ -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)