meerk40t 0.9.3001__py2.py3-none-any.whl → 0.9.7010__py2.py3-none-any.whl

meerk40t/network/tcp_server.py

@@ -1,140 +1,142 @@
-import socket
-
-from meerk40t.kernel import Module
-
-
-def plugin(kernel, lifecycle=None):
-    if lifecycle == "register":
-        _ = kernel.translation
-        kernel.register("module/TCPServer", TCPServer)
-
-
-class TCPServer(Module):
-    """
-    TCPServer opens up a localhost server and waits. Any connection is given its own handler.
-    """
-
-    def __init__(self, context, name, port=23):
-        """
-        Laser Server init.
-
-        @param context: Context at which this module is attached.
-        @param name: Name of this module
-        @param port: Port being used for the server.
-        """
-        Module.__init__(self, context, name)
-        self.port = port
-
-        self.socket = None
-        self.events_channel = self.context.channel(f"server-tcp-{port}")
-        self.data_channel = self.context.channel(f"data-tcp-{port}")
-        self.context.threaded(
-            self.run_tcp_delegater, thread_name=f"tcp-{port}", daemon=True
-        )
-
-    def stop(self):
-        self.state = "terminate"
-
-    def module_close(self, *args, **kwargs):
-        _ = self.context._
-        self.events_channel(_("Shutting down server."))
-        self.state = "terminate"
-        if self.socket is not None:
-            self.socket.close()
-            self.socket = None
-
-    def run_tcp_delegater(self):
-        """
-        TCP Run is a connection thread delegate. Any connections are given a different threaded
-        handle to interact with that connection. This thread here waits for sockets and delegates.
-        """
-        _ = self.context._
-        self.socket = socket.socket()
-        try:
-            self.socket.bind(("", self.port))
-            self.socket.listen(1)
-        except OSError:
-            self.events_channel(_("Could not start listening."))
-            return
-        handle = 1
-        while self.state != "terminate":
-            self.events_channel(
-                _("Listening {name} on port {port}...").format(
-                    name=self.name, port=self.port
-                )
-            )
-            connection = None
-            address = None
-            try:
-                connection, address = self.socket.accept()
-                self.events_channel(
-                    _("Socket Connected: {address}").format(address=address)
-                )
-                self.context.threaded(
-                    self.connection_handler(connection, address),
-                    thread_name=f"handler-{self.port}-{handle}",
-                    daemon=True,
-                )
-                handle += 1
-            except socket.timeout:
-                pass
-            except OSError:
-                self.events_channel(
-                    _("Socket was killed: {address}").format(address=address)
-                )
-                if connection is not None:
-                    connection.close()
-                break
-            except AttributeError:
-                self.events_channel(_("Socket did not exist to accept connection."))
-                break
-        if self.socket is not None:
-            self.socket.close()
-
-    def connection_handler(self, connection, address):
-        """
-        The TCP Connection Handle, handles all connections delegated by the tcp_run() method.
-        The threaded context is entirely local and independent.
-        """
-        _ = self.context._
-
-        def handle():
-            def send(e):
-                if connection is None:
-                    return
-                try:
-                    connection.send(bytes(e, "utf-8"))
-                    self.data_channel(f"<-- {str(e)}")
-                except (ConnectionAbortedError, ConnectionResetError):
-                    connection.close()
-                except OSError:
-                    # Connection is likely already closed.
-                    if connection is not None:
-                        connection.close()
-
-            recv = self.context.channel(f"{self.name}/recv", pure=True)
-            send_channel_name = f"{self.name}/send"
-            self.context.channel(send_channel_name, pure=True).watch(send)
-            while self.state != "terminate":
-                try:
-                    data_from_socket = connection.recv(1024)
-                    if len(data_from_socket):
-                        self.data_channel(f"--> {str(data_from_socket)}")
-                    else:
-                        break
-                    recv(data_from_socket)
-                except socket.timeout:
-                    self.events_channel(
-                        _("Connection to {address} timed out.").format(address=address)
-                    )
-                    break
-                except OSError:
-                    if connection is not None:
-                        connection.close()
-                    break
-            self.context.channel(send_channel_name).unwatch(send)
-            self.events_channel(
-                _("Connection to {address} was closed.").format(address=address)
-            )
-
-        return handle
+import socket
+
+from meerk40t.kernel import Module
+
+
+def plugin(kernel, lifecycle=None):
+    if lifecycle == "register":
+        _ = kernel.translation
+        kernel.register("module/TCPServer", TCPServer)
+
+
+class TCPServer(Module):
+    """
+    TCPServer opens up a localhost server and waits. Any connection is given its own handler.
+    """
+
+    def __init__(self, context, name, port=23):
+        """
+        Laser Server init.
+
+        @param context: Context at which this module is attached.
+        @param name: Name of this module
+        @param port: Port being used for the server.
+        """
+        Module.__init__(self, context, name)
+        self.port = port
+
+        self.socket = None
+        self.events_channel = self.context.channel(f"server-tcp-{port}")
+        self.data_channel = self.context.channel(f"data-tcp-{port}")
+        self.context.threaded(
+            self.run_tcp_delegater, thread_name=f"tcp-{port}", daemon=True
+        )
+
+    def stop(self):
+        self.state = "terminate"
+
+    def module_close(self, *args, **kwargs):
+        _ = self.context._
+        self.events_channel(_("Shutting down server."))
+        self.state = "terminate"
+        if self.socket is not None:
+            self.socket.close()
+            self.socket = None
+
+    def run_tcp_delegater(self):
+        """
+        TCP Run is a connection thread delegate. Any connections are given a different threaded
+        handle to interact with that connection. This thread here waits for sockets and delegates.
+        """
+        _ = self.context._
+        self.socket = socket.socket()
+        try:
+            self.socket.bind(("", self.port))
+            self.socket.listen(1)
+        except OSError:
+            self.events_channel(_("Could not start listening."))
+            return
+        handle = 1
+        while self.state != "terminate":
+            self.events_channel(
+                _("Listening {name} on port {port}...").format(
+                    name=self.name, port=self.port
+                )
+            )
+            connection = None
+            address = None
+            try:
+                connection, address = self.socket.accept()
+                self.events_channel(
+                    _("Socket Connected: {address}").format(address=address)
+                )
+                self.context.threaded(
+                    self.connection_handler(connection, address),
+                    thread_name=f"handler-{self.port}-{handle}",
+                    daemon=True,
+                )
+                handle += 1
+            except socket.timeout:
+                pass
+            except OSError:
+                self.events_channel(
+                    _("Socket was killed: {address}").format(address=address)
+                )
+                if connection is not None:
+                    connection.close()
+                break
+            except AttributeError:
+                self.events_channel(_("Socket did not exist to accept connection."))
+                break
+        if self.socket is not None:
+            self.socket.close()
+
+    def connection_handler(self, connection, address):
+        """
+        The TCP Connection Handle, handles all connections delegated by the tcp_run() method.
+        The threaded context is entirely local and independent.
+        """
+        _ = self.context._
+
+        def handle():
+            def send(e):
+                if connection is None:
+                    return
+                try:
+                    if isinstance(e, str):
+                        e = bytes(e, "utf-8")
+                    connection.send(e)
+                    self.data_channel(f"<-- {str(e)}")
+                except (ConnectionAbortedError, ConnectionResetError):
+                    connection.close()
+                except OSError:
+                    # Connection is likely already closed.
+                    if connection is not None:
+                        connection.close()
+
+            recv = self.context.channel(f"{self.name}/recv", pure=True)
+            send_channel_name = f"{self.name}/send"
+            self.context.channel(send_channel_name, pure=True).watch(send)
+            while self.state != "terminate":
+                try:
+                    data_from_socket = connection.recv(1024)
+                    if len(data_from_socket):
+                        self.data_channel(f"--> {str(data_from_socket)}")
+                    else:
+                        break
+                    recv(data_from_socket)
+                except socket.timeout:
+                    self.events_channel(
+                        _("Connection to {address} timed out.").format(address=address)
+                    )
+                    break
+                except OSError:
+                    if connection is not None:
+                        connection.close()
+                    break
+            self.context.channel(send_channel_name).unwatch(send)
+            self.events_channel(
+                _("Connection to {address} was closed.").format(address=address)
+            )
+
+        return handle

