@cadenza.io/service 1.14.0 → 1.15.1

package/dist/index.js

@@ -403,7 +403,7 @@ var ServiceRegistry = class _ServiceRegistry {
         }
         return true;
       },
-      "Handles instance update from DB signal"
+      "Handles instance updates to service instances"
     ).emits("meta.service_registry.service_discovered").doOn(
       "meta.initializing_service",
       "CadenzaDB.meta.service_instance.inserted",
@@ -469,9 +469,16 @@ var ServiceRegistry = class _ServiceRegistry {
         const instances = serviceInstances == null ? void 0 : serviceInstances.filter(
           (i) => i.address === serviceAddress && i.port === servicePort
         );
+        console.log(
+          "Service not responding",
+          serviceAddress,
+          servicePort,
+          instances
+        );
         for (const instance of instances != null ? instances : []) {
           instance.isActive = false;
           instance.isNonResponsive = true;
+          instance.clientCreated = false;
           emit("meta.service_registry.service_not_responding", {
             data: {
               isActive: false,
@@ -485,7 +492,7 @@ var ServiceRegistry = class _ServiceRegistry {
         return true;
       },
       "Handles service not responding"
-    ).doOn("meta.fetch.handshake_failed");
+    ).doOn("meta.fetch.handshake_failed", "meta.socket_client.disconnected");
     this.handleServiceHandshakeTask = CadenzaService.createMetaTask(
       "Handle service handshake",
       (ctx, emit) => {
@@ -503,8 +510,6 @@ var ServiceRegistry = class _ServiceRegistry {
           (i) => i.address === serviceAddress && i.port === servicePort
         );
         for (const instance of instances != null ? instances : []) {
-          instance.isActive = serviceInstanceId === instance.uuid;
-          instance.isNonResponsive = serviceInstanceId !== instance.uuid;
           emit("meta.service_registry.service_handshake", {
             data: {
               isActive: instance.isActive,
@@ -553,7 +558,7 @@ var ServiceRegistry = class _ServiceRegistry {
         "exposed",
         "created"
       ]
-    }).doOn("meta.sync_requested").then(
+    }).doOn("meta.sync_requested").emits("meta.service_registry.synced_instances").then(
       CadenzaService.createMetaTask(
         "Split service instances",
         function* (ctx) {
@@ -1176,7 +1181,7 @@ var RestController = class _RestController {
                 ).doAfter(CadenzaService.serviceRegistry.getStatusTask);
                 CadenzaService.broker.emit(
                   "meta.rest.status_check_requested",
-                  req.query
+                  req.body.query
                 );
               });
               return true;
@@ -1286,7 +1291,7 @@ var RestController = class _RestController {
         const URL = `${protocol}://${serviceAddress}:${port}`;
         const fetchId = `${serviceAddress}_${port}`;
         console.log("Fetch connecting to", URL);
-        CadenzaService.createMetaTask(
+        const handshakeTask = CadenzaService.createMetaTask(
           `Send Handshake to ${URL}`,
           (ctx2, emit2) => __async(null, null, function* () {
             var _a2;
@@ -1303,6 +1308,7 @@ var RestController = class _RestController {
             if (result.__status !== "success") {
               const error = (_a2 = result.__error) != null ? _a2 : `Failed to connect to service ${serviceName} ${ctx2.serviceInstanceId}`;
               console.error(error);
+              emit2(`meta.fetch.handshake_failed:${fetchId}`, result);
               return __spreadProps(__spreadValues({}, ctx2), { __error: error, errored: true });
             }
             ctx2.serviceInstanceId = result.__serviceInstanceId;
@@ -1319,8 +1325,8 @@ var RestController = class _RestController {
             return ctx2;
           }),
           "Sends handshake request"
-        ).doOn(`meta.fetch.handshake_requested:${fetchId}`).emits("meta.fetch.handshake_complete").emitsOnFail("meta.fetch.handshake_failed");
-        CadenzaService.createMetaTask(
+        ).doOn(`meta.fetch.handshake_requested:${fetchId}`).emits("meta.fetch.handshake_complete");
+        const delegateTask = CadenzaService.createMetaTask(
           `Delegate flow to REST server ${URL}`,
           (ctx2, emit2) => __async(null, null, function* () {
             if (ctx2.__remoteRoutineName === void 0) {
@@ -1355,7 +1361,7 @@ var RestController = class _RestController {
           `meta.service_registry.selected_instance_for_fetch:${fetchId}`,
           `meta.service_registry.socket_failed:${fetchId}`
         ).emitsOnFail("meta.fetch.delegate_failed");
-        CadenzaService.createMetaTask(
+        const transmitTask = CadenzaService.createMetaTask(
           `Transmit signal to server ${URL}`,
           (ctx2, emit2) => __async(null, null, function* () {
             if (ctx2.__signalName === void 0) {
@@ -1389,12 +1395,14 @@ var RestController = class _RestController {
           `meta.signal_controller.remote_signal_registered:${serviceName}`,
           "meta.signal_controller.wildcard_signal_registered"
         ).emitsOnFail("meta.fetch.signal_transmission_failed");
-        CadenzaService.createMetaTask(
+        const statusTask = CadenzaService.createMetaTask(
           `Request status from ${URL}`,
           (ctx2) => __async(null, null, function* () {
             let status;
             try {
-              const response = yield (0, import_node_fetch.default)(`${URL}/status`, { method: "GET" });
+              const response = yield (0, import_node_fetch.default)(`${URL}/status`, {
+                method: "GET"
+              });
               status = yield response.json();
             } catch (e) {
               status = __spreadValues({
@@ -1406,6 +1414,17 @@ var RestController = class _RestController {
           }),
           "Requests status"
         ).doOn("meta.fetch.status_check_requested").emits("meta.fetch.status_checked").emitsOnFail("meta.fetch.status_check_failed");
+        CadenzaService.createEphemeralMetaTask("Destroy fetch client", (ctx2, emit2) => {
+          console.log("Destroying fetch client");
+          handshakeTask.destroy();
+          delegateTask.destroy();
+          transmitTask.destroy();
+          statusTask.destroy();
+        }).doOn(
+          "meta.fetch.destroy_requested",
+          `meta.socket_client.disconnected:${fetchId}`,
+          `meta.fetch.handshake_failed:${fetchId}`
+        ).emits("meta.fetch.destroyed");
         return true;
       },
       "Manages REST client requests as fallback"
@@ -1655,72 +1674,94 @@ var SocketController = class _SocketController {
         });
         socket.on("disconnect", () => {
           console.log("SocketClient: Disconnected", URL);
-          CadenzaService.broker.emit("meta.socket_client.disconnected", {
-            URL
+          CadenzaService.broker.emit(`meta.socket_client.disconnected:${fetchId}`, {
+            serviceName,
+            serviceAddress,
+            servicePort
           });
         });
-        CadenzaService.createMetaTask(
+        const delegateTask = CadenzaService.createMetaTask(
           `Delegate flow to ${URL}`,
           (ctx2, emit) => __async(null, null, function* () {
             if (ctx2.__remoteRoutineName === void 0) {
               return;
             }
-            console.log("Socket Delegate:", ctx2);
-            socket.timeout(1e4).emit("delegation", ctx2, (err, resultContext) => {
-              if (err) {
-                console.log("socket error:", err);
-                resultContext = __spreadValues(__spreadValues({
-                  __error: `Timeout error: ${err}`,
-                  errored: true
-                }, ctx2), ctx2.__metadata);
-                emit(`meta.socket_client.delegate_failed`, resultContext);
-                return;
-              }
-              const metadata = resultContext.__metadata;
-              delete resultContext.__metadata;
-              emit(
-                `meta.socket_client.delegated:${ctx2.__metadata.__deputyExecId}`,
-                __spreadValues(__spreadValues({}, resultContext), metadata)
+            return new Promise((resolve, reject) => {
+              console.log("Socket Delegate:", ctx2);
+              socket.timeout(1e4).emit(
+                "delegation",
+                ctx2,
+                (err, resultContext) => {
+                  if (err) {
+                    console.log("socket error:", err);
+                    resultContext = __spreadValues(__spreadValues({
+                      __error: `Timeout error: ${err}`,
+                      errored: true
+                    }, ctx2), ctx2.__metadata);
+                    emit(`meta.socket_client.delegate_failed`, resultContext);
+                    resolve(resultContext);
+                    return;
+                  }
+                  const metadata = resultContext.__metadata;
+                  delete resultContext.__metadata;
+                  emit(
+                    `meta.socket_client.delegated:${ctx2.__metadata.__deputyExecId}`,
+                    __spreadValues(__spreadValues({}, resultContext), metadata)
+                  );
+                  resolve(resultContext);
+                }
               );
             });
           }),
           `Delegate flow to service ${serviceName} with address ${URL}`
         ).doOn(`meta.service_registry.selected_instance_for_socket:${fetchId}`);
-        CadenzaService.createMetaTask(
+        const transmitTask = CadenzaService.createMetaTask(
           `Transmit signal to ${URL}`,
           (ctx2, emit) => __async(null, null, function* () {
-            var _a2;
             if (ctx2.__signalName === void 0) {
               return;
             }
-            socket.timeout((_a2 = ctx2.__timeout) != null ? _a2 : 1e4).emit("signal", ctx2, (err, response) => {
-              if (err) {
-                console.log("socket error:", err);
-                response = __spreadValues(__spreadValues({
-                  __error: `Timeout error: ${err}`,
-                  errored: true
-                }, ctx2), ctx2.__metadata);
-                emit(
-                  `meta.socket_client.signal_transmission_failed`,
-                  response
-                );
-                return;
-              }
-              if (ctx2.__routineExecId) {
-                emit(
-                  `meta.socket_client.transmitted:${ctx2.__routineExecId}`,
-                  response
-                );
-              }
+            return new Promise((resolve, reject) => {
+              var _a2;
+              socket.timeout((_a2 = ctx2.__timeout) != null ? _a2 : 1e4).emit("signal", ctx2, (err, response) => {
+                if (err) {
+                  console.log("socket error:", err);
+                  response = __spreadValues(__spreadValues({
+                    __error: `Timeout error: ${err}`,
+                    errored: true
+                  }, ctx2), ctx2.__metadata);
+                  emit(
+                    `meta.socket_client.signal_transmission_failed`,
+                    response
+                  );
+                  resolve(response);
+                  return;
+                }
+                if (ctx2.__routineExecId) {
+                  emit(
+                    `meta.socket_client.transmitted:${ctx2.__routineExecId}`,
+                    response
+                  );
+                }
+                resolve(response);
+              });
             });
           }),
           `Transmits signal to service ${serviceName} with address ${URL}`
         ).doOn(`meta.service_registry.selected_instance_for_socket:${fetchId}`);
-        CadenzaService.createMetaTask(
+        CadenzaService.createEphemeralMetaTask(
           `Shutdown SocketClient ${URL}`,
-          () => socket.close(),
+          () => {
+            socket == null ? void 0 : socket.close();
+            delegateTask.destroy();
+            transmitTask.destroy();
+          },
           "Shuts down the socket client"
-        ).doOn(`meta.socket_shutdown_requested:${fetchId}`).emits("meta.socket_client_shutdown_complete");
+        ).doOn(
+          `meta.socket_shutdown_requested:${fetchId}`,
+          `meta.socket_client.disconnected:${fetchId}`,
+          `meta.fetch.handshake_failed:${fetchId}`
+        ).emits("meta.socket_client_shutdown_complete");
         return true;
       },
       "Connects to a specified socket server"
@@ -3116,8 +3157,7 @@ var GraphSyncController = class _GraphSyncController {
   }
   constructor() {
     var _a2;
-    (_a2 = CadenzaService.broker.getSignalsTask) == null ? void 0 : _a2.doOn("meta.sync_requested");
-    CadenzaService.registry.getAllTasks.doAfter(CadenzaService.broker.getSignalsTask);
+    (_a2 = CadenzaService.broker.getSignalsTask) == null ? void 0 : _a2.doOn("meta.service_registry.synced_instances").then(CadenzaService.registry.getAllTasks.then(CadenzaService.registry.getAllRoutines));
     CadenzaService.createMetaTask("Split routines for registration", (ctx, emit) => {
       const { __routines } = ctx;
       if (!__routines) return;
@@ -3261,7 +3301,7 @@ var GraphSyncController = class _GraphSyncController {
         );
       }
       return true;
-    }).doAfter(CadenzaService.registry.getAllTasks).then(CadenzaService.registry.getAllRoutines);
+    }).doAfter(CadenzaService.registry.getAllTasks);
   }
 };