Jbflow/feature/tcp socket

midi-script/AbletonJS.py → midi-script/AbletonJSBase.py

@@ -1,11 +1,8 @@
 from __future__ import absolute_import
-import time
-
-
 from .version import version
-from .Config import DEBUG, FAST_POLLING
+from .Config import DEBUG
 from .Logging import logger
-from .Socket import Socket
+
 from .Interface import Interface
 from .Application import Application
 from .ApplicationView import ApplicationView
@@ -29,16 +26,12 @@
 import Live
 
 
-class AbletonJS(ControlSurface):
+class AbletonJSBase(ControlSurface):
     def __init__(self, c_instance):
-        super(AbletonJS, self).__init__(c_instance)
-        logger.info("Starting AbletonJS " + version + "...")
-
+        super(AbletonJSBase, self).__init__(c_instance)
+        logger.info(f"Starting AbletonJS {version}...")
+        self._socket = None
         self.tracked_midi = set()
-
-        Socket.set_message(self.show_message)
-        self.socket = Socket(self.command_handler)
-
         self.handlers = {
             "application": Application(c_instance, self.socket, self.application()),
             "application-view": ApplicationView(c_instance, self.socket, self.application()),
@@ -58,33 +51,16 @@ def __init__(self, c_instance):
             "clip_slot": ClipSlot(c_instance, self.socket),
             "clip": Clip(c_instance, self.socket),
         }
+
+    @property
+    def socket(self):
+        return self._socket
 
-        self._last_tick = time.time() * 1000
-        self.tick()
-
-        if FAST_POLLING:
-            self.recv_loop = Live.Base.Timer(
-                callback=self.socket.process, interval=10, repeat=True)
-
-            self.recv_loop.start()
-
-    def tick(self):
-        tick_time = time.time() * 1000
-
-        if tick_time - self._last_tick > 200:
-            logger.warning("UDP tick is lagging, delta: " +
-                           str(round(tick_time - self._last_tick)) + "ms")
-
-        self._last_tick = tick_time
-        self.socket.process()
-
-        process_time = time.time() * 1000
-
-        if process_time - tick_time > 100:
-            logger.warning("UDP processing is taking long, delta: " +
-                           str(round(tick_time - process_time)) + "ms")
-
-        self.schedule_message(1, self.tick)
+    @socket.setter
+    def socket(self, value):
+        self._socket = value
+        for handler in self.handlers.values():
+            handler.socket = value
 
     def build_midi_map(self, midi_map_handle):
         script_handle = self._c_instance.handle()
@@ -99,15 +75,7 @@ def build_midi_map(self, midi_map_handle):
     def receive_midi(self, midi_bytes):
         self.handlers["midi"].send_midi(midi_bytes)
 
-    def disconnect(self):
-        logger.info("Disconnecting")
-        if FAST_POLLING:
-            self.recv_loop.stop()
-        self.socket.send("disconnect")
-        self.socket.shutdown()
-        Interface.listeners.clear()
-        super(AbletonJS, self).disconnect()
-
+
     def command_handler(self, payload):
         namespace = payload["ns"]
 
@@ -119,5 +87,12 @@ def command_handler(self, payload):
             handler = self.handlers[namespace]
             handler.handle(payload)
         else:
-            self.socket.send("error", "No handler for namespace " +
-                             str(namespace), payload["uuid"])
+            self.socket.send(f"error - No handler for namespace: {namespace}, Payload UUID: {payload['uuid']}")
+
+    def disconnect(self):
+        logger.info("Disconnecting")
+        self.socket.send("disconnect")
+        self.socket.shutdown()
+        Interface.listeners.clear()
+        super(AbletonJSBase, self).disconnect()
+

midi-script/AbletonJSTCP.py

