Working on server

src/server.py

@@ -2,23 +2,72 @@ import asyncio
 import logging
 
 
-async def read_input_socket():
+class Server:
-    return
+    def __init__(self, host='localhost', input_port=None, output_port=None):
+        self._host = host
+        self._input_port = input_port
+        self._output_port = output_port
+        self._reader = None
+        self._writer = None
+        self._stopping = False
+        self.buffer = []  # Shared list
 
+    @property
+    def host(self):
+        return self._host
 
-async def write_on_output_socket():
+    @property
-    return
+    def input_port(self):
+        return self._input_port
+
+    @property
+    def output_port(self):
+        return self._output_port
+
+    @property
+    def reader(self) -> asyncio.StreamReader:
+        return self._reader
+
+    @property
+    def writer(self) -> asyncio.StreamReader:
+        return self._writer
+
+    @property
+    def stopping(self) -> bool:
+        return self._stopping
+
+    async def setup_reader(self):
+        reader, _ = await asyncio.open_connection(self.host, self.input_port)
+        self._reader = reader
+
+    async def setup_writer(self):
+        _, writer = await asyncio.open_connection(self.host, self.output_port)
+        self._writer = writer
+
+    async def run_server(self):
+        await self.setup_reader()
+        while not self.stopping:
+            try:
+                while len(self.buffer) >= 10**4:
+                    await asyncio.sleep(1)
+                try:
+                    input_data = await self.reader.readexactly(10**4)
+                except asyncio.IncompleteReadError as e:
+                    input_data = e.partial
+                self.buffer.append(input_data)
+            except Exception as e:
+                logging.error(e)
 
 
 if __name__ == '__main__':
     loop = asyncio.get_event_loop()
     try:
         logging.info("Starting file bridging server...")
-        loop.run_until_complete(
+        # loop.run_until_complete(
-            asyncio.gather(
+        #     asyncio.gather(
-                read_input_socket,
+        #         read_input_socket,
-                write_on_output_socket
+        #         write_on_output_socket
-            )
+        #     )
-        )
+        # )
     except KeyboardInterrupt():
         logging.info("Received KeyboardInterrupt, stopping...")