@cadenza.io/service 1.9.54 → 1.10.0

package/dist/index.js

@@ -142,9 +142,11 @@ var DeputyTask = class extends import_core.Task {
       return new Promise((resolve, reject) => {
         if (context.__metadata.__blockRemoteExecution) {
           reject(new Error("Blocked remote execution"));
+          return;
         }
         if (context.__metadata.__skipRemoteExecution) {
           resolve(true);
+          return;
         }
         const processId = (0, import_uuid.v4)();
         context.__metadata.__deputyExecId = processId;
@@ -418,11 +420,14 @@ var ServiceRegistry = class _ServiceRegistry {
         let remoteSignals = (_a2 = this.remoteSignals.get(serviceName)) != null ? _a2 : [];
         remoteSignals = remoteSignals.concat((_b2 = this.remoteSignals.get("*")) != null ? _b2 : []);
         return __spreadValues({
-          __remoteSignals: remoteSignals
+          remoteSignals
         }, ctx);
       },
       "Gets remote signals"
-    ).doOn("meta.fetch.handshake_complete");
+    ).doOn(
+      "meta.register_remote_signals_requested",
+      "meta.fetch.handshake_complete"
+    );
     this.handleSocketStatusUpdateTask = CadenzaService.createMetaTask(
       "Handle Socket Status Update",
       (ctx) => {
@@ -456,10 +461,7 @@ var ServiceRegistry = class _ServiceRegistry {
         "health",
         "exposed"
       ]
-    }).doOn(
-      "meta.service_registry_sync_requested",
-      "meta.service_registry.instance_inserted"
-    ).then(
+    }).doOn("meta.service_registry_sync_requested").then(
       CadenzaService.createMetaTask("Split service instances", function* (ctx) {
         const { serviceInstances } = ctx;
         if (!serviceInstances) return;
@@ -467,6 +469,7 @@ var ServiceRegistry = class _ServiceRegistry {
           yield { serviceInstance };
         }
       }).then(this.handleInstanceUpdateTask)
+      // .emits("meta.process_signal_queue_requested"), // TODO Has to happen after the endpoints has been created...
     );
     this.updateInstanceId = CadenzaService.createMetaTask(
       "Update instance id",
@@ -749,11 +752,11 @@ var ServiceRegistry = class _ServiceRegistry {
         "Setup service",
         (ctx) => {
           var _a2, _b2;
-          const { serviceInstance, data, __useSocket, __retryCount } = ctx;
-          this.serviceInstanceId = (_a2 = data == null ? void 0 : data.uuid) != null ? _a2 : serviceInstance == null ? void 0 : serviceInstance.uuid;
+          const { service_instance, data, __useSocket, __retryCount } = ctx;
+          this.serviceInstanceId = (_a2 = service_instance == null ? void 0 : service_instance.uuid) != null ? _a2 : data == null ? void 0 : data.uuid;
           this.instances.set(
-            (_b2 = data == null ? void 0 : data.service_name) != null ? _b2 : serviceInstance == null ? void 0 : serviceInstance.service_name,
-            [__spreadValues({}, data != null ? data : serviceInstance)]
+            (_b2 = data == null ? void 0 : data.service_name) != null ? _b2 : service_instance == null ? void 0 : service_instance.service_name,
+            [__spreadValues({}, service_instance != null ? service_instance : data)]
           );
           this.useSocket = __useSocket;
           this.retryCount = __retryCount;
@@ -761,10 +764,7 @@ var ServiceRegistry = class _ServiceRegistry {
           return true;
         },
         "Sets service instance id after insertion"
-      ).emits(
-        "meta.service_registry.instance_inserted",
-        "meta.process_signal_queue_requested"
-      )
+      ).emits("meta.service_registry.instance_inserted")
     );
     CadenzaService.createMetaTask(
       "Handle service creation",
@@ -913,8 +913,14 @@ var RestController = class _RestController {
     return this._instance;
   }
   constructor() {
-    CadenzaService.registry.getTaskByName.doOn("meta.rest.delegation_requested");
-    CadenzaService.registry.getRoutineByName.doOn("meta.rest.delegation_requested");
+    CadenzaService.registry.getTaskByName.doOn(
+      "meta.rest.delegation_requested",
+      "meta.socket.delegation_requested"
+    );
+    CadenzaService.registry.getRoutineByName.doOn(
+      "meta.rest.delegation_requested",
+      "meta.socket.delegation_requested"
+    );
     CadenzaService.createMetaRoutine(
       "RestServer",
       [
@@ -1391,16 +1397,23 @@ var SocketController = class _SocketController {
             (ctx) => {
               const server = ctx.__socketServer;
               server.on("connection", (ws) => {
+                ws.on("handshake", (ctx2) => {
+                  console.log("Socket HANDSHAKE", ctx2.serviceInstanceId);
+                  ws.emit("handshake", {
+                    serviceInstanceId: CadenzaService.serviceRegistry.serviceInstanceId,
+                    __status: "success"
+                  });
+                  CadenzaService.broker.emit("meta.socket.handshake", ctx2);
+                });
                 ws.on(
                   "delegation",
                   (ctx2, callback) => {
+                    const deputyExecId = ctx2.__metadata.__deputyExecId;
                     CadenzaService.createEphemeralMetaTask(
                       "Resolve delegation",
                       callback,
                       "Resolves a delegation request using the provided callback from the client (.emitWithAck())"
-                    ).doOn(`meta.node.graph_completed:${ctx2.__routineExecId}`).emits(
-                      `meta.socket.delegation_resolved:${ctx2.__routineExecId}`
-                    );
+                    ).doOn(`meta.node.graph_completed:${deputyExecId}`).emits(`meta.socket.delegation_resolved:${deputyExecId}`);
                     CadenzaService.createEphemeralMetaTask(
                       "Delegation progress update",
                       (ctx3) => {
@@ -1416,10 +1429,10 @@ var SocketController = class _SocketController {
                         }
                       }
                     ).doOn(
-                      `meta.node.routine_execution_progress:${ctx2.__routineExecId}`,
-                      `meta.node.graph_completed:${ctx2.__routineExecId}`
+                      `meta.node.routine_execution_progress:${deputyExecId}`,
+                      `meta.node.graph_completed:${deputyExecId}`
                     ).emitsOnFail(
-                      `meta.socket.progress_failed:${ctx2.__routineExecId}`
+                      `meta.socket.progress_failed:${deputyExecId}`
                     );
                     CadenzaService.broker.emit(
                       "meta.socket.delegation_requested",
@@ -1488,15 +1501,15 @@ var SocketController = class _SocketController {
       "Connect to socket server",
       (ctx) => {
         const {
-          __serviceName,
-          __serviceInstanceId,
-          __serviceAddress,
-          __servicePort,
-          __protocol
+          serviceName,
+          serviceInstanceId,
+          serviceAddress,
+          servicePort,
+          protocol
         } = ctx;
-        const socketProtocol = __protocol === "https" ? "wss" : "ws";
-        const port = __protocol === "https" ? 443 : __servicePort;
-        const socket = (0, import_socket2.io)(`${socketProtocol}://${__serviceAddress}:${port}`, {
+        const socketProtocol = protocol === "https" ? "wss" : "ws";
+        const port = protocol === "https" ? 443 : servicePort;
+        const socket = (0, import_socket2.io)(`${socketProtocol}://${serviceAddress}:${port}`, {
           reconnection: true,
           reconnectionAttempts: 20,
           reconnectionDelay: 1e3,
@@ -1507,13 +1520,17 @@ var SocketController = class _SocketController {
         socket.on("connect", () => {
           CadenzaService.broker.emit("meta.socket_client.connected", ctx);
           socket.emit("handshake", {
-            __serviceInstanceId: ctx.__serviceInstanceId
+            serviceInstanceId
           });
         });
+        socket.on("handshake", (ctx2) => {
+          console.log("Socket client HANDSHAKE", ctx2);
+          CadenzaService.broker.emit("meta.socket_client.handshake", ctx2);
+        });
         socket.on("delegation_progress", (ctx2) => {
           CadenzaService.broker.emit(
-            `meta.socket_client.delegation_progress:${ctx2.__deputyExecId}`,
-            __spreadValues({ __serviceInstanceId }, ctx2)
+            `meta.socket_client.delegation_progress:${ctx2.__metadata.__deputyExecId}`,
+            __spreadValues({ serviceInstanceId }, ctx2)
           );
         });
         socket.on("status_update", (status) => {
@@ -1521,16 +1538,17 @@ var SocketController = class _SocketController {
         });
         socket.on("disconnect", () => {
           CadenzaService.broker.emit("meta.socket_client.disconnected", {
-            __serviceInstanceId
+            serviceInstanceId
           });
         });
         CadenzaService.createMetaTask(
-          `Delegate flow to ${__serviceInstanceId}`,
+          `Delegate flow to ${serviceInstanceId}`,
           (ctx2, emit) => __async(null, null, function* () {
             var _a2;
             if (ctx2.__remoteRoutineName === void 0) {
               return;
             }
+            console.log("Socket Delegate:", ctx2);
             let resultContext;
             try {
               resultContext = yield socket.timeout((_a2 = ctx2.__timeout) != null ? _a2 : 0).emitWithAck("delegation", ctx2);
@@ -1541,6 +1559,7 @@ var SocketController = class _SocketController {
                 __spreadValues(__spreadValues({}, resultContext), metadata)
               );
             } catch (e) {
+              console.log("socket error:", e);
               resultContext = __spreadValues(__spreadValues({
                 __error: `Timeout error: ${e}`,
                 errored: true
@@ -1548,14 +1567,14 @@ var SocketController = class _SocketController {
             }
             return resultContext;
           }),
-          `Delegate flow to instance ${__serviceInstanceId} of service ${__serviceName} with address ${__serviceAddress}:${__servicePort}`
+          `Delegate flow to instance ${serviceInstanceId} of service ${serviceName} with address ${serviceAddress}:${servicePort}`
         ).doOn(
-          `meta.service_registry.selected_instance_for_socket:${__serviceInstanceId}`
+          `meta.service_registry.selected_instance_for_socket:${serviceInstanceId}`
         ).emitsOnFail(
-          `meta.socket_client.delegate_failed:${__serviceInstanceId}`
+          `meta.socket_client.delegate_failed:${serviceInstanceId}`
         );
         CadenzaService.createMetaTask(
-          `Transmit signal to ${__serviceInstanceId}`,
+          `Transmit signal to ${serviceInstanceId}`,
           (ctx2, emit) => __async(null, null, function* () {
             var _a2;
             if (ctx2.__signalName === void 0) {
@@ -1578,11 +1597,11 @@ var SocketController = class _SocketController {
             }
             return response;
           }),
-          `Transmits signal to instance ${__serviceInstanceId} of service ${__serviceName} with address ${__serviceAddress}:${__servicePort}`
+          `Transmits signal to instance ${serviceInstanceId} of service ${serviceName} with address ${serviceAddress}:${servicePort}`
         ).doOn(
-          `meta.service_registry.selected_instance_for_socket:${__serviceInstanceId}`
+          `meta.service_registry.selected_instance_for_socket:${serviceInstanceId}`
         ).emitsOnFail(
-          `meta.socket_client.signal_transmission_failed:${__serviceInstanceId}`
+          `meta.socket_client.signal_transmission_failed:${serviceInstanceId}`
         );
         CadenzaService.createMetaTask(
           "Shutdown SocketClient",
@@ -1650,19 +1669,12 @@ var SignalController = class _SignalController {
     CadenzaService.createMetaTask(
       "Forward signal observations to remote service",
       (ctx, emit) => {
-        const { __remoteSignals } = ctx;
-        for (const remoteSignal of __remoteSignals) {
-          if (remoteSignal.__remoteServiceName === "*") {
-            emit(
-              "meta.signal_controller.wildcard_signal_registered",
-              remoteSignal
-            );
-          } else {
-            emit(
-              `meta.signal_controller.remote_signal_registered:${remoteSignal.__remoteServiceName}`,
-              remoteSignal
-            );
-          }
+        const { remoteSignals, serviceName } = ctx;
+        for (const remoteSignal of remoteSignals) {
+          emit(
+            `meta.signal_controller.remote_signal_registered:${serviceName}`,
+            remoteSignal
+          );
         }
         return true;
       },
@@ -3681,6 +3693,8 @@ var CadenzaService = class {
       (ctx, emit) => {
         SignalController.instance;
         GraphMetadataController.instance;
+        emit("meta.service_registry_sync_requested", {});
+        emit("meta.register_remote_signals_requested", { serviceName });
         emit("meta.register_all_routines", {});
         emit("meta.register_all_tasks", {});
         emit("meta.register_all_signals", {});