@@ -0,0 +1,41 @@
+from __future__ import absolute_import
+import queue
+from .version import version
+from .Logging import logger
+from .Socket.TCPSocket import Socket, WebsocketMessageHandler, WebsocketHandshakeHandler
+from .AbletonJSBase import AbletonJSBase
+import Live
+
+
+class AbletonJSTCP(AbletonJSBase):
+    def __init__(self, c_instance):
+        super(AbletonJSTCP, self).__init__(c_instance)
+        self.message_queue = queue.Queue()
+        self.socket_handshake_handler = WebsocketHandshakeHandler()
+        self.socket_message_handler = WebsocketHandshakeHandler()
+        self.socket = Socket(self.socket_callback, self.socket_handshake_handler, self.socket_websocket_handler)
+        self.socket.start()
+        self.check_queue = Live.Base.Timer(callback=self.process_queue, interval=20, repeat=True)
+        self.check_queue.start()
+
+
+    def socket_callback(self, payload):
+        self.message_queue.put(payload)
+
+    def process_queue(self):
+        if not self.message_queue.empty():
+            try:
+                payload = self.message_queue.get()
+                logger.debug(f"Payload: {payload}")
+                self.command_handler(payload)
+            except Exception as e:
+                logger.error(f'Error processing queue: {e}')
+
+
+    def disconnect(self):
+        self.check_queue.stop()
+        self.message_queue.clear()
+        self.message_queue = None
+        super(AbletonJSTCP, self).disconnect()
+
+

midi-script/AbletonJSUDP.py

@@ -0,0 +1,48 @@
+from __future__ import absolute_import
+import time
+from .Config import FAST_POLLING
+from .Logging import logger
+from .Socket.UDPSocket import Socket
+from .Interface import Interface
+
+from .AbletonJSBase import AbletonJSBase
+import Live
+
+
+class AbletonJSUDP(AbletonJSBase):
+    def __init__(self, c_instance):
+        super(AbletonJSUDP, self).__init__(c_instance)
+        Socket.set_message(self.show_message)
+        self.socket = Socket(self.command_handler)
+        self._last_tick = time.time() * 1000
+        self.tick()
+        if FAST_POLLING:
+            self.recv_loop = Live.Base.Timer(
+                callback=self.socket.process, interval=10, repeat=True)
+
+            self.recv_loop.start()
+
+    def tick(self):
+        tick_time = time.time() * 1000
+
+        if tick_time - self._last_tick > 200:
+            logger.warning("UDP tick is lagging, delta: " +
+                           str(round(tick_time - self._last_tick)) + "ms")
+
+        self._last_tick = tick_time
+        self.socket.process()
+
+        process_time = time.time() * 1000
+
+        if process_time - tick_time > 100:
+            logger.warning("UDP processing is taking long, delta: " +
+                           str(round(tick_time - process_time)) + "ms")
+        self.schedule_message(1, self.tick)
+
+
+
+    def disconnect(self):
+        if FAST_POLLING:
+            self.recv_loop.stop()
+        super(AbletonJSUDP, self).disconnect()
+

midi-script/Internal.py

@@ -19,3 +19,5 @@ def get_version(self, ns):
     def set_client_port(self, nsid, port):
         self.socket.set_client_port(port)
         return True
+
+

midi-script/Socket/Interfaces.py

@@ -0,0 +1,24 @@
+class MessageHandlerInterface:
+    def receive_message(self, connection):
+        raise NotImplementedError("receive_message method must be implemented by MassageHandler subclasses")
+
+    def send_message(self, connection, message):
+        raise NotImplementedError("send_message method must be implemented by MessageHandler subclasses")
+
+class HandshakeHandlerInterface:
+    def parse_headers(self, request):
+        raise NotImplementedError("parse_headers method must be implemented by HandshakeHandler subclasses")
+
+    def generate_accept_key(self, websocket_key):
+        raise NotImplementedError("generate_accept_key method should be implemented by HandshakeHandler subclasses")
+
+    def perform_handshake(self, connection):
+        raise NotImplementedError("perform_handshake method must be implemented by HandshakeHandler subclasses")
+
+class SocketInterface:
+    def send(self, name, obj=None, uuid=None):
+        raise NotImplementedError("send method must be implemented by socket subclasses")
+
+    def shutdown(self):
+        raise NotImplementedError("shutdown method must be implemented by socket subclasses")
+