@cadenza.io/service 1.13.9 → 1.15.0

package/dist/index.d.mts

@@ -158,6 +158,7 @@ declare class ServiceRegistry {
     private remoteSignals;
     serviceName: string | null;
     serviceInstanceId: string | null;
+    numberOfRunningGraphs: number;
     useSocket: boolean;
     retryCount: number;
     handleInstanceUpdateTask: Task;
@@ -169,13 +170,14 @@ declare class ServiceRegistry {
     doForEachInstance: Task;
     deleteInstance: Task;
     getBalancedInstance: Task;
-    updateInstanceId: Task;
     getInstanceById: Task;
     getInstancesByServiceName: Task;
     handleDeputyRegistrationTask: Task;
     getStatusTask: Task;
     insertServiceTask: Task;
     insertServiceInstanceTask: Task;
+    handleServiceNotRespondingTask: Task;
+    handleServiceHandshakeTask: Task;
     private constructor();
     reset(): void;
 }

package/dist/index.d.ts

@@ -158,6 +158,7 @@ declare class ServiceRegistry {
     private remoteSignals;
     serviceName: string | null;
     serviceInstanceId: string | null;
+    numberOfRunningGraphs: number;
     useSocket: boolean;
     retryCount: number;
     handleInstanceUpdateTask: Task;
@@ -169,13 +170,14 @@ declare class ServiceRegistry {
     doForEachInstance: Task;
     deleteInstance: Task;
     getBalancedInstance: Task;
-    updateInstanceId: Task;
     getInstanceById: Task;
     getInstancesByServiceName: Task;
     handleDeputyRegistrationTask: Task;
     getStatusTask: Task;
     insertServiceTask: Task;
     insertServiceInstanceTask: Task;
+    handleServiceNotRespondingTask: Task;
+    handleServiceHandshakeTask: Task;
     private constructor();
     reset(): void;
 }

package/dist/index.js

@@ -238,11 +238,13 @@ var DeputyTask = class extends import_core.Task {
       __localTaskName: this.name,
       __remoteRoutineName: this.remoteRoutineName,
       __serviceName: this.serviceName,
+      __localRoutineExecId: metadata.__routineExecId,
       __executionTraceId: (_a2 = metadata.__executionTraceId) != null ? _a2 : null,
       __metadata: __spreadProps(__spreadValues({}, metadata), {
         __deputyTaskName: this.name
       })
     }, ctx);
+    console.log("DEPUTY CONTEXT", deputyContext);
     return this.taskFunction(deputyContext, emit, progressCallback);
   }
 };
@@ -340,6 +342,7 @@ var ServiceRegistry = class _ServiceRegistry {
     this.remoteSignals = /* @__PURE__ */ new Map();
     this.serviceName = null;
     this.serviceInstanceId = null;
+    this.numberOfRunningGraphs = 0;
     this.useSocket = false;
     this.retryCount = 3;
     this.handleInstanceUpdateTask = CadenzaService.createMetaTask(
@@ -400,13 +403,14 @@ 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",
       "CadenzaDB.meta.service_instance.updated",
       "meta.service_instance.inserted",
-      "meta.service_instance.updated"
+      "meta.service_instance.updated",
+      "meta.socket_client.status_received"
     );
     this.handleRemoteSignalRegistrationTask = CadenzaService.createMetaTask(
       "Handle Remote Signal Registration",
@@ -457,6 +461,63 @@ var ServiceRegistry = class _ServiceRegistry {
       "meta.register_remote_signals_requested",
       "meta.fetch.handshake_complete"
     );
+    this.handleServiceNotRespondingTask = CadenzaService.createMetaTask(
+      "Handle service not responding",
+      (ctx, emit) => {
+        const { serviceName, serviceAddress, servicePort } = ctx;
+        const serviceInstances = this.instances.get(serviceName);
+        const instances = serviceInstances == null ? void 0 : serviceInstances.filter(
+          (i) => i.address === serviceAddress && i.port === servicePort
+        );
+        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,
+              isNonResponsive: true
+            },
+            filter: {
+              uuid: instance.uuid
+            }
+          });
+        }
+        return true;
+      },
+      "Handles service not responding"
+    ).doOn("meta.fetch.handshake_failed", "meta.socket_client.disconnected");
+    this.handleServiceHandshakeTask = CadenzaService.createMetaTask(
+      "Handle service handshake",
+      (ctx, emit) => {
+        const { serviceName, serviceAddress, servicePort, serviceInstanceId } = ctx;
+        console.log(
+          "SERVICE HANDSHAKE",
+          serviceName,
+          serviceAddress,
+          servicePort,
+          serviceInstanceId,
+          this.instances.get(serviceName)
+        );
+        const serviceInstances = this.instances.get(serviceName);
+        const instances = serviceInstances == null ? void 0 : serviceInstances.filter(
+          (i) => i.address === serviceAddress && i.port === servicePort
+        );
+        for (const instance of instances != null ? instances : []) {
+          emit("meta.service_registry.service_handshake", {
+            data: {
+              isActive: instance.isActive,
+              isNonResponsive: instance.isNonResponsive
+            },
+            filter: {
+              uuid: instance.uuid
+            }
+          });
+        }
+        return true;
+      },
+      "Handles service handshake"
+    ).doOn("meta.fetch.handshake_complete");
     this.handleSocketStatusUpdateTask = CadenzaService.createMetaTask(
       "Handle Socket Status Update",
       (ctx) => {
@@ -491,7 +552,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) {
@@ -503,18 +564,6 @@ var ServiceRegistry = class _ServiceRegistry {
         }
       ).then(this.handleInstanceUpdateTask)
     );
