add ownerReferences

zjy365 · zjy365 · commit b5dd7b99f82c · 2026-01-31T12:27:44.000+08:00
diff --git a/frontend/providers/applaunchpad/src/constants/app.ts b/frontend/providers/applaunchpad/src/constants/app.ts
@@ -97,6 +97,8 @@ export const gpuNodeSelectorKey = 'nvidia.com/gpu.product';
 export const gpuResourceKey = 'nvidia.com/gpu';
 export const templateDeployKey = 'cloud.sealos.io/deploy-on-sealos';
 export const sealafDeployKey = 'sealaf-app';
+export const ownerReferencesKey = 'cloud.sealos.io/owner-references';
+export const ownerReferencesReadyValue = 'ready';
 
 export enum Coin {
   cny = 'cny',
diff --git a/frontend/providers/applaunchpad/src/pages/api/applyApp.ts b/frontend/providers/applaunchpad/src/pages/api/applyApp.ts
@@ -3,6 +3,8 @@ import { ApiResp } from '@/services/kubernet';
 import { authSession } from '@/services/backend/auth';
 import { getK8s } from '@/services/backend/kubernetes';
 import { handleK8sError, jsonRes } from '@/services/backend/response';
+import yaml from 'js-yaml';
+import { generateOwnerReference, shouldHaveOwnerReference } from '@/utils/deployYaml2Json';
 
 export default async function handler(req: NextApiRequest, res: NextApiResponse<ApiResp>) {
   const { yamlList, mode = 'create' }: { yamlList: string[]; mode?: 'create' | 'replace' } =
@@ -15,13 +17,87 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse<
     return;
   }
   try {
-    const { applyYamlList } = await getK8s({
+    const { k8sApp, applyYamlList, namespace } = await getK8s({
       kubeconfig: await authSession(req.headers)
     });
 
-    const applyRes = await applyYamlList(yamlList, mode);
+    // Parse all resources from YAML list
+    const allResources: any[] = [];
+    yamlList.forEach((yamlStr) => {
+      const resources = yaml.loadAll(yamlStr).filter((item) => item);
+      allResources.push(...resources);
+    });
+
+    console.log(allResources, 'allResources');
+    // Separate main workload (Deployment or StatefulSet) from dependent resources
+    const mainWorkloadIndex = allResources.findIndex(
+      (resource) => resource.kind === 'Deployment' || resource.kind === 'StatefulSet'
+    );
+
+    if (mainWorkloadIndex === -1) {
+      // No main workload found, use legacy flow
+      const applyRes = await applyYamlList(yamlList, mode);
+      jsonRes(res, { data: applyRes.map((item) => item.kind) });
+      return;
+    }
+
+    const mainWorkload = allResources[mainWorkloadIndex];
+    const dependentResources = allResources.filter((_, index) => index !== mainWorkloadIndex);
+
+    // Phase 1: Create main workload first
+    const mainWorkloadYaml = yaml.dump(mainWorkload);
+
+    await applyYamlList([mainWorkloadYaml], mode);
+
+    // Phase 2: Get UID from created workload
+    let workloadUid: string;
+    try {
+      if (mainWorkload.kind === 'Deployment') {
+        const deployment = await k8sApp.readNamespacedDeployment(
+          mainWorkload.metadata.name,
+          namespace
+        );
+        workloadUid = deployment.body.metadata?.uid || '';
+      } else {
+        const statefulSet = await k8sApp.readNamespacedStatefulSet(
+          mainWorkload.metadata.name,
+          namespace
+        );
+        workloadUid = statefulSet.body.metadata?.uid || '';
+      }
+    } catch (err) {
+      console.error('Failed to get workload UID:', err);
+      throw new Error('Failed to get workload UID after creation');
+    }
+
+    if (!workloadUid) {
+      throw new Error('Workload UID is empty');
+    }
+
+    // Phase 3: Add ownerReferences to dependent resources
+    const ownerReferences = generateOwnerReference(
+      mainWorkload.metadata.name,
+      mainWorkload.kind,
+      workloadUid
+    );
+
+    dependentResources.forEach((resource) => {
+      if (shouldHaveOwnerReference(resource.kind)) {
+        if (!resource.metadata) {
+          resource.metadata = {};
+        }
+        resource.metadata.ownerReferences = ownerReferences;
+      }
+    });
+
+    // Phase 4: Create dependent resources
+    if (dependentResources.length > 0) {
+      const dependentYamlList = dependentResources.map((resource) => yaml.dump(resource));
+      await applyYamlList(dependentYamlList, mode);
+    }
 
-    jsonRes(res, { data: applyRes.map((item) => item.kind) });
+    const allKinds = [mainWorkload, ...dependentResources].map((item) => item.kind);
+    jsonRes(res, { data: allKinds });
   } catch (err: any) {
     console.log(err);
     jsonRes(res, handleK8sError(err));
diff --git a/frontend/providers/applaunchpad/src/pages/api/delApp.ts b/frontend/providers/applaunchpad/src/pages/api/delApp.ts
@@ -3,7 +3,7 @@ import { ApiResp } from '@/services/kubernet';
 import { authSession } from '@/services/backend/auth';
 import { getK8s } from '@/services/backend/kubernetes';
 import { jsonRes } from '@/services/backend/response';
-import { appDeployKey } from '@/constants/app';
+import { appDeployKey, ownerReferencesKey, ownerReferencesReadyValue } from '@/constants/app';
 
 export type DeleteAppParams = { name: string };
 
@@ -33,6 +33,44 @@ export async function DeleteAppByName({ name, req }: DeleteAppParams & { req: Ne
       kubeconfig: await authSession(req.headers)
     });
 
+  // Check if app has ownerReferences annotation (new apps)
+  let hasOwnerReferences = false;
+  let workloadKind: 'Deployment' | 'StatefulSet' | null = null;
+
+  try {
+    // Try to read Deployment first
+    const deployment = await k8sApp.readNamespacedDeployment(name, namespace);
+    const annotation = deployment.body.metadata?.annotations?.[ownerReferencesKey];
+    hasOwnerReferences = annotation === ownerReferencesReadyValue;
+    workloadKind = 'Deployment';
+  } catch (err: any) {
+    if (err?.body?.code !== 404) {
+      console.error('Error reading Deployment:', err);
+    }
+    // Try to read StatefulSet
+    try {
+      const statefulSet = await k8sApp.readNamespacedStatefulSet(name, namespace);
+      const annotation = statefulSet.body.metadata?.annotations?.[ownerReferencesKey];
+      hasOwnerReferences = annotation === ownerReferencesReadyValue;
+      workloadKind = 'StatefulSet';
+    } catch (err2: any) {
+      if (err2?.body?.code !== 404) {
+        console.error('Error reading StatefulSet:', err2);
+      }
+    }
+  }
+
+  // If app has ownerReferences, only delete main workload (cascade delete handles rest)
+  if (hasOwnerReferences && workloadKind) {
+    if (workloadKind === 'Deployment') {
+      await k8sApp.deleteNamespacedDeployment(name, namespace);
+    } else {
+      await k8sApp.deleteNamespacedStatefulSet(name, namespace);
+    }
+    return;
+  }
+
+  // Legacy delete flow for apps without ownerReferences
   // delete Certificate
   const certificatesList = (await k8sCustomObjects.listNamespacedCustomObject(
     'cert-manager.io',
diff --git a/frontend/providers/applaunchpad/src/pages/api/updateApp.ts b/frontend/providers/applaunchpad/src/pages/api/updateApp.ts
@@ -9,6 +9,7 @@ import type { AppPatchPropsType } from '@/types/app';
 import { initK8s } from 'sealos-desktop-sdk/service';
 import { errLog, infoLog, warnLog } from 'sealos-desktop-sdk';
 import type { V1Service } from '@kubernetes/client-node';
+import { generateOwnerReference, shouldHaveOwnerReference } from '@/utils/deployYaml2Json';
 
 export type Props = {
   patch: AppPatchPropsType;
@@ -364,7 +365,53 @@ export default async function handler(req: NextApiRequest, res: NextApiResponse<
         return item.value;
       })
       .filter((item) => item);
-    await applyYamlList(createYamlList as string[], 'create');
+
+    // Add ownerReferences to newly created resources
+    if (createYamlList.length > 0) {
+      // Get workload UID
+      let workloadUid: string | undefined;
+      let workloadKind: 'Deployment' | 'StatefulSet' | undefined;
+
+      try {
+        // Try to read Deployment first
+        const deployment = await k8sApp.readNamespacedDeployment(appName, namespace);
+        workloadUid = deployment.body.metadata?.uid;
+        workloadKind = 'Deployment';
+      } catch (err: any) {
+        if (err?.body?.code === 404) {
+          // Try StatefulSet
+          try {
+            const statefulSet = await k8sApp.readNamespacedStatefulSet(appName, namespace);
+            workloadUid = statefulSet.body.metadata?.uid;
+            workloadKind = 'StatefulSet';
+          } catch (err2) {
+            warnLog('Could not find workload for ownerReferences', { appName });
+          }
+        }
+      }
+
+      // Add ownerReferences to new resources
+      if (workloadUid && workloadKind) {
+        const ownerReferences = generateOwnerReference(appName, workloadKind, workloadUid);
+        const updatedCreateYamlList = createYamlList.map((yamlStr) => {
+          const resource = yaml.load(yamlStr as string) as any;
+          if (shouldHaveOwnerReference(resource.kind)) {
+            if (!resource.metadata) {
+              resource.metadata = {};
+            }
+            resource.metadata.ownerReferences = ownerReferences;
+            infoLog('Added ownerReferences to new resource', {
+              kind: resource.kind,
+              name: resource.metadata.name
+            });
+          }
+          return yaml.dump(resource);
+        });
+        await applyYamlList(updatedCreateYamlList, 'create');
+      } else {
+        await applyYamlList(createYamlList as string[], 'create');
+      }
+    }
 
     // delete
     await Promise.all(
diff --git a/frontend/providers/applaunchpad/src/pages/app/edit/index.tsx b/frontend/providers/applaunchpad/src/pages/app/edit/index.tsx
@@ -11,6 +11,7 @@ import type { YamlItemType } from '@/types';
 import type { AppEditSyncedFields, AppEditType, DeployKindsType } from '@/types/app';
 import { adaptEditAppData } from '@/utils/adapt';
 import {
+  generateOwnerReference,
   json2ConfigMap,
   json2DeployCr,
   json2HPA,
@@ -268,7 +269,22 @@ const EditApp = ({ appName, tabType }: { appName?: string; tabType: string }) =>
         if (data.networks?.[index]) {
           data.networks[index].customDomain = customDomain;
         }
-        const ingressYaml = json2Ingress(data);
+
+        // Get ownerReferences from existing workload
+        let ownerReferences: any[] | undefined;
+        const workload = crOldYamls.current.find(
+          (item) => item.kind === YamlKindEnum.Deployment || item.kind === YamlKindEnum.StatefulSet
+        );
+        if (workload) {
+          const workloadObj = yaml.load(workload.value) as any;
+          const workloadUid = workloadObj?.metadata?.uid;
+          const workloadKind = workload.kind as 'Deployment' | 'StatefulSet';
+          if (workloadUid && workloadKind) {
+            ownerReferences = generateOwnerReference(data.appName, workloadKind, workloadUid);
+          }
+        }
+
+        const ingressYaml = json2Ingress(data, ownerReferences);
         setIsLoading(true);
         postDeployApp([ingressYaml], 'replace')
           .then(() => {
@@ -281,7 +297,7 @@ const EditApp = ({ appName, tabType }: { appName?: string; tabType: string }) =>
           .finally(() => setIsLoading(false));
       } catch (error) {}
     },
-    [formHook, setIsLoading, toast, t]
+    [formHook, setIsLoading, toast, t, appName]
   );
 
   useQuery(
diff --git a/frontend/providers/applaunchpad/src/utils/deployYaml2Json.ts b/frontend/providers/applaunchpad/src/utils/deployYaml2Json.ts
