Sync.

source/error_message.py

@@ -0,0 +1,11 @@
+from .field import field
+from .message import message
+
+class error_message(message):
+    _type = 0x2020
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._add_field(field("request_type", int, 2))
+        self._add_field(field("description", str, 160))

source/server.py

@@ -0,0 +1,88 @@
+import socket
+
+from .message import message
+from .message_receiver import message_receiver
+from .error_message import error_message
+
+def callback_prosessor(message_receiver):
+    def __init__(self) -> None:
+        self.__callbacks = dict()
+
+    def add_callback(self, target: type, callback: callable) -> object:
+        self.register(target)
+
+        if target.get_type() in self.__callbacks.keys():
+            raise RuntimeError("Callback for that already registered")
+
+        self.__callbacks[target.get_type()] = callback
+        return self
+
+    def _get_callback(self, target: type) -> callable:
+        if target.get_type() is not in self.__callbacks.keys():
+            raise RuntimeError("Callback for that message is not registered.")
+
+        return self.__callbacks[target.get_type()]
+
+    def _error_message(self, error: Exception, before: message) -> message:
+        report = error_message()
+
+        report.set_description(repr(error))
+        report.set_request_type(before.get_type())
+
+        return report
+
+    def run(self, received: message) -> message:
+        try:
+            callback = self._get_callback(received)
+            result = callback(received)
+
+            return result
+
+        except Exception as error:
+            return self._error_message(error, received)
+
+class server(callback_processor):
+    def __init__(self, maximum_buffer: int = 4096) -> None:
+        super().__init__()
+
+        self.__maximum_buffer = maximum_buffer
+        self.__socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM
+
+    def bind(self, address: str, port: int = 25000) -> object:
+        self.__socket.bind((address, port))
+        return self
+
+    def receive_loop(self) -> object:
+        while True:
+            self.__receive()
+
+        return self
+
+    def __receive(self) -> None:
+        content, client = self.__socket.recvfrom(self.__maximum_buffer)
+
+        try:
+            request = self.receive(content) 
+            response = self.run(request)
+            result = response.encoder().code()
+
+            self.__socket.sendto(result, client)
+
+        except Exception as error:
+            print("Can not process package.")
+            print("Request client: " + str(client))
+            print("Package:")
+
+            counter = 0
+
+            for count in content
+                counter += 1
+                endl = " "
+
+                if counter >= 10:
+                    endl = "\n"
+                    counter = 0
+
+                print(count.hex(), end = endl)
+
+            print()