ensuring things are properly cleared which fixes Lawouach#20

Lawouach · Lawouach · commit 49ee697bbedd · 2012-02-23T19:04:15.000+01:00
diff --git a/ws4py/framing.py b/ws4py/framing.py
@@ -44,6 +44,11 @@ def __init__(self, opcode=None, body='', masking_key=None, fin=0, rsv1=0, rsv2=0
         self.parser = self._parser()
         self.parser.next()
 
+    def _cleanup(self):
+        if self.parser:
+            self.parser.close()
+            self.parser = None
+
     def build(self):
         """
         Builds a frame from the instance's attributes and returns
diff --git a/ws4py/messaging.py b/ws4py/messaging.py
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 import os
 import struct
+import copy
 
 from ws4py.framing import Frame, OPCODE_CONTINUATION, OPCODE_TEXT, \
      OPCODE_BINARY, OPCODE_CLOSE, OPCODE_PING, OPCODE_PONG
diff --git a/ws4py/streaming.py b/ws4py/streaming.py
@@ -82,7 +82,7 @@ def __init__(self, always_mask=False, expect_masking=True):
         self.always_mask = always_mask
         self.expect_masking = expect_masking
 
-    def release(self):
+    def _cleanup(self):
         """
         Frees the stream's resources rendering it unusable.
         """
@@ -92,6 +92,7 @@ def release(self):
         self.errors = None
         self.pings = None
         self.pongs = None
+        self.closing = None
         
     def text_message(self, text):
         """
@@ -166,13 +167,15 @@ def receiver(self):
         """
         utf8validator = Utf8Validator()
         running = True
+        frame = None
         while running:
             frame = Frame()
             while 1:
                 try:
                     bytes = (yield frame.parser.next())
                     frame.parser.send(bytes)
                 except StopIteration:
+                    frame._cleanup()
                     bytes = frame.body or ''
 
                     # Let's avoid unmasking when there is no payload
@@ -185,7 +188,7 @@ def receiver(self):
                             break
                         elif frame.masking_key and not self.expect_masking:
                             msg = CloseControlMessage(code=1002, reason='Masked when not expected')
-                            self.errors.append()
+                            self.errors.append(msg)
                             break
                         else:
                             bytes = bytearray(bytes)
@@ -282,7 +285,14 @@ def receiver(self):
                     break
 
             frame.body = None
-            frame.parser.close()
+            frame = None
             utf8validator.reset()
+
+        if frame:
+            frame._cleanup()
+            frame = None
             
+        utf8validator.reset()    
         utf8validator = None
+
+        self._cleanup()
diff --git a/ws4py/websocket.py b/ws4py/websocket.py
@@ -186,10 +186,11 @@ def _cleanup(self):
         Frees up resources used by the endpoint.
         """
         self.sender = None
-        self.stream.release()
-        self.stream = None
         self.sock = None
-
+        self.environ = None
+        self.stream._cleanup()
+        self.stream = None
+        
     def run(self):
         """
         Performs the operation of reading from the underlying
@@ -214,9 +215,9 @@ def run(self):
         in a thread.
         """
         self.sock.setblocking(True)
+        s = self.stream
         try:
             self.opened()
-            s = self.stream
             sock = self.sock
             fileno = sock.fileno()
             process = self.process
@@ -230,13 +231,15 @@ def run(self):
             
             try:
                 if not s.closing:
-                    self.closed(1006)
+                    self.closed(1006, "Going away")
                 else:
                     self.closed(s.closing.code, s.closing.reason)
             finally:
+                s = sock = fileno = process = None
                 self.close_connection()
                 self._cleanup()
 
+
     def process(self, bytes):
         """ Takes some bytes and process them through the
         internal stream's parser. If a message of any kind is
@@ -263,18 +266,21 @@ def process(self, bytes):
                 self.close(s.closing.code, s.closing.reason)
             else:
                 self.client_terminated = True
+            s = None
             return False
 
         if s.errors:
             for error in s.errors:
                 self.close(error.code, error.reason)
             s.errors = []
+            s = None
             return False
 
         if s.has_message:
             self.received_message(s.message)
             s.message.data = None
             s.message = None
+            s = None
             return True
 
         if s.pings:
@@ -287,6 +293,7 @@ def process(self, bytes):
                 self.ponged(pong)
             s.pongs = []
 
+        s = None
         return True
         
 class EchoWebSocket(WebSocket):
@@ -296,4 +303,3 @@ def received_message(self, message):
         its originating endpoint.
         """
         self.send(message.data, message.is_binary)
-        
