Rework whole package to allow read-only/write-only servers

pipe_io_server/__init__.py

@@ -1 +1,3 @@
 from .pipe_io_server import PipeIOServer
+from .pipe_reader_server import PipeReaderServer
+from .pipe_writer_server import PipeWriterServer

pipe_io_server/pipe.py

@@ -1,6 +1,8 @@
 from os import mkfifo, remove, chmod
 from os.path import exists
 
+DEFAULT_PERMISSIONS = 0o600
+
 
 class Pipe:
     def __init__(self, path):

pipe_io_server/pipe_io_server.py

@@ -1,80 +1,17 @@
-from threading import Thread, Event
+from .pipe import DEFAULT_PERMISSIONS
-
+from .pipe_reader_server import PipeReaderServer
-from .pipe_reader_thread import PipeReaderThread
+from .pipe_writer_server import PipeWriterServer
-from .pipe_writer_thread import PipeWriterThread
-from .pipe import Pipe
-from .terminate_process_on_failure import terminate_process_on_failure
 
 
-class PipeIOServer(Thread):
+class PipeIOServer(PipeReaderServer, PipeWriterServer):
-    def __init__(self, in_pipe, out_pipe, permissions=0o600):
+    # pylint: disable=abstract-method
-        super().__init__(daemon=True)
+    def __init__(self, in_pipe, out_pipe, permissions=DEFAULT_PERMISSIONS):
-        self._in_pipe, self._out_pipe = in_pipe, out_pipe
+        super().__init__(
-        self._create_pipes(permissions)
+            in_pipe=in_pipe,
-        self._stop_event = Event()
+            out_pipe=out_pipe,
-        self._reader_thread, self._writer_thread = None, None
+            permissions=permissions
-        self._io_threads = None
-
-    def _create_pipes(self, permissions):
-        Pipe(self.in_pipe).recreate(permissions)
-        Pipe(self.out_pipe).recreate(permissions)
-
-    @property
-    def in_pipe(self):
-        return self._in_pipe
-
-    @property
-    def out_pipe(self):
-        return self._out_pipe
-
-    def handle_message(self, message):
-        raise NotImplementedError()
-
-    def send_message(self, message):
-        self._writer_thread.write(message)
-
-    @terminate_process_on_failure
-    def run(self):
-        self._init_io_threads()
-        for thread in self._io_threads:
-            thread.start()
-        self._stop_event.wait()
-        self._stop_threads()
-
-    def _init_io_threads(self):
-        self._reader_thread = PipeReaderThread(
-            self.in_pipe,
-            self._stop_event,
-            self.handle_message
         )
-        self._writer_thread = PipeWriterThread(
-            self.out_pipe,
-            self._stop_event
-        )
-        self._io_threads = (self._reader_thread, self._writer_thread)
 
-    def stop(self):
+    def _init_io_thread(self):
-        self._stop_event.set()
+        PipeReaderServer._init_io_thread(self)
-        if self.is_alive():
+        PipeWriterServer._init_io_thread(self)
-            self.join()
-
-    def _stop_threads(self):
-        for thread in self._io_threads:
-            if thread.is_alive():
-                thread.stop()
-        Pipe(self.in_pipe).remove()
-        Pipe(self.out_pipe).remove()
-        self.on_stop()
-
-    def on_stop(self):
-        pass
-
-    def wait(self):
-        self._stop_event.wait()
-
-    def __enter__(self):
-        self.start()
-        return self
-
-    def __exit__(self, type_, value, tb):
-        self.stop()

pipe_io_server/pipe_io_thread.py

@@ -0,0 +1,45 @@
+from threading import Thread, Event
+
+from .terminate_process_on_failure import terminate_process_on_failure
+
+
+class PipeIOThread(Thread):
+    def __init__(self):
+        super().__init__(daemon=True)
+        self._stop_event = Event()
+        self._io_threads = []
+
+    @terminate_process_on_failure
+    def run(self):
+        self._init_io_thread()
+        for thread in self._io_threads:
+            thread.start()
+        self._stop_event.wait()
+        self._stop_threads()
+
+    def _init_io_thread(self):
+        raise NotImplementedError()
+
+    def _stop_threads(self):
+        for thread in self._io_threads:
+            if thread.is_alive():
+                thread.stop()
+        self.on_stop()
+
+    def on_stop(self):
+        pass
+
+    def stop(self):
+        self._stop_event.set()
+        if self.is_alive():
+            self.join()
+
+    def wait(self):
+        self._stop_event.wait()
+
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, type_, value, tb):
+        self.stop()

pipe_io_server/pipe_reader_server.py

@@ -0,0 +1,30 @@
+from .pipe import Pipe, DEFAULT_PERMISSIONS
+from .pipe_io_thread import PipeIOThread
+from .pipe_reader_thread import PipeReaderThread
+
+
+class PipeReaderServer(PipeIOThread):
+    def __init__(self, in_pipe, permissions=DEFAULT_PERMISSIONS, **kwargs):
+        super().__init__(**kwargs)
+        self._in_pipe = in_pipe
+        Pipe(self.in_pipe).recreate(permissions)
+        self._reader_thread = None
+
+    @property
+    def in_pipe(self):
+        return self._in_pipe
+
+    def _init_io_thread(self):
+        self._reader_thread = PipeReaderThread(
+            self.in_pipe,
+            self._stop_event,
+            self.handle_message
+        )
+        self._io_threads.append(self._reader_thread)
+
+    def handle_message(self, message):
+        raise NotImplementedError()
+
+    def stop(self):
+        super().stop()
+        Pipe(self.in_pipe).remove()

pipe_io_server/pipe_writer_server.py

@@ -0,0 +1,29 @@
+from .pipe import Pipe, DEFAULT_PERMISSIONS
+from .pipe_io_thread import PipeIOThread
+from .pipe_writer_thread import PipeWriterThread
+
+
+class PipeWriterServer(PipeIOThread):
+    def __init__(self, out_pipe, permissions=DEFAULT_PERMISSIONS, **kwargs):
+        super().__init__(**kwargs)
+        self._out_pipe = out_pipe
+        Pipe(self.out_pipe).recreate(permissions)
+        self._writer_thread = None
+
+    @property
+    def out_pipe(self):
+        return self._out_pipe
+
+    def _init_io_thread(self):
+        self._writer_thread = PipeWriterThread(
+            self.out_pipe,
+            self._stop_event
+        )
+        self._io_threads.append(self._writer_thread)
+
+    def send_message(self, message):
+        self._writer_thread.write(message)
+
+    def stop(self):
+        super().stop()
+        Pipe(self.out_pipe).remove()