Channels are closed responsibly by patterns

bombela · bombela · commit a100a5a27c0e · 2014-09-10T01:51:37.000-07:00
Instead of doing horrible __del__ stuff and freezing everything in the gc,
and sometimes getting totally absurd errors:
 -&gt; lets cleanly and explicitly close our channels all the way down.
diff --git a/zerorpc/channel.py b/zerorpc/channel.py
@@ -55,9 +55,6 @@ def recv_is_supported(self):
     def emit_is_supported(self):
         return self._events.emit_is_supported
 
-    def __del__(self):
-        self.close()
-
     def close(self):
         if self._channel_dispatcher_task:
             self._channel_dispatcher_task.kill()
@@ -135,9 +132,6 @@ def recv_is_supported(self):
     def emit_is_supported(self):
         return self._multiplexer.emit_is_supported
 
-    def __del__(self):
-        self.close()
-
     def close(self):
         if self._channel_id is not None:
             del self._multiplexer._active_channels[self._channel_id]
@@ -198,9 +192,6 @@ def on_close_if(self):
     def on_close_if(self, cb):
         self._on_close_if = cb
 
-    def __del__(self):
-        self.close()
-
     def close(self):
         if self._recv_task is not None:
             self._recv_task.kill()
diff --git a/zerorpc/core.py b/zerorpc/core.py
@@ -240,21 +240,13 @@ def __call__(self, method, *args, **kargs):
         self._context.hook_client_before_request(request_event)
         bufchan.emit_event(request_event)
 
-        try:
-            if kargs.get('async', False) is False:
-                return self._process_response(request_event, bufchan, timeout)
+        if kargs.get('async', False) is False:
+            return self._process_response(request_event, bufchan, timeout)
 
-            async_result = gevent.event.AsyncResult()
-            gevent.spawn(self._process_response, request_event, bufchan,
-                    timeout).link(async_result)
-            return async_result
-        except:
-            # XXX: This is going to be closed twice if async is false and
-            # _process_response raises an exception. I wonder if the above
-            # async branch can raise an exception too, if no we can just remove
-            # this code.
-            bufchan.close()
-            raise
+        async_result = gevent.event.AsyncResult()
+        gevent.spawn(self._process_response, request_event, bufchan,
+                timeout).link(async_result)
+        return async_result
 
     def __getattr__(self, method):
         return lambda *args, **kargs: self(method, *args, **kargs)
diff --git a/zerorpc/heartbeat.py b/zerorpc/heartbeat.py
@@ -57,9 +57,6 @@ def recv_is_supported(self):
     def emit_is_supported(self):
         return self._channel.emit_is_supported
 
-    def __del__(self):
-        self.close()
-
     def close(self):
         if self._heartbeat_task is not None:
             self._heartbeat_task.kill()
diff --git a/zerorpc/patterns.py b/zerorpc/patterns.py
@@ -38,14 +38,15 @@ def accept_answer(self, event):
 
     def process_answer(self, context, channel, req_event, rep_event,
             handle_remote_error):
-        if rep_event.name == 'ERR':
-            exception = handle_remote_error(rep_event)
-            context.hook_client_after_request(req_event, rep_event, exception)
-            raise exception
-        context.hook_client_after_request(req_event, rep_event)
-        channel.close()
-        result = rep_event.args[0]
-        return result
+        try:
+            if rep_event.name == 'ERR':
+                exception = handle_remote_error(rep_event)
+                context.hook_client_after_request(req_event, rep_event, exception)
+                raise exception
+            context.hook_client_after_request(req_event, rep_event)
+            return rep_event.args[0]
+        finally:
+            channel.close()
 
 
 class ReqStream:
@@ -74,17 +75,19 @@ def is_stream_done(rep_event):
         channel.on_close_if = is_stream_done
 
         def iterator(req_event, rep_event):
-            while rep_event.name == 'STREAM':
-                # Like in process_call, we made the choice to call the
-                # after_exec hook only when the stream is done.
-                yield rep_event.args
-                rep_event = channel.recv()
-            if rep_event.name == 'ERR':
-                exception = handle_remote_error(rep_event)
-                context.hook_client_after_request(req_event, rep_event, exception)
-                raise exception
-            context.hook_client_after_request(req_event, rep_event)
-            channel.close()
+            try:
+                while rep_event.name == 'STREAM':
+                    # Like in process_call, we made the choice to call the
+                    # after_exec hook only when the stream is done.
+                    yield rep_event.args
+                    rep_event = channel.recv()
+                if rep_event.name == 'ERR':
+                    exception = handle_remote_error(rep_event)
+                    context.hook_client_after_request(req_event, rep_event, exception)
+                    raise exception
+                context.hook_client_after_request(req_event, rep_event)
+            finally:
+                channel.close()
 
         return iterator(req_event, rep_event)
 