meerk40t/network/udp_server.py

@@ -1,77 +1,103 @@
-import socket
-
-from meerk40t.kernel import Module
-
-
-def plugin(kernel, lifecycle=None):
-    if lifecycle == "register":
-        _ = kernel.translation
-        kernel.register("module/UDPServer", UDPServer)
-
-
-class UDPServer(Module):
-    """
-    UDPServer opens up a localhost data server and waits for UDP packets.
-
-    Anything sent to the {path}/send channel is sent as a reply to the last seen UDP packet.
-    Any packet the server picks up will be sent to the {path}/recv channel.
-    """
-
-    def __init__(self, context, name, port=23, udp_address=None):
-        """
-        Laser Server init.
-
-        @param context: Context at which this module is attached.
-        @param name: Name of this module.
-        @param port: UDP listen port.
-        """
-        Module.__init__(self, context, name)
-        self.port = port
-        self.events_channel = self.context.channel(f"server-udp-{port}")
-
-        self.udp_address = udp_address
-        self.context.channel(f"{name}/send").watch(self.send)
-        self.recv = self.context.channel(f"{name}/recv")
-
-        self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-        self.socket.settimeout(2)
-        self.socket.bind(("", self.port))
-        self.context.threaded(self.run_udp_listener, thread_name=name, daemon=True)
-
-    def module_close(self, *args, **kwargs):
-        _ = self.context._
-        self.context.channel(f"{self.name}/send").unwatch(self.send)
-        # We stop watching the `send channel`
-        self.events_channel(_("Shutting down server."))
-        if self.socket is not None:
-            self.socket.close()
-            self.socket = None
-        self.state = "terminate"
-
-    def send(self, message):
-        _ = self.context._
-        if self.udp_address is None:
-            self.events_channel(
-                _(
-                    "No UDP packet can be sent as reply to a host that has never made contact."
-                )
-            )
-            return
-        self.socket.sendto(message, self.udp_address)
-
-    def run_udp_listener(self):
-        _ = self.context._
-        try:
-            self.events_channel(
-                _("UDP Socket({port}) Listening.").format(port=self.port)
-            )
-            while self.state not in ("end", "terminate"):
-                try:
-                    message, address = self.socket.recvfrom(1024)
-                except (socket.timeout, AttributeError):
-                    continue
-                if address is not None:
-                    self.udp_address = address
-                self.recv(message)
-        except OSError:
-            pass
+"""
+UDPServer opens up a localhost data server and waits for UDP packets. Utilizing pure MK channels.
+
+Any packet the server picks up will be sent to the `{path}/recv` channel.
+Data sent to the `{path}/send` channel is sent as a reply to the last seen UDP packet.
+
+"""
+
+import socket
+
+from meerk40t.kernel import Module
+
+
+def plugin(kernel, lifecycle=None):
+    if lifecycle == "register":
+        _ = kernel.translation
+        kernel.register("module/UDPServer", UDPServer)
+
+
+class UDPServer(Module):
+    def __init__(self, context, name, port=23, udp_address=None):
+        """
+        Laser Server init.
+
+        @param context: Context at which this module is attached.
+        @param name: Name of this module.
+        @param port: UDP listen port.
+        """
+        Module.__init__(self, context, name)
+
+        self.udp_address = udp_address
+
+        self.events_channel = self.context.channel(f"server-udp-{port}")
+        self.send_channel = self.context.channel(f"{name}/send", pure=True)
+        self.recv_channel = self.context.channel(f"{name}/recv", pure=True)
+
+        self.listen_address = ""
+        self.listen_port = port
+        self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        self.socket.settimeout(2)
+        self.socket.bind((self.listen_address, self.listen_port))
+
+    def module_open(self, *args, **kwargs):
+        """
+        Module opened. Watch send_channel -> Send and run the upd_listener thread.
+        @param args:
+        @param kwargs:
+        @return:
+        """
+        self.send_channel.watch(self.send)
+        self.context.threaded(self.run_udp_listener, thread_name=self.name, daemon=True)
+
+    def module_close(self, *args, **kwargs):
+        _ = self.context._
+        self.send_channel.unwatch(self.send)
+
+        self.events_channel(_("Shutting down server."))
+        if self.socket is not None:
+            self.socket.close()
+            self.socket = None
+        self.state = "terminate"
+
+    def send(self, message, address=None):
+        """
+        Watching the {name}/send channel. This will receive any data sent along that channel. And send it to the last
+        address at which data was received.
+
+        @param message:  Message to send.
+        @param address: (address,port) override if not simply replying.
+        @return:
+        """
+        _ = self.context._
+        if self.udp_address is None:
+            self.events_channel(
+                _(
+                    "No UDP packet can be sent as reply to a host that has never made contact."
+                )
+            )
+            return
+        if address:
+            self.udp_address = address
+        self.socket.sendto(message, self.udp_address)
+
+    def run_udp_listener(self):
+        """
+        UDP Thread Listener. Attempt to read UDP socket. On data read, send to `.recv_channel` ({name}/recv).
+        @return:
+        """
+        _ = self.context._
+        self.events_channel(
+            _("UDP Socket({port}) Listening.").format(port=self.listen_port)
+        )
+        try:
+            while self.state not in ("end", "terminate"):
+                try:
+                    message, address = self.socket.recvfrom(1024)
+                except (socket.timeout, AttributeError):
+                    continue
+                if address is not None:
+                    self.udp_address = address
+                self.recv_channel(message)
+        except OSError:
+            pass