Finished error_handler

letsencrypt/error_handler.py

@@ -3,44 +3,55 @@ import os
 import signal
 
 
-_SIGNALS = [signal.SIGTERM] if os.name == "nt" else
+_SIGNALS = ([signal.SIGTERM] if os.name == "nt" else
             [signal.SIGTERM, signal.SIGHUP, signal.SIGQUIT,
-            signal.SIGXCPU, signal.SIGXFSZ, signal.SIGPWR,]
+             signal.SIGXCPU, signal.SIGXFSZ, signal.SIGPWR])
 
 
-class ErrorHandler():
+class ErrorHandler(object):
     """Registers and calls cleanup functions in case of an error."""
     def __init__(self, func=None):
-        self.funcs = []
+        self.funcs = [func] if func else []
-        if func:
+        self.prev_handlers = {}
-            self.funcs.append(func)
 
     def __enter__(self):
         self.set_signal_handlers()
 
     def __exit__(self, exec_type, exec_value, traceback):
         if exec_value is not None:
-            self.cleanup()
+            self.call_registered()
         self.reset_signal_handlers()
 
     def register(self, func):
         """Registers func to be called if an error occurs."""
         self.funcs.append(func)
 
-    def cleanup(self):
+    def call_registered(self):
-        """Calls all registered functions."""
+        """Calls all functions in the order they were registered."""
-        while self.funcs:
+        for func in self.funcs:
-            self.funcs.pop()()
+            func()
 
     def set_signal_handlers(self):
-        for signal_type in _SIGNALS:
+        """Sets signal handlers for signals in _SIGNALS."""
-            signal.signal(signal_type, self._signal_handler)
+        for signum in _SIGNALS:
+            prev_handler = signal.getsignal(signum)
+            # If prev_handler is None, the handler was set outside of Python
+            if prev_handler is not None:
+                self.prev_handlers[signum] = prev_handler
+                signal.signal(signum, self._signal_handler)
 
     def reset_signal_handlers(self):
-        for signal_type in _SIGNALS:
+        """Resets signal handlers for signals in _SIGNALS."""
-            signal.signal(signal_type, signal.SIG_DFL)
+        for signum in self.prev_handlers:
+            signal.signal(signum, self.prev_handlers[signum])
+        self.prev_handlers.clear()
 
-    def _signal_handler(self, signum, frame):
+    def _signal_handler(self, signum, _):
-        self.cleanup()
+        """Calls registered functions and the previous signal handler.
-        signal.signal(signal_type, signal.SIG_DFL)
+
+        :param int signum: number of current signal
+
+        """
+        self.call_registered()
+        signal.signal(signum, self.prev_handlers[signum])
         os.kill(os.getpid(), signum)

letsencrypt/tests/error_handler_test.py

@@ -0,0 +1,25 @@
+"""Tests for letsencrypt.error_handler."""
+import unittest
+
+import mock
+
+
+class ErrorHandlerTest(unittest.TestCase):
+    """Tests for letsencrypt.error_handler."""
+
+    def setUp(self):
+        from letsencrypt import error_handler
+        self.init_func = mock.MagicMock()
+        self.error_handler = error_handler.ErrorHandler(self.init_func)
+
+    def test_context_manager(self):
+        try:
+            with self.error_handler:
+                raise ValueError
+        except ValueError:
+            pass
+        self.init_func.assert_called_once_with()
+
+
+if __name__ == "__main__":
+    unittest.main()  # pragma: no cover