-    this.updateInstanceId = CadenzaService.createMetaTask(
-      "Update instance id",
-      (context) => {
-        const { __id, __oldId } = context;
-        const instance = this.instances.get(__oldId);
-        if (!instance) return context;
-        this.instances.set(__id, instance);
-        this.instances.delete(__oldId);
-        return context;
-      },
-      "Updates instance id."
-    ).doOn("meta.service.global_id_set");
     this.getInstanceById = CadenzaService.createMetaTask(
       "Get instance by id",
       (context) => {
@@ -1048,7 +1097,10 @@ var RestController = class _RestController {
                 try {
                   console.log("handshake", req.body);
                   CadenzaService.broker.emit("meta.rest.handshake", req.body);
-                  res.send({ __status: "success" });
+                  res.send({
+                    __status: "success",
+                    __serviceInstanceId: CadenzaService.serviceRegistry.serviceInstanceId
+                  });
                 } catch (e) {
                   console.error("Error in handshake", e);
                   res.send({ __status: "error" });
@@ -1123,7 +1175,7 @@ var RestController = class _RestController {
                 ).doAfter(CadenzaService.serviceRegistry.getStatusTask);
                 CadenzaService.broker.emit(
                   "meta.rest.status_check_requested",
-                  req.query
+                  req.body.query
                 );
               });
               return true;
@@ -1172,6 +1224,8 @@ var RestController = class _RestController {
                   };
                   const httpsServer = import_node_https.default.createServer(options, ctx2.__app);
                   ctx2.__httpsServer = httpsServer;
+                  ctx2.__port = 443;
+                  port = 443;
                   httpsServer.listen(443, () => {
                     var _a2, _b2;
                     if (typeof (httpsServer == null ? void 0 : httpsServer.address()) === "string") {
@@ -1231,7 +1285,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;
@@ -1245,11 +1299,13 @@ var RestController = class _RestController {
             });
             const result = yield response.json();
             console.log("Handshake result", result);
-            if (result.__status === "error") {
-              throw new Error(
-                (_a2 = result.__error) != null ? _a2 : `Failed to connect to service ${serviceName} ${ctx2.serviceInstanceId}`
-              );
+            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;
             console.log(`Connected to service ${serviceName} ${URL}`, result);
             for (const communicationType of ctx2.communicationTypes) {
               emit2("meta.fetch.service_communication_established", {
@@ -1260,17 +1316,11 @@ var RestController = class _RestController {
                 }
               });
             }
-            return true;
+            return ctx2;
           }),
-          "Sends handshake request",
-          {
-            retryCount: 20,
-            retryDelay: 200,
-            retryDelayMax: 5e3,
-            retryDelayFactor: 1.5
-          }
-        ).doOn(`meta.fetch.handshake_requested:${fetchId}`).emits("meta.fetch.handshake_complete").emitsOnFail("meta.fetch.handshake_failed");
-        CadenzaService.createMetaTask(
+          "Sends handshake request"
+        ).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) {
@@ -1305,7 +1355,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) {
@@ -1339,12 +1389,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({
@@ -1356,6 +1408,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"
@@ -1368,13 +1431,17 @@ var RestController = class _RestController {
             serviceInstanceId,
             communicationTypes,
             serviceAddress,
-            servicePort
+            servicePort,
+            protocol
           } = ctx;
           const fetchId = `${serviceAddress}_${servicePort}`;
           emit(`meta.fetch.handshake_requested:${fetchId}`, {
             serviceInstanceId,
             serviceName,
             communicationTypes,
+            serviceAddress,
+            servicePort,
+            protocol,
             handshakeData: {
               instanceId: CadenzaService.serviceRegistry.serviceInstanceId
               // JWT token...
@@ -1565,6 +1632,7 @@ var SocketController = class _SocketController {
         const port = protocol === "https" ? 443 : servicePort;
         const URL = `${socketProtocol}://${serviceAddress}:${port}`;
         const fetchId = `${serviceAddress}_${port}`;
+        console.log("SocketClient: Connecting to", serviceName, URL);
         const socket = (0, import_socket2.io)(URL, {
           reconnection: true,
           reconnectionAttempts: 20,
@@ -1573,7 +1641,6 @@ var SocketController = class _SocketController {
           randomizationFactor: 0.5,
           retries: 5
         });
-        console.log("SocketClient: Connecting to", URL);
         socket.on("connect", () => {
           console.log("SocketClient: CONNECTED");
           CadenzaService.broker.emit("meta.socket_client.connected", ctx);
@@ -1601,72 +1668,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"
@@ -1920,6 +2009,9 @@ var GraphMetadataController = class _GraphMetadataController {
       "Handle routine execution creation",
       (ctx) => {
         const context = ctx.data.context;
+        if (!ctx.data.isMeta) {
+          console.log("Handle routine execution creation", ctx.data);
+        }
         delete ctx.data.context;
         return {
           data: __spreadProps(__spreadValues({}, ctx.data), {
@@ -2024,8 +2116,8 @@ var GraphMetadataController = class _GraphMetadataController {
       (ctx) => {
         var _a2;
         const context = ctx.data.resultContext;
-        delete ctx.data.resultContext;
         console.log("Handle task execution ended", context);
+        delete ctx.data.resultContext;
         return {
           data: __spreadProps(__spreadValues({}, ctx.data), {
             service_name: CadenzaService.serviceRegistry.serviceName,
@@ -3059,8 +3151,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;
@@ -3204,7 +3295,7 @@ var GraphSyncController = class _GraphSyncController {
         );
       }
       return true;
-    }).doAfter(CadenzaService.registry.getAllTasks).then(CadenzaService.registry.getAllRoutines);
+    }).doAfter(CadenzaService.registry.getAllTasks);
   }
 };
 
@@ -3253,7 +3344,7 @@ var CadenzaService = class {
   static createDeputyTask(routineName, serviceName = void 0, options = {}) {
     this.bootstrap();
     this.validateName(routineName);
-    const name = `Deputy task for "${routineName}"`;
+    const name = `Deputy task for: ${routineName}`;
     options = __spreadValues({
       concurrency: 0,
       timeout: 0,
@@ -3344,12 +3435,12 @@ var CadenzaService = class {
       retryDelayFactor: 1
     }, options);
     options.isMeta = true;
-    const name = `SignalTransmission task for "${signalName}"`;
+    const name = `Transmission of signal: ${signalName}`;
     return new SignalTransmissionTask(
       name,
       signalName,
       serviceName,
-      `Transmits signal "${signalName}" to service "${serviceName}"`,
+      `Transmits signal ${signalName} to ${serviceName} service.`,
       options.concurrency,
       options.timeout,
       options.register,
@@ -3374,7 +3465,7 @@ var CadenzaService = class {
     import_core3.default.validateName(operation);
     const tableNameFormatted = tableName.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
     const name = `${operation} ${tableName} in ${databaseServiceName != null ? databaseServiceName : "default database service"}`;
-    const description = `Executes a database "${operation}" on table "${tableName}" in ${databaseServiceName != null ? databaseServiceName : "default database service"}`;
+    const description = `Executes a ${operation} on table ${tableName} in ${databaseServiceName != null ? databaseServiceName : "default database service"}`;
     const taskName = `db${operation.charAt(0).toUpperCase() + operation.slice(1)}${tableNameFormatted}`;
     options = __spreadValues({
       concurrency: 0,