@cadenza.io/service 2.3.0 → 2.3.2

package/dist/index.js

@@ -318,8 +318,29 @@ var ServiceRegistry = class _ServiceRegistry {
       "Handle Instance Update",
       (ctx, emit) => {
         const { serviceInstance } = ctx;
-        const { uuid: uuid4, serviceName, address, port, exposed, isFrontend } = serviceInstance;
+        const {
+          uuid: uuid4,
+          serviceName,
+          address,
+          port,
+          exposed,
+          isFrontend,
+          deleted
+        } = serviceInstance;
         if (uuid4 === this.serviceInstanceId) return;
+        if (deleted) {
+          this.instances.get(serviceName)?.splice(
+            this.instances.get(serviceName)?.findIndex((i) => i.uuid === uuid4) ?? -1,
+            1
+          );
+          if (this.instances.get(serviceName)?.length === 0) {
+            this.instances.delete(serviceName);
+          } else if (this.instances.get(serviceName)?.filter((i) => i.address === address && i.port === port).length === 0) {
+            emit(`meta.socket_shutdown_requested:${address}_${port}`, {});
+            emit(`meta.fetch.destroy_requested:${address}_${port}`, {});
+          }
+          return;
+        }
         if (!this.instances.has(serviceName))
           this.instances.set(serviceName, []);
         const instances = this.instances.get(serviceName);
@@ -370,7 +391,11 @@ var ServiceRegistry = class _ServiceRegistry {
       "meta.service_instance.inserted",
       "meta.service_instance.updated",
       "meta.socket_client.status_received"
-    ).attachSignal("meta.service_registry.dependee_registered");
+    ).attachSignal(
+      "meta.service_registry.dependee_registered",
+      "meta.socket_shutdown_requested",
+      "meta.fetch.destroy_requested"
+    );
     CadenzaService.createMetaTask("Split service instances", function* (ctx) {
       if (!ctx.serviceInstances) {
         return;
@@ -458,7 +483,7 @@ var ServiceRegistry = class _ServiceRegistry {
     this.handleServiceHandshakeTask = CadenzaService.createMetaTask(
       "Handle service handshake",
       (ctx, emit) => {
-        const { serviceName, serviceInstanceId } = ctx;
+        const { serviceName, serviceInstanceId, serviceAddress, servicePort } = ctx;
         const serviceInstances = this.instances.get(serviceName);
         const instance = serviceInstances?.find(
           (i) => i.uuid === serviceInstanceId
@@ -477,10 +502,29 @@ var ServiceRegistry = class _ServiceRegistry {
             uuid: instance.uuid
           }
         });
+        const instancesToDelete = serviceInstances?.filter(
+          (i) => i.uuid !== serviceInstanceId && i.address === serviceAddress && i.port === servicePort
+        );
+        for (const i of instancesToDelete ?? []) {
+          this.instances.get(serviceName)?.splice(this.instances.get(serviceName)?.indexOf(i) ?? -1, 1);
+          emit("global.meta.service_registry.deleted", {
+            data: {
+              isActive: false,
+              isNonResponsive: false,
+              deleted: true
+            },
+            filter: {
+              uuid: i.uuid
+            }
+          });
+        }
         return true;
       },
       "Handles service handshake"
-    ).doOn("meta.fetch.handshake_complete").attachSignal("global.meta.service_registry.service_handshake");
+    ).doOn("meta.fetch.handshake_complete").attachSignal(
+      "global.meta.service_registry.service_handshake",
+      "global.meta.service_registry.deleted"
+    );
     this.handleSocketStatusUpdateTask = CadenzaService.createMetaTask(
       "Handle Socket Status Update",
       (ctx) => {
@@ -1560,7 +1604,7 @@ var RestController = class _RestController {
           transmitTask.destroy();
           statusTask.destroy();
         }).doOn(
-          "meta.fetch.destroy_requested",
+          `meta.fetch.destroy_requested:${fetchId}`,
           `meta.socket_client.disconnected:${fetchId}`,
           `meta.fetch.handshake_failed:${fetchId}`
         ).emits("meta.fetch.destroyed");
@@ -1855,12 +1899,23 @@ var SocketController = class _SocketController {
     CadenzaService.createMetaTask(
       "Connect to socket server",
       (ctx) => {
-        const { serviceName, serviceAddress, servicePort, protocol } = ctx;
+        const {
+          serviceInstanceId,
+          communicationTypes,
+          serviceName,
+          serviceAddress,
+          servicePort,
+          protocol
+        } = ctx;
         const socketProtocol = protocol === "https" ? "wss" : "ws";
         const port = protocol === "https" ? 443 : servicePort;
         const URL = `${socketProtocol}://${serviceAddress}:${port}`;
         const fetchId = `${serviceAddress}_${port}`;
         let handshake = false;
+        if (CadenzaService.get(`Socket handshake with ${URL}`)) {
+          console.error("Socket client already exists", URL);
+          return;
+        }
         const socket = (0, import_socket2.io)(URL, {
           reconnection: true,
           reconnectionAttempts: 5,
@@ -1948,7 +2003,7 @@ var SocketController = class _SocketController {
             { error: err.message, serviceName, socketId: socket.id, URL },
             "error"
           );
-          CadenzaService.emit("meta.socket_client.connect_error", err);
+          CadenzaService.emit(`meta.socket_client.connect_error:${fetchId}`, err);
         });
         socket.on("reconnect_attempt", (attempt) => {
           CadenzaService.log(`Reconnect attempt: ${attempt}`);
@@ -1989,8 +2044,8 @@ var SocketController = class _SocketController {
           handshake = false;
         });
         socket.connect();
-        CadenzaService.createEphemeralMetaTask(
-          `Handshake with ${URL}`,
+        const handshakeTask = CadenzaService.createMetaTask(
+          `Socket handshake with ${URL}`,
           async () => {
             if (handshake) return;
             handshake = true;
@@ -2024,7 +2079,7 @@ var SocketController = class _SocketController {
           "Handshakes with socket server"
         ).doOn(`meta.socket_client.connected:${fetchId}`);
         const delegateTask = CadenzaService.createMetaTask(
-          `Delegate flow to ${URL}`,
+          `Delegate flow to Socket service ${URL}`,
           async (ctx2, emit) => {
             if (ctx2.__remoteRoutineName === void 0) {
               return;
@@ -2057,7 +2112,7 @@ var SocketController = class _SocketController {
           `Delegate flow to service ${serviceName} with address ${URL}`
         ).doOn(`meta.service_registry.selected_instance_for_socket:${fetchId}`).attachSignal("meta.socket_client.delegated");
         const transmitTask = CadenzaService.createMetaTask(
-          `Transmit signal to ${URL}`,
+          `Transmit signal to socket server ${URL}`,
           async (ctx2, emit) => {
             if (ctx2.__signalName === void 0) {
               return;
@@ -2079,16 +2134,31 @@ var SocketController = class _SocketController {
         ).doOn(`meta.service_registry.selected_instance_for_socket:${fetchId}`).attachSignal("meta.socket_client.transmitted");
         CadenzaService.createEphemeralMetaTask(
           `Shutdown SocketClient ${URL}`,
-          () => {
+          (ctx2, emit) => {
+            CadenzaService.log("Shutting down socket client", { URL, serviceName });
             socket?.close();
+            handshakeTask.destroy();
             delegateTask.destroy();
             transmitTask.destroy();
+            emit(`meta.fetch.handshake_requested:${fetchId}`, {
+              serviceInstanceId,
+              serviceName,
+              communicationTypes,
+              serviceAddress,
+              servicePort,
+              protocol,
+              handshakeData: {
+                instanceId: CadenzaService.serviceRegistry.serviceInstanceId,
+                serviceName: CadenzaService.serviceRegistry.serviceName
+              }
+            });
           },
           "Shuts down the socket client"
         ).doOn(
           `meta.socket_shutdown_requested:${fetchId}`,
           `meta.socket_client.disconnected:${fetchId}`,
-          `meta.fetch.handshake_failed:${fetchId}`
+          `meta.fetch.handshake_failed:${fetchId}`,
+          `meta.socket_client.connect_error:${fetchId}`
         ).emits("meta.socket_client_shutdown_complete");
         return true;
       },