@kumori/aurora-backend-handler 1.0.0

package/api/service-api-service.ts

@@ -0,0 +1,796 @@
+import { environment } from "../environment";
+import { deployServiceHelper } from "./deploy-service-helper";
+import { eventHelper } from "../backend-handler";
+import {
+  initializeGlobalWebSocketClient,
+  getWebSocketStatus,
+  makeGlobalWebSocketRequest,
+} from "../websocket-manager";
+import { Link, Notification, Service } from "@hestekumori/aurora-interfaces";
+let pendingLinks = new Map<string, Link[]>();
+/**
+ * Function to deploy a service
+ * @param data Service object with the data of the service
+ */
+export const deployService = async (data: Service, token: string) => {
+  try {
+    const url = new URL(
+      `${environment.apiServer.baseUrl}/api/${environment.apiServer.apiVersion}/tenant/${data.tenant}/service/${data.name}`
+    );
+    url.searchParams.append("dryrun", "false");
+    url.searchParams.append("accept", "true");
+    url.searchParams.append("wait", "30000");
+    url.searchParams.append("validate", "true");
+    if(data.dsl){
+      url.searchParams.append("dsl", "true");
+    }
+    if (data.serviceData) {
+      const formData = new FormData();
+      formData.append("bundle", data.serviceData);
+      formData.append(
+        "meta",
+        JSON.stringify({
+          targetAccount: data.account,
+          targetEnvironment: data.environment,
+        })
+      );
+      formData.append("labels", JSON.stringify({ project: data.project }));
+      formData.append("comment", " ");
+      const response = await fetch(url.toString(), {
+        method: "POST",
+        body: formData,
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+
+      const jsonResponse = await response.json();
+
+      const isTimeout = jsonResponse?.events?.some(
+        (event: any) => event.content === "_timeout_"
+      );
+
+      if (isTimeout) {
+        console.error("Timeout en la petición:", {
+          isOk: false,
+          code: "TIMEOUT",
+          error: "_timeout_",
+        });
+      }
+    } else {
+      const formData = await deployServiceHelper(data);
+      if (data.download) {
+        return;
+      }
+      const response = await fetch(url.toString(), {
+        method: "POST",
+        body: formData,
+      });
+      if (!response.ok) {
+        const jsonResponse = await response.json();
+        data.error = {
+          code: jsonResponse.code,
+          message: jsonResponse.content,
+          timestamp: new Date().toISOString(),
+        };
+        eventHelper.service.publish.deploymentError(data);
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+
+      const jsonResponse = await response.json();
+
+      const isTimeout = jsonResponse?.events?.some(
+        (event: any) => event.content === "_timeout_"
+      );
+
+      if (isTimeout) {
+        console.error("Timeout en la petición:", {
+          isOk: false,
+          code: "TIMEOUT",
+          error: "_timeout_",
+        });
+      } else {
+        if (data.links.length > 0) {
+          pendingLinks.set(data.name, data.links);
+          linkPendingServices(data, token);
+        }
+      }
+    }
+  } catch (err) {
+    console.error("Error en la petición de despliegue de servicio:", err);
+    // data.error = {
+    //   code: (err as any).code,
+    //   message: (err as any).content,
+    //   timestamp: new Date().toISOString(),
+    // }
+    // eventHelper.service.publish.deploymentError(data);
+  }
+};
+export const redeployService = async (data: Service) => {
+  try {
+    const formData = await deployServiceHelper(data);
+    const url = new URL(
+      `${environment.apiServer.baseUrl}/api/${environment.apiServer.apiVersion}/tenant/${data.tenant}/service/${data.name}/revision/${data.currentRevision}`
+    );
+    url.searchParams.append("dryrun", "false");
+    url.searchParams.append("accept", "true");
+    url.searchParams.append("wait", "30000");
+    url.searchParams.append("validate", "true");
+
+    const response = await fetch(url.toString(), {
+      method: "POST",
+      body: formData,
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    const jsonResponse = await response.json();
+
+    const isTimeout = jsonResponse?.events?.some(
+      (event: any) => event.content === "_timeout_"
+    );
+
+    if (isTimeout) {
+      console.error("Timeout en la petición:", {
+        isOk: false,
+        code: "TIMEOUT",
+        error: "_timeout_",
+      });
+    } else {
+      eventHelper.service.publish.deployed(data);
+    }
+  } catch (err) {
+    console.error("Error en la petición de redepliegue de servicio:", err);
+  }
+};
+export const deleteService = async (data: Service, security: string) => {
+  try {
+    await initializeGlobalWebSocketClient(security);
+    const status = getWebSocketStatus();
+
+    const deleteBody = {
+      tenant: data.tenant,
+      service: data.name,
+      wait: 0,
+      remove_links: true,
+    };
+
+    const response = await makeGlobalWebSocketRequest(
+      "service:delete_service",
+      deleteBody,
+      30000,
+      "DELETE",
+      data.name
+    );
+    return response;
+  } catch (err) {
+    console.error("Error in service deletion WebSocket request:", err);
+    eventHelper.service.publish.deletionError(data);
+    throw err;
+  }
+};
+
+export const restartService = async (data: Service, security: string) => {
+  try {
+    await initializeGlobalWebSocketClient(security);
+    const status = getWebSocketStatus();
+
+    const restartBody = {
+      tenant: data.tenant,
+      service: data.name,
+    };
+
+    const response = await makeGlobalWebSocketRequest(
+      "service:restart",
+      restartBody,
+      30000,
+      "RESTART",
+      data.name
+    );
+
+    const updatedService: Service = {
+      ...data,
+      status: {
+        code: "PENDING",
+        message: "",
+        timestamp: "",
+        args: [],
+      },
+    };
+    eventHelper.service.publish.restarted(updatedService);
+    return response;
+  } catch (err) {
+    console.error("Error in service restart WebSocket request:", err);
+    eventHelper.service.publish.restartError(data);
+    throw err;
+  }
+};
+const generateLinkBody = (data: Service, link: Link) => {
+  const originInClient = data.clientChannels.find(
+    (channel) =>
+      channel.name === link.originChannel || channel.from === link.originChannel
+  );
+  const originInServer = data.serverChannels.find(
+    (channel) =>
+      channel.name === link.originChannel || channel.from === link.originChannel
+  );
+  const originInDuplex = data.duplexChannels.find(
+    (channel) =>
+      channel.name === link.originChannel || channel.from === link.originChannel
+  );
+  const targetInClient = data.clientChannels.find(
+    (channel) =>
+      channel.name === link.targetChannel || channel.from === link.targetChannel
+  );
+  const targetInServer = data.serverChannels.find(
+    (channel) =>
+      channel.name === link.targetChannel || channel.from === link.targetChannel
+  );
+  const targetInDuplex = data.duplexChannels.find(
+    (channel) =>
+      channel.name === link.targetChannel || channel.from === link.targetChannel
+  );
+
+  let linkBody;
+  if (originInClient) {
+    linkBody = {
+      client_tenant: data.tenant,
+      client_service: data.name,
+      client_channel: link.originChannel,
+      server_tenant: data.tenant,
+      server_service: link.target,
+      server_channel: link.targetChannel,
+    };
+  } else if (targetInClient) {
+    linkBody = {
+      client_tenant: data.tenant,
+      client_service: data.name,
+      client_channel: link.targetChannel,
+      server_tenant: data.tenant,
+      server_service: link.origin,
+      server_channel: link.originChannel,
+    };
+  } else if (originInServer) {
+    linkBody = {
+      client_tenant: data.tenant,
+      client_service: link.target,
+      client_channel: link.targetChannel,
+      server_tenant: data.tenant,
+      server_service: data.name,
+      server_channel: link.originChannel,
+    };
+  } else if (targetInServer) {
+    linkBody = {
+      client_tenant: data.tenant,
+      client_service: link.origin,
+      client_channel: link.originChannel,
+      server_tenant: data.tenant,
+      server_service: data.name,
+      server_channel: link.targetChannel,
+    };
+  } else if (originInDuplex) {
+    linkBody = {
+      client_tenant: data.tenant,
+      client_service: link.target,
+      client_channel: link.targetChannel,
+      server_tenant: data.tenant,
+      server_service: data.name,
+      server_channel: link.originChannel,
+    };
+  } else if (targetInDuplex) {
+    linkBody = {
+      client_tenant: data.tenant,
+      client_service: link.origin,
+      client_channel: link.originChannel,
+      server_tenant: data.tenant,
+      server_service: data.name,
+      server_channel: link.targetChannel,
+    };
+  } else {
+    console.warn(
+      `No se encontraron canales para el enlace: origin=${link.origin}, target=${link.target}`
+    );
+    linkBody = {
+      client_tenant: data.tenant,
+      client_service: link.origin,
+      client_channel: link.originChannel,
+      server_tenant: data.tenant,
+      server_service: link.target,
+      server_channel: link.targetChannel,
+    };
+  }
+  return linkBody;
+};
+export const linkPendingServices = async (service: Service, token: string) => {
+  const links = pendingLinks.get(service.name);
+  if (links) {
+    await Promise.all(
+      links.map(async (link) => {
+        try {
+          await initializeGlobalWebSocketClient(token);
+          const status = getWebSocketStatus();
+          const linkBody = generateLinkBody(service, link);
+
+          const linkResponse = await makeGlobalWebSocketRequest(
+            "link:link_service",
+            linkBody,
+            30000,
+            "LINK",
+            service.name
+          );
+
+          const notification: Notification = {
+            type: "success",
+            subtype: "service-linked",
+            date: Date.now().toString(),
+            status: "unread",
+            callToAction: false,
+            data: {
+              service: service.name,
+              tenant: service.tenant,
+            },
+          };
+
+          eventHelper.notification.publish.creation(notification);
+        } catch (linkErr) {
+          const notification: Notification = {
+            type: "error",
+            subtype: "error-service-link",
+            date: Date.now().toString(),
+            info_content: {
+              code: (linkErr as any).error.code,
+              message: (linkErr as any).error.content,
+            },
+            status: "unread",
+            callToAction: false,
+            data: {
+              service: service.name,
+              tenant: service.tenant,
+            },
+          };
+          eventHelper.notification.publish.creation(notification);
+        }
+      })
+    );
+  }
+};
+export const requestRevisionData = async (service: Service, token: string) => {
+  try {
+    await initializeGlobalWebSocketClient(token);
+    const status = getWebSocketStatus();
+
+    const revisionBody = {
+      tenant: service.tenant,
+      service: service.name,
+      revision: "latest",
+    };
+
+    const response = await makeGlobalWebSocketRequest(
+      "revision:revision_info",
+      revisionBody,
+      30000,
+      "GET_REVISION",
+      service.name,
+      "service",
+      service
+    );
+    return response;
+  } catch (err) {
+    console.error("Error in service deletion WebSocket request:", err);
+    throw err;
+  }
+};
+export const updateService = async (
+  data: Service,
+  token: string,
+  scale?: number
+) => {
+  try {
+    await initializeGlobalWebSocketClient(token);
+    // await unlinkServices(data, token);
+    // const newLinks: Link[] = data.links.filter((link) => !link.delete);
+    // const newLinksToCreate = newLinks.filter((link) => link.delete === false);
+    // console.log("DEBUG - newLinks", newLinksToCreate);
+    // if (newLinksToCreate.length > 0) {
+    //   const serviceWithNewLinks: Service = {
+    //     ...data,
+    //     links: newLinksToCreate,
+    //   };
+    //   pendingLinks.set(data.name, newLinksToCreate);
+    //   await linkPendingServices(serviceWithNewLinks, token);
+    // }
+
+    const parameterObject: Record<string, any> = {};
+    if (data.parameters && data.parameters.length > 0) {
+      data.parameters.forEach((param) => {
+        const key = param.configKey || param.name;
+        const paramType = param.type?.toLowerCase();
+        if (paramType === "number" || paramType === "integer") {
+          parameterObject[key] = Number(param.value) || 0;
+        } else if (paramType === "boolean") {
+          parameterObject[key] = param.value === "true";
+        } else {
+          parameterObject[key] = param.value;
+        }
+      });
+    }
+
+    const resourceObject: Record<string, any> = {};
+    if (data.resources && data.resources.length > 0) {
+      data.resources.forEach((resource) => {
+        if (resource.type === "volume") {
+          resourceObject[resource.name] = {
+            volume: {
+              kind: "storage",
+              size: parseInt(resource.value) || 1,
+              unit: "G",
+              type: resource.kind,
+            },
+          };
+        } else if (resource.type === "secret") {
+          resourceObject[resource.name] = {
+            secret: `${data.tenant}/${resource.value}`,
+          };
+        } else if (resource.type === "domain") {
+          resourceObject[resource.name] = {
+            domain: `${data.tenant}/${resource.value}`,
+          };
+        } else if (resource.type === "ca") {
+          resourceObject[resource.name] = {
+            ca: `${data.tenant}/${resource.value}`,
+          };
+        } else if (resource.type === "certificate") {
+          resourceObject[resource.name] = {
+            certificate: `${data.tenant}/${resource.value}`,
+          };
+        } else if (resource.type === "port") {
+          resourceObject[resource.name] = {
+            port: `${data.tenant}/${resource.value}`,
+          };
+        }
+      });
+    }
+
+    let previousRevision = 1;
+    if (data.currentRevision) {
+      previousRevision = parseInt(data.currentRevision.toString(), 10);
+      if (isNaN(previousRevision)) {
+        console.warn("currentRevision is not a valid number, using 1");
+        previousRevision = 1;
+      }
+    }
+    else{
+      previousRevision = getLatestRevision(data.revisions) || 1;
+    }
+
+    const scaleConfig: any = {};
+    if (data.role && data.role.length > 0) {
+      scaleConfig.detail = {};
+      data.role.forEach((role) => {
+        scaleConfig.detail[role.name] = {
+          hsize: role.hsize || scale || data.minReplicas || 1,
+        };
+      });
+    } else {
+      scaleConfig.hsize = scale || data.minReplicas || 1;
+    }
+    const meta = {
+      scaling: {
+        simple:
+          data.role?.reduce((acc, role) => {
+            if (role.scalling && role.name) {
+              acc[role.name] = {
+                scale_up: {
+                  cpu: Math.min(parseInt(role.scalling.cpu.up) || 0, 100),
+                  memory: Math.min(parseInt(role.scalling.memory.up) || 0, 100),
+                },
+                scale_down: {
+                  cpu: Math.min(parseInt(role.scalling.cpu.down) || 0, 100),
+                  memory: Math.min(
+                    parseInt(role.scalling.memory.down) || 0,
+                    100
+                  ),
+                },
+                hysteresis: parseInt(role.scalling.histeresys) || 0,
+                min_replicas: role.scalling.instances.min || 0,
+                max_replicas: role.scalling.instances.max || 0,
+              };
+            }
+            return acc;
+          }, {} as Record<string, any>) || {},
+      },
+    };
+
+    const updateBody = {
+      spec: {
+        type: "update-config",
+        comment: "Service configuration update",
+        config: {
+          parameter: parameterObject,
+          resource: resourceObject,
+          resilience: 0,
+          scale: scaleConfig,
+        },
+        meta: meta,
+      },
+      tenant: data.tenant,
+      service: data.name,
+      previous: previousRevision,
+    };
+
+    const response = await makeGlobalWebSocketRequest(
+      "revision:update_revision",
+      updateBody,
+      30000,
+      "UPDATE_CONFIG",
+      data.name
+    );
+
+    const updatedService: Service = {
+      ...data,
+      status: {
+        code: "PENDING",
+        message: "",
+        timestamp: "",
+        args: [],
+      },
+    };
+    eventHelper.service.publish.updated(updatedService);
+
+    const updateNotification: Notification = {
+      type: "success",
+      subtype: "service-updated",
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        service: data.name,
+        tenant: data.tenant,
+      },
+    };
+
+    eventHelper.notification.publish.creation(updateNotification);
+    return response;
+  } catch (err) {
+    console.error("Error updating service configuration via WebSocket:", err);
+    const notification: Notification = {
+      type: "error",
+      subtype: "service-update-error",
+      date: Date.now().toString(),
+      info_content: {
+        code: (err as any).error.code,
+        message: (err as any).error.content,
+      },
+      status: "unread",
+      callToAction: false,
+      data: {
+        service: data.name,
+        tenant: data.tenant,
+      },
+    };
+    eventHelper.notification.publish.creation(notification);
+    eventHelper.service.publish.updateError(data);
+    throw err;
+  }
+};
+export const unlinkServices = async (service: Service, token: string) => {
+  const deleteLinks: Link[] = service.links.filter(
+    (link) => link.delete === true
+  );
+  if (deleteLinks.length > 0) {
+    await Promise.all(
+      deleteLinks.map(async (link) => {
+        try {
+          await initializeGlobalWebSocketClient(token);
+          const status = getWebSocketStatus();
+          const unlinkBody = generateLinkBody(service, link);
+
+          const unlinkResponse = await makeGlobalWebSocketRequest(
+            "link:unlink_service",
+            unlinkBody,
+            30000,
+            "UNLINK",
+            service.name
+          );
+
+          const unlinkNotification: Notification = {
+            type: "success",
+            subtype: "service-unlinking",
+            date: Date.now().toString(),
+            status: "unread",
+            callToAction: false,
+            data: {
+              service: service.name,
+              tenant: service.tenant,
+            },
+          };
+
+          eventHelper.notification.publish.creation(unlinkNotification);
+        } catch (unlinkErr) {
+          console.error("Error unlinking service via WebSocket:", unlinkErr);
+
+          const notification: Notification = {
+            type: "error",
+            subtype: "service-unlink-error",
+            date: Date.now().toString(),
+            info_content: {
+              code: (unlinkErr as any).error.code,
+              message: (unlinkErr as any).error.content,
+            },
+            status: "unread",
+            callToAction: false,
+            data: {
+              service: service.name,
+              tenant: service.tenant,
+            },
+          };
+          eventHelper.notification.publish.creation(notification);
+        }
+      })
+    );
+  }
+};
+export const updateServiceLinks = async (link: Link, token: string) => {
+  const deleteLink = link.delete || false;
+  const originClient = link.client === link.originChannel;
+  const linkBody = {
+    client_tenant: link.tenant,
+    client_service: originClient ? link.origin : link.target,
+    client_channel: originClient ? link.originChannel : link.targetChannel,
+    server_tenant: link.tenant,
+    server_service: originClient ? link.target : link.origin,
+    server_channel: originClient ? link.targetChannel : link.originChannel,
+  };
+  if (deleteLink) {
+    try {
+      await initializeGlobalWebSocketClient(token);
+      const status = getWebSocketStatus();
+
+      const unlinkResponse = await makeGlobalWebSocketRequest(
+        "link:unlink_service",
+        linkBody,
+        30000,
+        "UNLINK",
+        link.origin
+      );
+
+      // const unlinkNotification: Notification = {
+      //   type: "success",
+      //   subtype: "service-unlinked",
+      //   date: Date.now().toString(),
+      //   status: "unread",
+      //   callToAction: false,
+      //   data: {
+      //     service: link.origin,
+      //     tenant: link.tenant,
+      //   },
+      // };
+
+      // eventHelper.notification.publish.creation(unlinkNotification);
+    } catch (unlinkErr) {
+      console.error("Error unlinking service via WebSocket:", unlinkErr);
+
+      const notification: Notification = {
+        type: "error",
+        subtype: "service-unlink-error",
+        date: Date.now().toString(),
+        info_content: {
+          code: (unlinkErr as any).error.code,
+          message: (unlinkErr as any).error.content,
+        },
+        status: "unread",
+        callToAction: false,
+        data: {
+          service: link.origin,
+          tenant: link.tenant,
+        },
+      };
+      eventHelper.notification.publish.creation(notification);
+    }
+  } else {
+    try {
+      await initializeGlobalWebSocketClient(token);
+      const status = getWebSocketStatus();
+
+      const linkResponse = await makeGlobalWebSocketRequest(
+        "link:link_service",
+        linkBody,
+        30000,
+        "LINK",
+        link.origin
+      );
+
+      const notification: Notification = {
+        type: "success",
+        subtype: "service-linked",
+        date: Date.now().toString(),
+        status: "unread",
+        callToAction: false,
+        data: {
+          service: link.origin,
+          tenant: link.tenant,
+        },
+      };
+
+      eventHelper.notification.publish.creation(notification);
+    } catch (linkErr) {
+      const notification: Notification = {
+        type: "error",
+        subtype: "error-service-link",
+        date: Date.now().toString(),
+        info_content: {
+          code: (linkErr as any).error.code,
+          message: (linkErr as any).error.content,
+        },
+        status: "unread",
+        callToAction: false,
+        data: {
+          service: link.origin,
+          tenant: link.tenant,
+        },
+      };
+      eventHelper.notification.publish.creation(notification);
+    }
+  }
+};
+export const changeRevision = async (data: Service, token: string) => {
+  try {
+    await initializeGlobalWebSocketClient(token);
+    const status = getWebSocketStatus();
+    const revisionBody = {
+      tenant: data.tenant,
+      service: data.name,
+      previous: Number(data.lastDeployed),
+      spec: {
+        type: "rollback",
+        labels: {},
+        target: Number(data.currentRevision),
+        comment: "",
+      },
+    };
+    const revisionResponse = await makeGlobalWebSocketRequest(
+      "revision:update_revision",
+      revisionBody,
+      30000,
+      "UPDATE_REVISION",
+      data.name
+    );
+    const notification: Notification = {
+      type: "success",
+      subtype: "revision-updated",
+      date: Date.now().toString(),
+      status: "unread",
+      callToAction: false,
+      data: {
+        service: data,
+      },
+    };
+
+    eventHelper.notification.publish.creation(notification);
+  } catch (error) {
+    const notification: Notification = {
+      type: "error",
+      subtype: "error-revision-update",
+      date: Date.now().toString(),
+      info_content: {
+        code: (error as any).error.code,
+        message: (error as any).error.content,
+      },
+      status: "unread",
+      callToAction: false,
+      data: {
+        service: data,
+      },
+    };
+    eventHelper.notification.publish.creation(notification);
+  }
+};
+function getLatestRevision(revisions: string[]): number | null {
+  if (!revisions || revisions.length === 0) {
+    return null;
+  }
+  
+  return Math.max(...revisions.map(Number));
+}