feature(crr): orchestrate the Apply Actions chain with useChainedMutations

Author: hervedombya

__mocks__/@scality/data-browser-library.tsx

@@ -30,6 +30,32 @@ export const useCreateBucket = jest.fn(() => ({
   reset: jest.fn(),
 }));
 
+export const useSetBucketVersioning = jest.fn(() => ({
+  mutate: jest.fn(),
+  mutateAsync: jest.fn(),
+  status: 'idle',
+  isIdle: true,
+  isLoading: false,
+  isSuccess: false,
+  isError: false,
+  data: undefined,
+  error: null,
+  reset: jest.fn(),
+}));
+
+export const useSetBucketReplication = jest.fn(() => ({
+  mutate: jest.fn(),
+  mutateAsync: jest.fn(),
+  status: 'idle',
+  isIdle: true,
+  isLoading: false,
+  isSuccess: false,
+  isError: false,
+  data: undefined,
+  error: null,
+  reset: jest.fn(),
+}));
+
 export const useSetBucketTagging = jest.fn(() => ({
   mutate: jest.fn(),
   mutateAsync: jest.fn(),

src/react/locations/CRRSetupWizard/hooks/useAssumeSourceRoleMutation.test.ts

@@ -0,0 +1,9 @@
+import { sourceStorageManagerRoleArn } from './useAssumeSourceRoleMutation';
+
+describe('sourceStorageManagerRoleArn', () => {
+  it('builds the storage-manager role ARN for the given account id', () => {
+    expect(sourceStorageManagerRoleArn('123456789012')).toBe(
+      'arn:aws:iam::123456789012:role/scality-internal/storage-manager-role',
+    );
+  });
+});

src/react/locations/CRRSetupWizard/hooks/useAssumeSourceRoleMutation.ts

@@ -0,0 +1,22 @@
+import { useMutation } from 'react-query';
+import { useSetAssumedRolePromise } from '../../../DataServiceRoleProvider';
+
+/**
+ * ARN of the platform-provisioned storage-manager role for an account — the
+ * role the wizard assumes to run S3 operations (create bucket, put replication)
+ * as that account. Matches the convention used by the ISV apply chain.
+ */
+export const sourceStorageManagerRoleArn = (accountId: string): string =>
+  `arn:aws:iam::${accountId}:role/scality-internal/storage-manager-role`;
+
+/**
+ * Assumes the source account's storage-manager role so the data-browser S3
+ * hooks target that account: the DataBrowserProvider S3 client is rebuilt from
+ * the newly assumed role between chain steps (same mechanism as the ISV chain).
+ */
+export const useAssumeSourceRoleMutation = () => {
+  const setRolePromise = useSetAssumedRolePromise();
+  return useMutation({
+    mutationFn: ({ roleArn }: { roleArn: string }) => setRolePromise({ roleArn }),
+  });
+};

src/react/locations/CRRSetupWizard/hooks/useCreateCRRLocationMutation.ts

@@ -0,0 +1,46 @@
+import { useShellHooks } from '@scality/module-federation';
+import { useMutation } from 'react-query';
+import type { LocationV1 } from '../../../../js/managementClient/api';
+import { notFalsyTypeGuard } from '../../../../types/typeGuards';
+import { useManagementClient } from '../../../ManagementProvider';
+import { useInstanceId } from '../../../next-architecture/ui/AuthProvider';
+import { useCreateLocationMutation } from '../../hooks/useCreateLocationMutation';
+
+const POLL_INTERVAL_MS = 500;
+const MAX_POLLS = 120; // ~60s
+
+const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+/**
+ * Creates the CRR location and resolves only once it has been applied to the
+ * running configuration. The subsequent replication rule references the
+ * location by name (`StorageClass`), which cloudserver only accepts after the
+ * overlay has reconciled — so the wizard must wait here before that step runs.
+ */
+export const useCreateCRRLocationMutation = () => {
+  const createLocation = useCreateLocationMutation();
+  const managementClient = useManagementClient();
+  const { useAuth } = useShellHooks();
+  const { getToken } = useAuth();
+  const instanceId = useInstanceId();
+
+  const runningConfigurationVersion = async (): Promise<number> => {
+    const client = notFalsyTypeGuard(managementClient);
+    client.setToken(await getToken());
+    return (await client.getLatestInstanceStatus(instanceId)).state?.runningConfigurationVersion ?? 0;
+  };
+
+  return useMutation({
+    mutationFn: async (location: LocationV1) => {
+      const referenceVersion = await runningConfigurationVersion();
+      await createLocation.mutateAsync(location);
+      for (let attempt = 0; attempt < MAX_POLLS; attempt += 1) {
+        if ((await runningConfigurationVersion()) > referenceVersion) {
+          return;
+        }
+        await delay(POLL_INTERVAL_MS);
+      }
+      throw new Error('Timed out waiting for the location to be applied to the running configuration');
+    },
+  });
+};

src/react/locations/CRRSetupWizard/hooks/useImportDestinationCertificateMutation.test.ts

@@ -0,0 +1,22 @@
+import type { ZenkoCR } from '../../../truststore/Truststore';
+import { isCertificateAlreadyImported } from './useImportDestinationCertificateMutation';
+
+const CERT = '-----BEGIN CERTIFICATE-----\ndest\n-----END CERTIFICATE-----';
+const withCerts = (certs: string[]): ZenkoCR => ({
+  spec: { egress: { extraCACerts: certs.map((c) => ({ 'ca.crt': c })) } },
+});
+
+describe('isCertificateAlreadyImported', () => {
+  it('is false when the truststore has no egress configuration yet', () => {
+    expect(isCertificateAlreadyImported(undefined, CERT)).toBe(false);
+    expect(isCertificateAlreadyImported({ spec: {} }, CERT)).toBe(false);
+  });
+
+  it('is false when other certificates are present but not this one', () => {
+    expect(isCertificateAlreadyImported(withCerts(['some-other-cert']), CERT)).toBe(false);
+  });
+
+  it('is true when the exact certificate is already in the truststore', () => {
+    expect(isCertificateAlreadyImported(withCerts(['some-other-cert', CERT]), CERT)).toBe(true);
+  });
+});

src/react/locations/CRRSetupWizard/hooks/useImportDestinationCertificateMutation.ts

@@ -0,0 +1,30 @@
+import { useMutation, useQuery } from 'react-query';
+import { useAddCertificateToZenkoConfigurationMutation } from '../../../../js/mutations';
+import { getZenkoCRQuery } from '../../../queries';
+import type { ZenkoCR } from '../../../truststore/Truststore';
+
+/** True when the PEM is already in the source truststore, so importing it again is a no-op. */
+export const isCertificateAlreadyImported = (zenkoCR: ZenkoCR | undefined, certificate: string): boolean =>
+  (zenkoCR?.spec?.egress?.extraCACerts ?? []).some((bundle) => bundle['ca.crt'] === certificate);
+
+/**
+ * Imports the destination CA certificate into the source cluster's truststore
+ * (Zenko CR `spec.egress.extraCACerts`). Idempotent: if the certificate is
+ * already present the step is a no-op, so re-runs and retries do not append
+ * duplicate entries.
+ */
+export const useImportDestinationCertificateMutation = () => {
+  const { data: zenkoCR } = useQuery(getZenkoCRQuery());
+  const hasEgress = !!zenkoCR?.spec?.egress;
+  const hasExtraCACerts = !!zenkoCR?.spec?.egress?.extraCACerts;
+  const addCertificate = useAddCertificateToZenkoConfigurationMutation({ hasEgress, hasExtraCACerts });
+
+  return useMutation({
+    mutationFn: async ({ certificate }: { certificate: string }) => {
+      if (isCertificateAlreadyImported(zenkoCR, certificate)) {
+        return;
+      }
+      await addCertificate.mutateAsync({ certificate });
+    },
+  });
+};