Disaster recovery UI for Kubevirt VM - Discovered(Standalone)

Signed-off-by: Gowtham Shanmugasundaram <gshanmug@redhat.com>

Author: GowthamShanmugam

locales/en/plugin__odf-console.json

@@ -340,6 +340,7 @@
   "{{selected}} of {{total}} selected": "{{selected}} of {{total}} selected",
   "subscription-selector": "subscription-selector",
   "Select the subscriptions groups you wish to replicate via": "Select the subscriptions groups you wish to replicate via",
+  "Enroll virtual machine": "Enroll virtual machine",
   "Enroll managed application": "Enroll managed application",
   "Manage disaster recovery": "Manage disaster recovery",
   "<0>Application:</0> {applicationName} (Namespace: {applicationNamespace})": "<0>Application:</0> {applicationName} (Namespace: {applicationNamespace})",
@@ -349,6 +350,15 @@
   "Invalid label selector": "Invalid label selector",
   "The selected PVC label selector doesn't meet the label requirements. Choose a valid label selector or create one with the following requirements: {{ message }}": "The selected PVC label selector doesn't meet the label requirements. Choose a valid label selector or create one with the following requirements: {{ message }}",
   "Assign": "Assign",
+  "Protection name": "Protection name",
+  "A unique name to identify and manage this protection.": "A unique name to identify and manage this protection.",
+  "Protect this VM independently without associating it with an existing DR placement control.": "Protect this VM independently without associating it with an existing DR placement control.",
+  "Standalone": "Standalone",
+  "Add this VM to an existing DR placement control for consistent failover and recovery. This method is only available for discovered VMs.": "Add this VM to an existing DR placement control for consistent failover and recovery. This method is only available for discovered VMs.",
+  "Shared": "Shared",
+  "Protection type": "Protection type",
+  "Choose how you would like to protect this VM:": "Choose how you would like to protect this VM:",
+  "Shared protection is not available for managed VMs.": "Shared protection is not available for managed VMs.",
   "Delete": "Delete",
   "Select a placement": "Select a placement",
   "{{count}} selected_one": "{{count}} selected",
@@ -360,25 +370,28 @@
   "Application resource": "Application resource",
   "PVC label selector": "PVC label selector",
   "Add application resource": "Add application resource",
-  "{{count}} placements_one": "{{count}} placements",
-  "{{count}} placements_other": "{{count}} placements",
-  "Data policy": "Data policy",
+  "Protection type:": "Protection type:",
+  "Protection name:": "Protection name:",
+  "Policy": "Policy",
   "Policy name:": "Policy name:",
   "Clusters:": "Clusters:",
   "Replication type:": "Replication type:",
   "Sync interval:": "Sync interval:",
+  "{{count}} placements_one": "{{count}} placements",
+  "{{count}} placements_other": "{{count}} placements",
   "PVC details": "PVC details",
   "Application resource:": "Application resource:",
   "PVC label selector:": "PVC label selector:",
+  "Application already enrolled in disaster recovery": "Application already enrolled in disaster recovery",
+  "<0>This managed application namespace is already DR protected. You may have protected this namespace while enrolling discovered applications.</0><1>To see disaster recovery information for your applications, go to<1> Protected applications </1> under <3> Disaster Recovery </3>.</1>": "<0>This managed application namespace is already DR protected. You may have protected this namespace while enrolling discovered applications.</0><1>To see disaster recovery information for your applications, go to<1> Protected applications </1> under <3> Disaster Recovery </3>.</1>",
+  "No assigned disaster recovery policy found": "No assigned disaster recovery policy found",
+  "<0>You have not enrolled this application yet. To protect your application, click <1>Enroll application.</1></0>": "<0>You have not enrolled this application yet. To protect your application, click <1>Enroll application.</1></0>",
+  "Enroll application": "Enroll application",
+  "<0>You have not enrolled this virtual machine yet. To protect your virtual machine, click <1>Enroll virtual machine.</1></0>": "<0>You have not enrolled this virtual machine yet. To protect your virtual machine, click <1>Enroll virtual machine.</1></0>",
   "New policy assigned to application": "New policy assigned to application",
   "Remove disaster recovery": "Remove disaster recovery",
   "Your application will lose disaster recovery protection, preventing volume synchronization (replication) between clusters.": "Your application will lose disaster recovery protection, preventing volume synchronization (replication) between clusters.",
   "Disaster recovery removed successfully.": "Disaster recovery removed successfully.",
-  "Enroll application": "Enroll application",
-  "Application already enrolled in disaster recovery": "Application already enrolled in disaster recovery",
-  "No assigned disaster recovery policy found": "No assigned disaster recovery policy found",
-  "<0>This managed application namespace is already DR protected. You may have protected this namespace while enrolling discovered applications.</0><1>To see disaster recovery information for your applications, go to<1>Protected applications</1> under <3>Disaster Recovery</3>.</1>": "<0>This managed application namespace is already DR protected. You may have protected this namespace while enrolling discovered applications.</0><1>To see disaster recovery information for your applications, go to<1>Protected applications</1> under <3>Disaster Recovery</3>.</1>",
-  "You have not enrolled this application yet. To protect your application,": "You have not enrolled this application yet. To protect your application,",
   "Disaster recovery policy details": "Disaster recovery policy details",
   "Name: {{name}} ({{status}})": "Name: {{name}} ({{status}})",
   "Replication policy: {{replicationType}}, {{interval}} {{unit}}": "Replication policy: {{replicationType}}, {{interval}} {{unit}}",
@@ -418,7 +431,6 @@
   "{{appName}} is now successfully enrolled for disaster recovery protection.": "{{appName}} is now successfully enrolled for disaster recovery protection.",
   "For disaster recovery or replication details about ACM managed applications navigate to Applications overview page.": "For disaster recovery or replication details about ACM managed applications navigate to Applications overview page.",
   "Overall sync status": "Overall sync status",
-  "Policy": "Policy",
   "Cluster": "Cluster",
   "Edit configuration": "Edit configuration",
   "Update existing configuration in YAML view": "Update existing configuration in YAML view",
@@ -440,6 +452,7 @@
   "PersistentVolumeClaim": "PersistentVolumeClaim",
   "Review and assign": "Review and assign",
   "Review": "Review",
+  "Data policy": "Data policy",
   "Data Services": "Data Services",
   "In use: {{targetClusters}}": "In use: {{targetClusters}}",
   "Used: {{targetClusters}}": "Used: {{targetClusters}}",
@@ -1156,13 +1169,6 @@
   "NamespaceStore details": "NamespaceStore details",
   "Target Blob Container": "Target Blob Container",
   "Num Volumes": "Num Volumes",
-  "Manage distribution of resources": "Manage distribution of resources",
-  "Storage classes": "Storage classes",
-  "Provisioner": "Provisioner",
-  "Deletion policy": "Deletion policy",
-  "VolumeSnapshot classes": "VolumeSnapshot classes",
-  "Driver": "Driver",
-  "Save changes": "Save changes",
   "SSE-C (customer keys)": "SSE-C (customer keys)",
   "SSE-S3 with KMS": "SSE-S3 with KMS",
   "SSE-S3 with KMS (Dual-layer)": "SSE-S3 with KMS (Dual-layer)",
@@ -1199,6 +1205,7 @@
   "Drag a file here, upload files, or start from scratch.": "Drag a file here, upload files, or start from scratch.",
   "Start from scratch or use predefined policy configuration": "Start from scratch or use predefined policy configuration",
   "Apply policy": "Apply policy",
+  "Save changes": "Save changes",
   "Grant Public Read Access to All Objects": "Grant Public Read Access to All Objects",
   "Allows anyone to read all objects in the bucket": "Allows anyone to read all objects in the bucket",
   "Allow Access to a Specific S3 Account": "Allow Access to a Specific S3 Account",
@@ -1526,6 +1533,12 @@
   "and": "and",
   "GiB RAM": "GiB RAM",
   "Configure Performance": "Configure Performance",
+  "Manage distribution of resources": "Manage distribution of resources",
+  "Storage classes": "Storage classes",
+  "Provisioner": "Provisioner",
+  "Deletion policy": "Deletion policy",
+  "VolumeSnapshot classes": "VolumeSnapshot classes",
+  "Driver": "Driver",
   "Cancel upload": "Cancel upload",
   "Cancel all ongoing uploads?": "Cancel all ongoing uploads?",
   "Yes, cancel": "Yes, cancel",

packages/mco/components/discovered-application-wizard/enroll-discovered-application.spec.tsx

@@ -625,7 +625,7 @@ describe('Test review step', () => {
     await waitFor(async () => {
       expect(
         JSON.stringify(drpcObj) ===
-          '{"apiVersion":"ramendr.openshift.io/v1alpha1","kind":"DRPlacementControl","metadata":{"name":"my-name","namespace":"openshift-dr-ops"},"spec":{"preferredCluster":"east-1","protectedNamespaces":["namespace-1","namespace-2"],"pvcSelector":{},"kubeObjectProtection":{"captureInterval":"5m","recipeRef":{"name":"mock-recipe-1","namespace":"namespace-1"}},"drPolicyRef":{"name":"mock-policy-1","apiVersion":"ramendr.openshift.io/v1alpha1","kind":"DRPolicy"},"placementRef":{"name":"my-name-placement-1","namespace":"openshift-dr-ops","apiVersion":"cluster.open-cluster-management.io/v1beta1","kind":"Placement"}}}'
+          '{"apiVersion":"ramendr.openshift.io/v1alpha1","kind":"DRPlacementControl","metadata":{"name":"my-name","namespace":"openshift-dr-ops"},"spec":{"preferredCluster":"east-1","protectedNamespaces":["namespace-1","namespace-2"],"pvcSelector":{},"kubeObjectProtection":{"captureInterval":"5m","recipeRef":{"name":"mock-recipe-1","namespace":"namespace-1"},"recipeParameters":{}},"drPolicyRef":{"name":"mock-policy-1","apiVersion":"ramendr.openshift.io/v1alpha1","kind":"DRPolicy"},"placementRef":{"name":"my-name-placement-1","namespace":"openshift-dr-ops","apiVersion":"cluster.open-cluster-management.io/v1beta1","kind":"Placement"}}}'
       ).toBeTruthy();
     });
   });

packages/mco/components/discovered-application-wizard/utils/k8s-utils.ts

@@ -7,16 +7,13 @@ import {
   DISCOVERED_APP_NS,
   PROTECTED_APP_ANNOTATION,
 } from '@odf/mco/constants';
-import {
-  ACMPlacementKind,
-  DRPlacementControlKind,
-  DRPolicyKind,
-} from '@odf/mco/types';
+import { ACMPlacementKind, DRPlacementControlKind } from '@odf/mco/types';
 import { getName } from '@odf/shared/selectors';
 import { K8sResourceKind } from '@odf/shared/types';
 import { getAPIVersionForModel } from '@odf/shared/utils';
 import {
   MatchExpression,
+  ObjectMetadata,
   k8sCreate,
 } from '@openshift-console/dynamic-plugin-sdk';
 import {
@@ -29,19 +26,22 @@ export const getDRPCKindObj = (props: {
   preferredCluster: string;
   namespaces: string[];
   protectionMethod: ProtectionMethodType;
-  drPolicy: DRPolicyKind;
+  drPolicyName: string;
   k8sResourceReplicationInterval: string;
   recipeName?: string;
   recipeNamespace?: string;
   k8sResourceLabelExpressions?: MatchExpression[];
   pvcLabelExpressions?: MatchExpression[];
   placementName: string;
+  recipeParameters?: Record<string, string[]>;
+  labels?: ObjectMetadata['labels'];
 }): DRPlacementControlKind => ({
   apiVersion: getAPIVersionForModel(DRPlacementControlModel),
   kind: DRPlacementControlModel.kind,
   metadata: {
     name: props.name,
     namespace: DISCOVERED_APP_NS,
+    labels: props.labels ?? {},
   },
   spec: {
     preferredCluster: props.preferredCluster,
@@ -59,6 +59,7 @@ export const getDRPCKindObj = (props: {
               name: props.recipeName,
               namespace: props.recipeNamespace,
             },
+            recipeParameters: props.recipeParameters ?? {},
           }
         : {
             kubeObjectSelector: {
@@ -67,7 +68,7 @@ export const getDRPCKindObj = (props: {
           }),
     },
     drPolicyRef: {
-      name: getName(props.drPolicy),
+      name: props.drPolicyName,
       apiVersion: getAPIVersionForModel(DRPolicyModel),
       kind: DRPolicyModel.kind,
     },
@@ -81,7 +82,9 @@ export const getDRPCKindObj = (props: {
 });
 
 // Dummy placement for the discovered apps DRPC
-const getPlacementKindObj = (placementName: string): ACMPlacementKind => ({
+export const getPlacementKindObj = (
+  placementName: string
+): ACMPlacementKind => ({
   apiVersion: getAPIVersionForModel(ACMPlacementModel),
   kind: ACMPlacementModel.kind,
   metadata: {
@@ -130,7 +133,7 @@ export const createPromise = (
         recipeNamespace,
         k8sResourceLabelExpressions,
         pvcLabelExpressions,
-        drPolicy,
+        drPolicyName: getName(drPolicy),
         k8sResourceReplicationInterval,
         placementName,
       }),

packages/mco/components/discovered-application-wizard/wizard-steps/replication-step/replication-selection-helper.tsx

@@ -0,0 +1,190 @@
+import * as React from 'react';
+import {
+  MIN_VALUE,
+  normalizeSyncTimeValue,
+} from '@odf/mco/components/create-dr-policy/select-replication-type';
+import {
+  REPLICATION_DISPLAY_TEXT,
+  SYNC_SCHEDULE_DISPLAY_TEXT,
+} from '@odf/mco/constants';
+import { getDRPolicyStatus, parseSyncInterval } from '@odf/mco/utils';
+import { SingleSelectDropdown } from '@odf/shared/dropdown';
+import { FieldLevelHelp } from '@odf/shared/generic';
+import { useCustomTranslation } from '@odf/shared/useCustomTranslationHook';
+import { getValidatedProp } from '@odf/shared/utils';
+import { RequestSizeInput } from '@odf/shared/utils/RequestSizeInput';
+import { SelectOption } from '@patternfly/react-core/deprecated';
+import * as _ from 'lodash-es';
+import { TFunction } from 'react-i18next';
+import {
+  Form,
+  FormGroup,
+  FormHelperText,
+  FormSection,
+  HelperText,
+  HelperTextItem,
+  Text,
+  TextVariants,
+} from '@patternfly/react-core';
+
+// Get Policy Dropdown Options
+const getPolicyOptions = (policies: PolicyInfo[], t: TFunction) =>
+  policies.map((policy) => (
+    <SelectOption
+      key={policy.name}
+      value={policy.name}
+      description={
+        policy.schedulingInterval !== '0m'
+          ? t(
+              'Replication type: {{type}}, Interval: {{interval}}, Clusters: {{clusters}}',
+              {
+                type: REPLICATION_DISPLAY_TEXT(t).async,
+                interval: policy.schedulingInterval,
+                clusters: policy.drClusters.join(', '),
+              }
+            )
+          : t('Replication type: {{type}}, Clusters: {{clusters}}', {
+              type: REPLICATION_DISPLAY_TEXT(t).sync,
+              clusters: policy.drClusters.join(', '),
+            })
+      }
+    />
+  ));
+
+// Policy Selection Component
+const PolicySelection: React.FC<PolicySelectionProps> = ({
+  policy,
+  eligiblePolicies,
+  isValidationEnabled,
+  onChange,
+}) => {
+  const { t } = useCustomTranslation();
+  const translatedPolicyStatus = t('Status: {{status}}', {
+    status: getDRPolicyStatus(policy?.isValidated, t),
+  });
+
+  const policyValidated = getValidatedProp(
+    (isValidationEnabled && _.isEmpty(policy)) || !eligiblePolicies.length
+  );
+
+  const helperTextInvalid = !eligiblePolicies.length
+    ? t('No policy found')
+    : t('Required');
+  const helperText = !_.isEmpty(policy) && translatedPolicyStatus;
+
+  return (
+    <FormGroup
+      className="pf-v5-u-w-50"
+      fieldId="dr-policy-selection"
+      label={t('Disaster recovery policy')}
+      labelIcon={
+        <FieldLevelHelp>
+          {t('The policy sync interval is only applicable to volumes.')}
+        </FieldLevelHelp>
+      }
+      isRequired
+    >
+      <SingleSelectDropdown
+        id="dr-policy-dropdown"
+        placeholderText={t('Select a policy')}
+        selectedKey={policy?.name}
+        selectOptions={getPolicyOptions(eligiblePolicies, t)}
+        onChange={onChange}
+        validated={policyValidated}
+        isDisabled={!eligiblePolicies.length}
+      />
+      <FormHelperText>
+        <HelperText>
+          <HelperTextItem variant={policyValidated}>
+            {policyValidated === 'error' ? helperTextInvalid : helperText}
+          </HelperTextItem>
+        </HelperText>
+      </FormHelperText>
+    </FormGroup>
+  );
+};
+
+// Replication Selection Component
+export const ReplicationSelectionHelper: React.FC<
+  ReplicationSelectionHelperProps
+> = ({
+  eligiblePolicies,
+  policy,
+  k8sResourceReplicationInterval,
+  isValidationEnabled,
+  onK8sSyncIntervalChange,
+  onPolicyChange,
+}) => {
+  const { t } = useCustomTranslation();
+  const SyncScheduleFormat = SYNC_SCHEDULE_DISPLAY_TEXT(t);
+  const [unitVal, interval] = parseSyncInterval(k8sResourceReplicationInterval);
+
+  const setInterval = (props: { value: number; unit: string }) => {
+    onK8sSyncIntervalChange(
+      `${normalizeSyncTimeValue(props.value)}${props.unit}`
+    );
+  };
+
+  return (
+    <Form maxWidth="58rem">
+      <FormSection title={t('Volume and Kubernetes object replication')}>
+        <Text component={TextVariants.small}>
+          {t(
+            'Define where to sync or replicate your application volumes and Kubernetes object using a disaster recovery policy.'
+          )}
+        </Text>
+        <PolicySelection
+          policy={policy}
+          eligiblePolicies={eligiblePolicies}
+          isValidationEnabled={isValidationEnabled}
+          onChange={onPolicyChange}
+        />
+        <FormGroup
+          fieldId="k8s-resource-interval-selection"
+          label={t('Kubernetes object replication interval')}
+        >
+          <FormHelperText>
+            <HelperText>
+              <HelperTextItem>
+                {t('Define the interval for Kubernetes object replication')}
+              </HelperTextItem>
+            </HelperText>
+          </FormHelperText>
+          <RequestSizeInput
+            name={t('Replication interval')}
+            onChange={setInterval}
+            dropdownUnits={SyncScheduleFormat}
+            defaultRequestSizeUnit={unitVal}
+            defaultRequestSizeValue={interval.toString()}
+            minValue={MIN_VALUE}
+          />
+        </FormGroup>
+      </FormSection>
+    </Form>
+  );
+};
+
+// Common Policy Type
+export type PolicyInfo = {
+  name: string;
+  drClusters: string[];
+  schedulingInterval: string;
+  isValidated: boolean;
+};
+
+// Props
+type ReplicationSelectionHelperProps = {
+  eligiblePolicies: PolicyInfo[];
+  policy: PolicyInfo;
+  k8sResourceReplicationInterval: string;
+  isValidationEnabled: boolean;
+  onPolicyChange: (policyName: string) => void;
+  onK8sSyncIntervalChange: (syncInterval: string) => void;
+};
+
+type PolicySelectionProps = {
+  policy: PolicyInfo;
+  eligiblePolicies: PolicyInfo[];
+  isValidationEnabled: boolean;
+  onChange: (policyName: string) => void;
+};

packages/mco/components/discovered-application-wizard/wizard-steps/replication-step/replication-step.tsx

@@ -1,216 +1,87 @@
 import * as React from 'react';
-import {
-  MIN_VALUE,
-  normalizeSyncTimeValue,
-} from '@odf/mco/components/create-dr-policy/select-replication-type';
-import {
-  REPLICATION_DISPLAY_TEXT,
-  SYNC_SCHEDULE_DISPLAY_TEXT,
-} from '@odf/mco/constants';
 import { DRPolicyModel } from '@odf/mco/models';
 import { DRPolicyKind } from '@odf/mco/types';
-import {
-  getDRPolicyStatus,
-  isDRPolicyValidated,
-  parseSyncInterval,
-} from '@odf/mco/utils';
-import { SingleSelectDropdown } from '@odf/shared/dropdown';
-import { FieldLevelHelp, StatusBox } from '@odf/shared/generic';
+import { isDRPolicyValidated } from '@odf/mco/utils';
+import { StatusBox } from '@odf/shared/generic/status-box';
 import { useK8sList } from '@odf/shared/hooks';
 import { getName } from '@odf/shared/selectors';
-import { useCustomTranslation } from '@odf/shared/useCustomTranslationHook';
-import { getValidatedProp } from '@odf/shared/utils';
-import { RequestSizeInput } from '@odf/shared/utils/RequestSizeInput';
-import { SelectOption } from '@patternfly/react-core/deprecated';
 import * as _ from 'lodash-es';
-import { TFunction } from 'react-i18next';
-import {
-  Form,
-  FormGroup,
-  FormHelperText,
-  FormSection,
-  HelperText,
-  HelperTextItem,
-  Text,
-  TextVariants,
-} from '@patternfly/react-core';
 import {
   EnrollDiscoveredApplicationAction,
   EnrollDiscoveredApplicationState,
   EnrollDiscoveredApplicationStateType,
 } from '../../utils/reducer';
 import { findAllEligiblePolicies } from '../namespace-step/namespace-table';
-import '../../enroll-discovered-application.scss';
-
-const getPolicyOptions = (dataPolicies: DRPolicyKind[], t: TFunction) =>
-  dataPolicies.map((policy) => (
-    <SelectOption
-      key={getName(policy)}
-      value={getName(policy)}
-      description={
-        policy.spec.schedulingInterval !== '0m'
-          ? t(
-              'Replication type: {{type}}, Interval: {{interval}}, Clusters: {{clusters}}',
-              {
-                type: REPLICATION_DISPLAY_TEXT(t).async,
-                interval: policy.spec.schedulingInterval,
-                clusters: policy.spec.drClusters.join(', '),
-              }
-            )
-          : t('Replication type: {{type}}, Clusters: {{clusters}}', {
-              type: REPLICATION_DISPLAY_TEXT(t).sync,
-              clusters: policy.spec.drClusters.join(', '),
-            })
+import {
+  PolicyInfo,
+  ReplicationSelectionHelper,
+} from './replication-selection-helper';
+
+// Convert DRPolicyKind to PolicyInfo
+const convertToPolicyInfo = (policy?: DRPolicyKind): PolicyInfo =>
+  !_.isEmpty(policy)
+    ? {
+        name: getName(policy),
+        drClusters: policy?.spec?.drClusters || [],
+        schedulingInterval: policy?.spec?.schedulingInterval || '0m',
+        isValidated: isDRPolicyValidated(policy),
       }
-    />
-  ));
+    : ({} as PolicyInfo);
 
-const PolicySelection: React.FC<PolicySelectionProps> = ({
-  policy,
-  clusterName,
+export const ReplicationSelection: React.FC<ReplicationSelectionProps> = ({
+  state,
   isValidationEnabled,
   dispatch,
 }) => {
-  const { t } = useCustomTranslation();
+  const { clusterName } = state.namespace;
+  const { drPolicy, k8sResourceReplicationInterval } = state.replication;
 
   const [drPolicies, loaded, loadError] =
     useK8sList<DRPolicyKind>(DRPolicyModel);
 
-  // Filteting policy using cluster name
-  const eligiblePolicies = findAllEligiblePolicies(
-    clusterName,
-    drPolicies || []
-  );
-
-  // Validated/Not Validated
-  const translatedPolicyStatus = t('Status: {{status}}', {
-    status: getDRPolicyStatus(isDRPolicyValidated(policy), t),
-  });
+  // Filtering policies using cluster name
+  const eligiblePolicies = React.useMemo(() => {
+    if (loaded && !loadError) {
+      return findAllEligiblePolicies(clusterName, drPolicies);
+    }
+    return [];
+  }, [clusterName, drPolicies, loaded, loadError]);
 
-  const policyValidated = getValidatedProp(
-    (isValidationEnabled && _.isEmpty(policy)) || !eligiblePolicies.length
-  );
+  // Convert all policies to PolicyInfo before filtering
+  const convertedPolicies = eligiblePolicies.map(convertToPolicyInfo);
 
-  const helperTextInvalid = !eligiblePolicies.length
-    ? t('No policy found')
-    : t('Required');
-  const helperText = !_.isEmpty(policy) && translatedPolicyStatus;
+  const setK8sSyncInterval = (syncInterval: string) => {
+    dispatch({
+      type: EnrollDiscoveredApplicationStateType.SET_K8S_RESOURCE_REPLICATION_INTERVAL,
+      payload: syncInterval,
+    });
+  };
 
   const setSelectedPolicy = (policyName: string) => {
     dispatch({
       type: EnrollDiscoveredApplicationStateType.SET_POLICY,
-      payload: eligiblePolicies.find(
+      payload: drPolicies.find(
         (currPolicy) => getName(currPolicy) === policyName
       ),
     });
   };
 
   return loaded && !loadError ? (
-    <FormGroup
-      className="pf-v5-u-w-50"
-      fieldId="dr-policy-selection"
-      label={t('Disaster recovery policy')}
-      labelIcon={
-        <FieldLevelHelp>
-          {t('The policy sync interval is only applicable to volumes.')}
-        </FieldLevelHelp>
-      }
-      isRequired
-    >
-      <SingleSelectDropdown
-        id="dr-policy-dropdown"
-        placeholderText={t('Select a policy')}
-        selectedKey={getName(policy)}
-        selectOptions={getPolicyOptions(eligiblePolicies, t)}
-        onChange={setSelectedPolicy}
-        validated={policyValidated}
-        isDisabled={!eligiblePolicies.length}
-      />
-      <FormHelperText>
-        <HelperText>
-          <HelperTextItem variant={policyValidated}>
-            {policyValidated === 'error' ? helperTextInvalid : helperText}
-          </HelperTextItem>
-        </HelperText>
-      </FormHelperText>
-    </FormGroup>
+    <ReplicationSelectionHelper
+      policy={convertToPolicyInfo(drPolicy)}
+      eligiblePolicies={convertedPolicies}
+      k8sResourceReplicationInterval={k8sResourceReplicationInterval}
+      isValidationEnabled={isValidationEnabled}
+      onK8sSyncIntervalChange={setK8sSyncInterval}
+      onPolicyChange={setSelectedPolicy}
+    />
   ) : (
     <StatusBox loaded={loaded} loadError={loadError} />
   );
 };
 
-export const ReplicationSelection: React.FC<ReplicationSelectionProps> = ({
-  state,
-  isValidationEnabled,
-  dispatch,
-}) => {
-  const { t } = useCustomTranslation();
-
-  const { clusterName } = state.namespace;
-  const {
-    drPolicy: policy,
-    k8sResourceReplicationInterval: replicationInterval,
-  } = state.replication;
-
-  const SyncScheduleFormat = SYNC_SCHEDULE_DISPLAY_TEXT(t);
-  const [unitVal, interval] = parseSyncInterval(replicationInterval);
-
-  const setInterval = (props: { value: number; unit: string }) => {
-    const { value, unit } = props;
-    dispatch({
-      type: EnrollDiscoveredApplicationStateType.SET_K8S_RESOURCE_REPLICATION_INTERVAL,
-      payload: `${normalizeSyncTimeValue(value)}${unit}`,
-    });
-  };
-
-  return (
-    <Form maxWidth="58rem">
-      <FormSection title={t('Volume and Kubernetes object replication')}>
-        <Text component={TextVariants.small}>
-          {t(
-            'Define where to sync or replicate your application volumes and Kubernetes object using a disaster recovery policy.'
-          )}
-        </Text>
-        <PolicySelection
-          policy={policy}
-          clusterName={clusterName}
-          isValidationEnabled={isValidationEnabled}
-          dispatch={dispatch}
-        />
-        <FormGroup
-          fieldId="k8s-resource-interval-selection"
-          label={t('Kubernetes object replication interval')}
-        >
-          <FormHelperText>
-            <HelperText>
-              <HelperTextItem>
-                {t('Define the interval for Kubernetes object replication')}
-              </HelperTextItem>
-            </HelperText>
-          </FormHelperText>
-          <RequestSizeInput
-            name={t('Replication interval')}
-            onChange={setInterval}
-            dropdownUnits={SyncScheduleFormat}
-            defaultRequestSizeUnit={unitVal}
-            defaultRequestSizeValue={interval.toString()}
-            minValue={MIN_VALUE}
-          />
-        </FormGroup>
-      </FormSection>
-    </Form>
-  );
-};
-
 type ReplicationSelectionProps = {
   state: EnrollDiscoveredApplicationState;
   isValidationEnabled: boolean;
   dispatch: React.Dispatch<EnrollDiscoveredApplicationAction>;
 };
-
-type PolicySelectionProps = {
-  policy: DRPolicyKind;
-  clusterName: string;
-  isValidationEnabled: boolean;
-  dispatch: React.Dispatch<EnrollDiscoveredApplicationAction>;
-};

packages/mco/components/modals/app-manage-policies/app-manage-policies-modal-body.tsx

@@ -16,20 +16,22 @@ const ComponentMap = {
   [referenceForModel(VirtualMachineModel)]: VirtualMachineParser,
 };
 
-export const AppManagePoliciesModalBody: React.FC<
-  AppManagePoliciesModalBodyProps
-> = ({ application, cluster, setCurrentModalContext }) => {
-  const gvk = getGVKofResource(application);
-  const SelectedComponent = ComponentMap[gvk];
+// Memoizing the component to prevent unnecessary re-renders.
+// Problem: Without React.memo, the component re-renders even if props haven't changed.
+// Fix: React.memo ensures the component only re-renders when `application`, `cluster`, or `setCurrentModalContext` changes.
+export const AppManagePoliciesModalBody: React.FC<AppManagePoliciesModalBodyProps> =
+  React.memo(({ application, cluster, setCurrentModalContext }) => {
+    const gvk = getGVKofResource(application);
+    const SelectedComponent = ComponentMap[gvk];
 
-  return SelectedComponent ? (
-    <SelectedComponent
-      application={application as any}
-      cluster={cluster}
-      setCurrentModalContext={setCurrentModalContext}
-    />
-  ) : null;
-};
+    return SelectedComponent ? (
+      <SelectedComponent
+        application={application as any}
+        cluster={cluster}
+        setCurrentModalContext={setCurrentModalContext}
+      />
+    ) : null;
+  });
 
 type AppManagePoliciesModalBodyProps = {
   application: K8sResourceCommon;

packages/mco/components/modals/app-manage-policies/app-manage-policies-modal.tsx

@@ -1,4 +1,5 @@
 import * as React from 'react';
+import { VirtualMachineModel } from '@odf/mco/models';
 import { SearchResultItemType } from '@odf/mco/types';
 import { convertSearchResult } from '@odf/mco/utils';
 import { getName, getNamespace } from '@odf/shared/selectors';
@@ -16,19 +17,35 @@ export const AppManagePoliciesModal: React.FC<AppManagePoliciesModalProps> = ({
   close,
 }) => {
   const { t } = useCustomTranslation();
-  const [currentModalContext, setCurrentModalContext] = React.useState(
+  const [currentModalContext, setModalContext] = React.useState(
     ModalViewContext.MANAGE_POLICY_VIEW
   );
 
-  const application =
-    'apigroup' in resource ? convertSearchResult(resource) : resource;
+  // Problem: Without useCallback, the function reference changes on each render,
+  // causing child components to re-render unnecessarily.
+  // Fix: useCallback ensures the function has a stable reference.
+  const setCurrentModalContext = React.useCallback(
+    (context: ModalViewContext) => setModalContext(context),
+    []
+  );
+
+  // Problem: Parsing runs on every render, even if the resource didn't change.
+  // This causes performance issues and unnecessary recalculations.
+  // Fix: useMemo ensures parsing only happens when 'resource' changes.
+  const application = React.useMemo(
+    () => ('apigroup' in resource ? convertSearchResult(resource) : resource),
+    [resource]
+  );
+
   const applicationName = getName(application) ?? application?.['name'];
   const applicationNamespace =
     getNamespace(application) ?? application?.['namespace'];
 
   const title =
     currentModalContext === ModalViewContext.ASSIGN_POLICY_VIEW
-      ? t('Enroll managed application')
+      ? application.kind === VirtualMachineModel.kind
+        ? t('Enroll virtual machine')
+        : t('Enroll managed application')
       : t('Manage disaster recovery');
 
   const description = (

packages/mco/components/modals/app-manage-policies/assign-policy-view.tsx

@@ -1,8 +1,8 @@
 import * as React from 'react';
 import {
-  DRApplication,
   AssignPolicySteps,
   AssignPolicyStepsNames,
+  DRApplication,
 } from '@odf/mco/constants';
 import { ModalBody } from '@odf/shared/modals';
 import { getName } from '@odf/shared/selectors';
@@ -11,7 +11,9 @@ import { getErrorMessage } from '@odf/shared/utils';
 import { Wizard, WizardStep } from '@patternfly/react-core/deprecated';
 import { TFunction } from 'react-i18next';
 import { AssignPolicyViewFooter } from './helper/assign-policy-view-footer';
+import ProtectionTypeWizardContent from './helper/protection-type-wizard-content';
 import { PVCDetailsWizardContent } from './helper/pvc-details-wizard-content';
+import { ReplicationTypeWizardContent } from './helper/replication-wizard-content';
 import { ReviewAndAssign } from './helper/review-and-assign';
 import { SelectPolicyWizardContent } from './helper/select-policy-wizard-content';
 import { assignPromises } from './utils/k8s-utils';
@@ -27,6 +29,7 @@ import {
   ApplicationType,
   DRInfoType,
   DRPolicyType,
+  ModalType,
   PlacementType,
   PVCQueryFilter,
 } from './utils/types';
@@ -42,6 +45,7 @@ export const createSteps = (
   dispatch: React.Dispatch<ManagePolicyStateAction>,
   protectedPVCSelectors: PVCSelectorType[],
   pvcQueryFilter: PVCQueryFilter,
+  modalType: ModalType,
   isEditMode?: boolean
 ): WizardStep[] => {
   const commonSteps = {
@@ -71,13 +75,44 @@ export const createSteps = (
     },
     reviewAndAssign: {
       name: AssignPolicyStepsNames(t)[AssignPolicySteps.ReviewAndAssign],
-      component: <ReviewAndAssign state={state} />,
+      component: (
+        <ReviewAndAssign
+          state={state}
+          modalType={modalType}
+          appType={appType}
+        />
+      ),
     },
   };
 
-  switch (appType) {
-    case DRApplication.APPSET:
-    case DRApplication.SUBSCRIPTION:
+  const vmSteps = {
+    protectionType: {
+      name: AssignPolicyStepsNames(t)[AssignPolicySteps.ProtectionType],
+      component: (
+        <ProtectionTypeWizardContent
+          protectionType={state.protectionType.protectionType}
+          protectionName={state.protectionType.protectionName}
+          appType={appType}
+          dispatch={dispatch}
+        />
+      ),
+    },
+    replication: {
+      name: AssignPolicyStepsNames(t)[AssignPolicySteps.Replication],
+      component: (
+        <ReplicationTypeWizardContent
+          matchingPolicies={matchingPolicies}
+          policy={state.replication.policy}
+          k8sResourceSyncInterval={state.replication.k8sSyncInterval}
+          isValidationEnabled={isValidationEnabled}
+          dispatch={dispatch}
+        />
+      ),
+    },
+  };
+
+  switch (modalType) {
+    case ModalType.Application:
       return isEditMode
         ? [
             {
@@ -108,6 +143,47 @@ export const createSteps = (
               canJumpTo: stepIdReached >= 3,
             },
           ];
+    case ModalType.VirtualMachine:
+      return appType === DRApplication.DISCOVERED
+        ? [
+            {
+              id: 1,
+              ...vmSteps.protectionType,
+              canJumpTo: stepIdReached >= 1,
+            },
+            {
+              id: 2,
+              ...vmSteps.replication,
+              canJumpTo: stepIdReached >= 2,
+            },
+            {
+              id: 3,
+              ...commonSteps.reviewAndAssign,
+              canJumpTo: stepIdReached >= 3,
+            },
+          ]
+        : [
+            {
+              id: 1,
+              ...vmSteps.protectionType,
+              canJumpTo: stepIdReached >= 1,
+            },
+            {
+              id: 2,
+              ...commonSteps.policy,
+              canJumpTo: stepIdReached >= 2,
+            },
+            {
+              id: 3,
+              ...commonSteps.persistentVolumeClaim,
+              canJumpTo: stepIdReached >= 3,
+            },
+            {
+              id: 4,
+              ...commonSteps.reviewAndAssign,
+              canJumpTo: stepIdReached >= 4,
+            },
+          ];
     default:
       return [];
   }
@@ -121,6 +197,7 @@ export const AssignPolicyView: React.FC<AssignPolicyViewProps> = ({
   setModalContext,
   setModalActionContext,
   dispatch,
+  modalType,
 }) => {
   const { t } = useCustomTranslation();
   const isEditMode =
@@ -134,6 +211,7 @@ export const AssignPolicyView: React.FC<AssignPolicyViewProps> = ({
     placements: unProtectedPlacements,
     drInfo,
     pvcQueryFilter,
+    workloadNamespace,
   } = applicationInfo;
 
   const protectedPVCSelectors: PVCSelectorType[] = isEditMode
@@ -151,7 +229,13 @@ export const AssignPolicyView: React.FC<AssignPolicyViewProps> = ({
 
   const onSubmit = async () => {
     // assign DRPolicy
-    const promises = assignPromises(state, applicationInfo.placements);
+    const promises = assignPromises(
+      state,
+      applicationInfo.placements,
+      appType,
+      workloadNamespace,
+      getName(applicationInfo)
+    );
     await Promise.all(promises)
       .then(() => {
         setModalActionContext(
@@ -189,6 +273,7 @@ export const AssignPolicyView: React.FC<AssignPolicyViewProps> = ({
           dispatch,
           protectedPVCSelectors,
           pvcQueryFilter,
+          modalType,
           isEditMode
         )}
         footer={
@@ -198,7 +283,6 @@ export const AssignPolicyView: React.FC<AssignPolicyViewProps> = ({
             stepIdReached={stepIdReached}
             isValidationEnabled={isValidationEnabled}
             errorMessage={errorMessage}
-            modalActionContext={modalActionContext}
             setStepIdReached={setStepIdReached}
             onSubmit={onSubmit}
             onCancel={onClose}
@@ -222,4 +306,5 @@ type AssignPolicyViewProps = {
     modalActionContext: ModalActionContext,
     modalViewContext?: ModalViewContext
   ) => void;
+  modalType: ModalType;
 };

packages/mco/components/modals/app-manage-policies/helper/assign-policy-view-footer.tsx

@@ -13,18 +13,15 @@ import {
   WizardContext,
   WizardFooter,
 } from '@patternfly/react-core/deprecated';
+import * as _ from 'lodash-es';
 import { TFunction } from 'react-i18next';
 import {
   Button,
   Alert,
   AlertVariant,
   AlertProps,
 } from '@patternfly/react-core';
-import {
-  AssignPolicyViewState,
-  ModalActionContext,
-  PVCSelectorType,
-} from '../utils/reducer';
+import { AssignPolicyViewState, PVCSelectorType } from '../utils/reducer';
 import { DRPolicyType } from '../utils/types';
 import '../../../../style.scss';
 import '../style.scss';
@@ -57,16 +54,40 @@ const isPVCSelectorFound = (pvcSelectors: PVCSelectorType[]) =>
 
 const isDRPolicySelected = (dataPolicy: DRPolicyType) => !!getName(dataPolicy);
 
+const validateReplicationStep = (
+  policy: DRPolicyType,
+  k8sSyncInterval: string
+) =>
+  !_.isEmpty(policy) &&
+  k8sSyncInterval !== undefined &&
+  k8sSyncInterval !== '0m';
+
+const validateProtectionTypeStep = (
+  protectionName: string,
+  appType: DRApplication
+) => appType !== DRApplication.DISCOVERED || !!protectionName;
+
 const canJumpToNextStep = (
   stepName: string,
   state: AssignPolicyViewState,
+  appType: DRApplication,
   t: TFunction
 ) => {
   switch (stepName) {
     case AssignPolicyStepsNames(t)[AssignPolicySteps.Policy]:
       return isDRPolicySelected(state.policy);
     case AssignPolicyStepsNames(t)[AssignPolicySteps.PersistentVolumeClaim]:
       return isPVCSelectorFound(state.persistentVolumeClaim.pvcSelectors);
+    case AssignPolicyStepsNames(t)[AssignPolicySteps.ProtectionType]:
+      return validateProtectionTypeStep(
+        state.protectionType.protectionName,
+        appType
+      );
+    case AssignPolicyStepsNames(t)[AssignPolicySteps.Replication]:
+      return validateReplicationStep(
+        state.replication.policy,
+        state.replication.k8sSyncInterval
+      );
     default:
       return false;
   }
@@ -113,10 +134,10 @@ const getErrorMessage = (
 
 export const AssignPolicyViewFooter: React.FC<AssignPolicyViewFooterProps> = ({
   state,
+  appType,
   stepIdReached,
   isValidationEnabled,
   errorMessage,
-  modalActionContext,
   setStepIdReached,
   onSubmit,
   onCancel,
@@ -130,7 +151,7 @@ export const AssignPolicyViewFooter: React.FC<AssignPolicyViewFooterProps> = ({
   const stepId = activeStep.id as number;
   const stepName = activeStep.name as string;
 
-  const canJumpToNext = canJumpToNextStep(stepName, state, t);
+  const canJumpToNext = canJumpToNextStep(stepName, state, appType, t);
   const validationError = isValidationEnabled && !canJumpToNext;
   const message =
     (validationError || !!errorMessage) &&
@@ -175,15 +196,7 @@ export const AssignPolicyViewFooter: React.FC<AssignPolicyViewFooterProps> = ({
         <Button
           variant="secondary"
           onClick={onBack}
-          isDisabled={
-            stepName === AssignPolicyStepsNames(t)[AssignPolicySteps.Policy] ||
-            requestInProgress ||
-            (stepName ===
-              AssignPolicyStepsNames(t)[
-                AssignPolicySteps.PersistentVolumeClaim
-              ] &&
-              modalActionContext === ModalActionContext.EDIT_DR_PROTECTION)
-          }
+          isDisabled={stepId === 1 || requestInProgress}
         >
           {t('Back')}
         </Button>
@@ -217,7 +230,6 @@ type AssignPolicyViewFooterProps = {
   stepIdReached: number;
   isValidationEnabled: boolean;
   errorMessage: string;
-  modalActionContext: ModalActionContext;
   setStepIdReached: React.Dispatch<React.SetStateAction<number>>;
   onSubmit: () => Promise<void>;
   onCancel: () => void;

packages/mco/components/modals/app-manage-policies/helper/protection-type-wizard-content.tsx

@@ -0,0 +1,188 @@
+import * as React from 'react';
+import { DISCOVERED_APP_NS, DRApplication } from '@odf/mco/constants';
+import { getDRPlacementControlResourceObj } from '@odf/mco/hooks';
+import { DRPlacementControlKind } from '@odf/mco/types';
+import { getName, StatusBox, useCustomTranslation } from '@odf/shared';
+import NameInput from '@odf/shared/input-with-requirements/nameInputWithValidation';
+import { useK8sWatchResource } from '@openshift-console/dynamic-plugin-sdk';
+import { TFunction } from 'react-i18next';
+import {
+  Alert,
+  AlertVariant,
+  Form,
+  FormGroup,
+  FormHelperText,
+  HelperText,
+  HelperTextItem,
+  Radio,
+} from '@patternfly/react-core';
+import {
+  ManagePolicyStateAction,
+  ManagePolicyStateType,
+  ModalViewContext,
+} from '../utils/reducer';
+import { VMProtectioType } from '../utils/types';
+
+const RADIO_GROUP_NAME = 'vm_protection_method';
+
+const ProtectionNameInput: React.FC<ProtectionNameInputProps> = ({
+  vmProtectionName,
+  dispatch,
+}) => {
+  const { t } = useCustomTranslation();
+  const [drpcs, drpcsLoaded, drpcsLoadError] = useK8sWatchResource<
+    DRPlacementControlKind[]
+  >(
+    getDRPlacementControlResourceObj({
+      namespace: DISCOVERED_APP_NS,
+    })
+  );
+
+  const existingProtectionNames = React.useMemo(() => {
+    // Ensure drpcs is loaded and valid before processing
+    if (!drpcsLoaded || drpcsLoadError) return [];
+
+    return drpcs.map(getName);
+  }, [drpcs, drpcsLoaded, drpcsLoadError]);
+
+  const setProtectionName = (newName: string) => {
+    dispatch({
+      type: ManagePolicyStateType.SET_VM_PROTECTION_NAME,
+      context: ModalViewContext.ASSIGN_POLICY_VIEW,
+      payload: newName,
+    });
+  };
+
+  return drpcsLoaded && !drpcsLoadError ? (
+    <NameInput
+      label={t('Protection name')}
+      helperText={t('A unique name to identify and manage this protection.')}
+      name={vmProtectionName}
+      existingNames={existingProtectionNames}
+      onChange={setProtectionName}
+    />
+  ) : (
+    <StatusBox loaded={drpcsLoaded} loadError={drpcsLoadError} />
+  );
+};
+
+const getRadioOptions = (
+  isDiscoveredApp: boolean,
+  protectionName: string,
+  dispatch: React.Dispatch<ManagePolicyStateAction>,
+  t: TFunction
+): RadioOption[] => {
+  const options: RadioOption[] = [
+    {
+      id: 'standalone-vm-protection',
+      value: VMProtectioType.STANDALONE,
+      description: t(
+        'Protect this VM independently without associating it with an existing DR placement control.'
+      ),
+      label: t('Standalone'),
+      isDisabled: false,
+      ...(isDiscoveredApp && {
+        componentRef: (
+          <ProtectionNameInput
+            vmProtectionName={protectionName}
+            dispatch={dispatch}
+          />
+        ),
+      }),
+    },
+    {
+      id: 'shared-vm-protection',
+      value: VMProtectioType.SHARED,
+      description: t(
+        'Add this VM to an existing DR placement control for consistent failover and recovery. This method is only available for discovered VMs.'
+      ),
+      label: t('Shared'),
+      isDisabled: !isDiscoveredApp,
+    },
+  ];
+
+  return options;
+};
+
+const ProtectionTypeWizardContent: React.FC<
+  ProtectionTypeWizardContentProps
+> = ({ protectionType, protectionName, appType, dispatch }) => {
+  const { t } = useCustomTranslation();
+
+  const isDiscoveredApp = appType === DRApplication.DISCOVERED;
+
+  const setProtectionMethod = (event: React.ChangeEvent<HTMLInputElement>) =>
+    dispatch({
+      type: ManagePolicyStateType.SET_VM_PROTECTION_METHOD,
+      context: ModalViewContext.ASSIGN_POLICY_VIEW,
+      payload: event.target.value as VMProtectioType,
+    });
+
+  const radioOptions = React.useMemo(
+    () => getRadioOptions(isDiscoveredApp, protectionName, dispatch, t),
+    [isDiscoveredApp, protectionName, dispatch, t]
+  );
+
+  return (
+    <Form>
+      <FormGroup label={t('Protection type')} fieldId="vm-protection-method">
+        <FormHelperText className="pf-v5-u-mb-sm">
+          <HelperText>
+            <HelperTextItem variant="indeterminate">
+              {t('Choose how you would like to protect this VM:')}
+            </HelperTextItem>
+          </HelperText>
+        </FormHelperText>
+
+        {radioOptions.map(
+          ({ id, value, description, label, isDisabled, componentRef }) => (
+            <Radio
+              key={id}
+              id={id}
+              name={RADIO_GROUP_NAME}
+              value={value}
+              description={description}
+              label={label}
+              onChange={setProtectionMethod}
+              isChecked={protectionType === value}
+              isDisabled={isDisabled}
+              className="pf-v5-u-mb-md"
+              body={componentRef}
+            />
+          )
+        )}
+
+        {!isDiscoveredApp && (
+          <Alert
+            title={t('Shared protection is not available for managed VMs.')}
+            variant={AlertVariant.info}
+            isInline
+          />
+        )}
+      </FormGroup>
+    </Form>
+  );
+};
+
+type ProtectionTypeWizardContentProps = {
+  protectionType: VMProtectioType;
+  protectionName: string;
+  appType: DRApplication;
+  dispatch: React.Dispatch<ManagePolicyStateAction>;
+};
+
+type RadioOption = {
+  id: string;
+  value: VMProtectioType;
+  description: string;
+  label: string;
+  isDisabled: boolean;
+  componentRef?: React.ReactNode;
+};
+
+type ProtectionNameInputProps = {
+  vmProtectionName: string;
+  dispatch: React.Dispatch<ManagePolicyStateAction>;
+};
+
+export default ProtectionTypeWizardContent;

packages/mco/components/modals/app-manage-policies/helper/replication-wizard-content.tsx

@@ -0,0 +1,73 @@
+import * as React from 'react';
+import {
+  PolicyInfo,
+  ReplicationSelectionHelper,
+} from '@odf/mco/components/discovered-application-wizard/wizard-steps/replication-step/replication-selection-helper';
+import { getName } from '@odf/shared/selectors';
+import * as _ from 'lodash-es';
+import {
+  ManagePolicyStateAction,
+  ManagePolicyStateType,
+  ModalViewContext,
+} from '../utils/reducer';
+import { DRPolicyType } from '../utils/types';
+import { findPolicy } from './select-policy-wizard-content';
+
+// Convert DRPolicyType to PolicyInfo
+const convertToPolicyInfo = (policy?: DRPolicyType): PolicyInfo =>
+  policy
+    ? {
+        name: getName(policy),
+        drClusters: policy?.drClusters || [],
+        schedulingInterval: policy?.schedulingInterval || '0m',
+        isValidated: !!policy?.isValidated,
+      }
+    : ({} as PolicyInfo);
+
+export const ReplicationTypeWizardContent: React.FC<
+  ReplicationTypeWizardContentProps
+> = ({
+  policy,
+  k8sResourceSyncInterval,
+  matchingPolicies,
+  isValidationEnabled,
+  dispatch,
+}) => {
+  // Convert all policies to PolicyInfoBase before filtering
+  const convertedPolicies = matchingPolicies.map(convertToPolicyInfo);
+
+  const setK8sSyncInterval = (syncInterval: string) => {
+    dispatch({
+      type: ManagePolicyStateType.SET_K8S_SYNC_INTERVAL,
+      context: ModalViewContext.ASSIGN_POLICY_VIEW,
+      payload: syncInterval,
+    });
+  };
+
+  const setSelectedPolicy = (policyName: string) => {
+    dispatch({
+      type: ManagePolicyStateType.SET_SELECTED_POLICY_FOR_REPLICATION,
+      context: ModalViewContext.ASSIGN_POLICY_VIEW,
+      payload: findPolicy(policyName, matchingPolicies),
+    });
+  };
+
+  return (
+    <ReplicationSelectionHelper
+      policy={convertToPolicyInfo(policy)}
+      eligiblePolicies={convertedPolicies}
+      k8sResourceReplicationInterval={k8sResourceSyncInterval}
+      isValidationEnabled={isValidationEnabled}
+      onK8sSyncIntervalChange={setK8sSyncInterval}
+      onPolicyChange={setSelectedPolicy}
+    />
+  );
+};
+
+type ReplicationTypeWizardContentProps = {
+  policy: DRPolicyType;
+  k8sResourceSyncInterval: string;
+  matchingPolicies: DRPolicyType[];
+  isValidationEnabled: boolean;
+  dispatch: React.Dispatch<ManagePolicyStateAction>;
+};

packages/mco/components/modals/app-manage-policies/helper/review-and-assign.tsx

@@ -1,5 +1,6 @@
 import * as React from 'react';
 import {
+  DRApplication,
   REPLICATION_DISPLAY_TEXT,
   SYNC_SCHEDULE_DISPLAY_TEXT,
 } from '@odf/mco/constants';
@@ -13,54 +14,143 @@ import {
 import { getName } from '@odf/shared/selectors';
 import { useCustomTranslation } from '@odf/shared/useCustomTranslationHook';
 import { AssignPolicyViewState, PVCSelectorType } from '../utils/reducer';
+import { DRPolicyType, ModalType, VMProtectioType } from '../utils/types';
 import '../style.scss';
 
 const getLabels = (pvcSelectors: PVCSelectorType[]): string[] =>
   pvcSelectors.reduce((acc, selectors) => [...acc, ...selectors.labels], []);
 
-export const ReviewAndAssign: React.FC<ReviewAndAssignProps> = ({ state }) => {
+const ProtectionTypeReview: React.FC<{
+  protectionTypeState: AssignPolicyViewState['protectionType'];
+  appType: DRApplication;
+}> = ({ protectionTypeState: { protectionName, protectionType }, appType }) => {
+  const { t } = useCustomTranslation();
+  const showProtectionName =
+    protectionType === VMProtectioType.STANDALONE &&
+    appType === DRApplication.DISCOVERED;
+  const protectionDisplayType =
+    protectionType === VMProtectioType.STANDALONE
+      ? t('Standalone')
+      : t('Shared');
+
+  return (
+    <ReviewAndCreationGroup title={t('Protection type')}>
+      <ReviewAndCreationItem label={t('Protection type:')}>
+        {protectionDisplayType}
+      </ReviewAndCreationItem>
+      {showProtectionName && (
+        <ReviewAndCreationItem label={t('Protection name:')}>
+          {protectionName}
+        </ReviewAndCreationItem>
+      )}
+    </ReviewAndCreationGroup>
+  );
+};
+
+const ReplicationReview: React.FC<{
+  replication: AssignPolicyViewState['replication'];
+}> = ({ replication: { policy, k8sSyncInterval } }) => {
+  const { t } = useCustomTranslation();
+  const replicationType =
+    policy.schedulingInterval === '0m'
+      ? REPLICATION_DISPLAY_TEXT(t).sync
+      : REPLICATION_DISPLAY_TEXT(t).async;
+  const [unitVal, interval] = parseSyncInterval(k8sSyncInterval);
+
+  return (
+    <ReviewAndCreationGroup title={t('Replication')}>
+      <>
+        <ReviewAndCreationItem label={t('Volume replication:')}>
+          {t('{{policyName}}, {{replicationType}}, Interval: {{interval}}', {
+            policyName: getName(policy),
+            replicationType,
+            interval: policy.schedulingInterval,
+          })}
+        </ReviewAndCreationItem>
+        <ReviewAndCreationItem label={t('Kubernetes object replication:')}>
+          {`${interval} ${SYNC_SCHEDULE_DISPLAY_TEXT(t)[unitVal]}`}
+        </ReviewAndCreationItem>
+      </>
+    </ReviewAndCreationGroup>
+  );
+};
+
+const PolicyReview: React.FC<{ policy: DRPolicyType }> = ({ policy }) => {
   const { t } = useCustomTranslation();
-  const { policy, persistentVolumeClaim } = state;
   const { drClusters, replicationType, schedulingInterval } = policy;
+  const [unit, interval] = parseSyncInterval(schedulingInterval);
+
+  return (
+    <ReviewAndCreationGroup title={t('Policy')}>
+      <ReviewAndCreationItem label={t('Policy name:')}>
+        {getName(policy)}
+      </ReviewAndCreationItem>
+      <ReviewAndCreationItem label={t('Clusters:')}>
+        {drClusters.join(', ')}
+      </ReviewAndCreationItem>
+      <ReviewAndCreationItem label={t('Replication type:')}>
+        {REPLICATION_DISPLAY_TEXT(t)[replicationType]}
+      </ReviewAndCreationItem>
+      <ReviewAndCreationItem label={t('Sync interval:')}>
+        {`${interval} ${SYNC_SCHEDULE_DISPLAY_TEXT(t)[unit]}`}
+      </ReviewAndCreationItem>
+    </ReviewAndCreationGroup>
+  );
+};
+
+const PVCDetailsReview: React.FC<{
+  persistentVolumeClaim: AssignPolicyViewState['persistentVolumeClaim'];
+}> = ({ persistentVolumeClaim }) => {
+  const { t } = useCustomTranslation();
   const { pvcSelectors } = persistentVolumeClaim;
+  const labels = getLabels(pvcSelectors);
   const selectorCount = pvcSelectors.length;
   const appResourceText =
     selectorCount > 1
       ? t('{{count}} placements', { count: selectorCount })
       : pvcSelectors[0].placementName;
 
-  const labels = getLabels(pvcSelectors);
-
-  const [unit, interval] = parseSyncInterval(schedulingInterval);
+  return (
+    <ReviewAndCreationGroup title={t('PVC details')}>
+      <ReviewAndCreationItem label={t('Application resource:')}>
+        {appResourceText}
+      </ReviewAndCreationItem>
+      <ReviewAndCreationItem label={t('PVC label selector:')}>
+        <Labels numLabels={5} labels={labels} />
+      </ReviewAndCreationItem>
+    </ReviewAndCreationGroup>
+  );
+};
 
+export const ReviewAndAssign: React.FC<ReviewAndAssignProps> = ({
+  state,
+  modalType,
+  appType,
+}) => {
   return (
     <ReviewAndCreateStep>
-      <ReviewAndCreationGroup title={t('Data policy')}>
-        <ReviewAndCreationItem label={t('Policy name:')}>
-          {getName(policy)}
-        </ReviewAndCreationItem>
-        <ReviewAndCreationItem label={t('Clusters:')}>
-          {drClusters.join(', ')}
-        </ReviewAndCreationItem>
-        <ReviewAndCreationItem label={t('Replication type:')}>
-          {REPLICATION_DISPLAY_TEXT(t)[replicationType]}
-        </ReviewAndCreationItem>
-        <ReviewAndCreationItem label={t('Sync interval:')}>
-          {`${interval} ${SYNC_SCHEDULE_DISPLAY_TEXT(t)[unit]}`}
-        </ReviewAndCreationItem>
-      </ReviewAndCreationGroup>
-      <ReviewAndCreationGroup title={t('PVC details')}>
-        <ReviewAndCreationItem label={t('Application resource:')}>
-          {appResourceText}
-        </ReviewAndCreationItem>
-        <ReviewAndCreationItem label={t('PVC label selector:')}>
-          <Labels numLabels={5} labels={labels} />
-        </ReviewAndCreationItem>
-      </ReviewAndCreationGroup>
+      {modalType === ModalType.VirtualMachine ? (
+        <>
+          <ProtectionTypeReview
+            protectionTypeState={state.protectionType}
+            appType={appType}
+          />
+          <ReplicationReview replication={state.replication} />
+        </>
+      ) : (
+        <>
+          <PolicyReview policy={state.policy} />
+          <PVCDetailsReview
+            persistentVolumeClaim={state.persistentVolumeClaim}
+          />
+        </>
+      )}
     </ReviewAndCreateStep>
   );
 };
 
 type ReviewAndAssignProps = {
   state: AssignPolicyViewState;
+  modalType: ModalType;
+  appType: DRApplication;
 };

packages/mco/components/modals/app-manage-policies/helper/select-policy-wizard-content.tsx

@@ -44,7 +44,7 @@ const getDropdownOptions = (dataPolicies: DRPolicyType[], t: TFunction) =>
     />
   ));
 
-const findPolicy = (name: string, dataPolicies: DRPolicyType[]) =>
+export const findPolicy = (name: string, dataPolicies: DRPolicyType[]) =>
   dataPolicies.find((policy) => getName(policy) === name);
 
 export const SelectPolicyWizardContent: React.FC<

packages/mco/components/modals/app-manage-policies/manage-policy-view.tsx

@@ -30,6 +30,7 @@ import {
   DISCOVERED_APP_NS,
   ReplicationType,
   SYNC_SCHEDULE_DISPLAY_TEXT,
+  VM_RECIPE_NAME,
 } from '../../../constants';
 import { getDRPlacementControlResourceObj } from '../../../hooks';
 import {
@@ -46,9 +47,63 @@ import {
   DRInfoType,
   DRPlacementControlType,
   DRPolicyType,
+  ModalType,
 } from './utils/types';
 import './style.scss';
 
+enum EmptyPageContentType {
+  NamespaceProtected = 'NamespaceProtected',
+  Application = 'Application',
+  VirtualMachine = 'VirtualMachine',
+}
+
+// Map containing content for each type
+const getEmptyPageContentMap = (t: TFunction) => ({
+  [EmptyPageContentType.NamespaceProtected]: {
+    title: t('Application already enrolled in disaster recovery'),
+    content: (
+      <Trans t={t}>
+        <p>
+          This managed application namespace is already DR protected. You may
+          have protected this namespace while enrolling discovered applications.
+        </p>
+        <p className="pf-v5-u-mt-md">
+          To see disaster recovery information for your applications, go to
+          <strong> Protected applications </strong> under&nbsp;
+          <strong> Disaster Recovery </strong>.
+        </p>
+      </Trans>
+    ),
+    buttonText: '',
+  },
+  [EmptyPageContentType.Application]: {
+    title: t('No assigned disaster recovery policy found'),
+    content: (
+      <Trans t={t}>
+        <p>
+          You have not enrolled this application yet. To protect your
+          application, click&nbsp;
+          <strong>Enroll application.</strong>
+        </p>
+      </Trans>
+    ),
+    buttonText: t('Enroll application'),
+  },
+  [EmptyPageContentType.VirtualMachine]: {
+    title: t('No assigned disaster recovery policy found'),
+    content: (
+      <Trans t={t}>
+        <p>
+          You have not enrolled this virtual machine yet. To protect your
+          virtual machine, click&nbsp;
+          <strong>Enroll virtual machine.</strong>
+        </p>
+      </Trans>
+    ),
+    buttonText: t('Enroll virtual machine'),
+  },
+});
+
 const isDRProtectionRemoved = (drpcs: DRPlacementControlType[]) =>
   drpcs.every((drpc) => _.has(drpc.metadata, 'deletionTimestamp'));
 
@@ -59,7 +114,8 @@ const checkNamespaceProtected = (
 ): boolean =>
   drpcs?.some((drpc) => {
     const isNamespaceProtected =
-      drpc.spec?.protectedNamespaces?.includes(workloadNamespace);
+      drpc.spec?.protectedNamespaces?.includes(workloadNamespace) &&
+      drpc.spec?.kubeObjectProtection?.recipeRef?.name !== VM_RECIPE_NAME;
     const isPolicyMatching = eligiblePolicies?.some(
       (policy) => getName(policy) === drpc.spec.drPolicyRef.name
     );
@@ -114,6 +170,7 @@ const ManagePolicyEmptyPage: React.FC<ManagePolicyEmptyPageProps> = ({
   policyInfoLoaded,
   policyInfoLoadError,
   onClick,
+  modalType,
 }) => {
   const { t } = useCustomTranslation();
   const [discoveredApps, loaded, loadError] = useK8sWatchResource<
@@ -130,6 +187,16 @@ const ManagePolicyEmptyPage: React.FC<ManagePolicyEmptyPageProps> = ({
     discoveredApps
   );
 
+  // Determine the correct type dynamically
+  const emptyPageContentType: EmptyPageContentType = isNamespaceProtected
+    ? EmptyPageContentType.NamespaceProtected
+    : modalType === ModalType.VirtualMachine
+      ? EmptyPageContentType.VirtualMachine
+      : EmptyPageContentType.Application;
+
+  const { title, content, buttonText } =
+    getEmptyPageContentMap(t)[emptyPageContentType];
+
   const allLoaded = policyInfoLoaded && loaded;
   const anyLoadError = policyInfoLoadError || loadError;
 
@@ -140,31 +207,10 @@ const ManagePolicyEmptyPage: React.FC<ManagePolicyEmptyPageProps> = ({
       isDisabled={isNamespaceProtected}
       EmptyIcon={BlueInfoCircleIcon}
       onClick={onClick}
-      buttonText={t('Enroll application')}
-      title={
-        isNamespaceProtected
-          ? t('Application already enrolled in disaster recovery')
-          : t('No assigned disaster recovery policy found')
-      }
+      buttonText={buttonText}
+      title={title}
     >
-      {isNamespaceProtected ? (
-        <Trans t={t}>
-          <p>
-            This managed application namespace is already DR protected. You may
-            have protected this namespace while enrolling discovered
-            applications.
-          </p>
-          <p className="pf-v5-u-mt-md">
-            To see disaster recovery information for your applications, go to
-            <strong>Protected applications</strong> under&nbsp;
-            <strong>Disaster Recovery</strong>.
-          </p>
-        </Trans>
-      ) : (
-        t(
-          'You have not enrolled this application yet. To protect your application,'
-        )
-      )}
+      {content}
     </EmptyPage>
   ) : (
     <StatusBox loaded={allLoaded} loadError={anyLoadError} />
@@ -301,6 +347,7 @@ export const ManagePolicyView: React.FC<ManagePolicyViewProps> = ({
   dispatch,
   setModalContext,
   setModalActionContext,
+  modalType,
 }) => {
   const { t } = useCustomTranslation();
   const [localModalActionContext, setLocalModalActionContext] =
@@ -321,6 +368,7 @@ export const ManagePolicyView: React.FC<ManagePolicyViewProps> = ({
           setModalActionContext(ModalActionContext.ENABLE_DR_PROTECTION);
           setModalContext(ModalViewContext.ASSIGN_POLICY_VIEW);
         }}
+        modalType={modalType}
       />
     );
   }
@@ -434,6 +482,7 @@ type ManagePolicyViewProps = {
   dispatch: React.Dispatch<ManagePolicyStateAction>;
   setModalContext: (modalViewContext: ModalViewContext) => void;
   setModalActionContext: (modalActionContext: ModalActionContext) => void;
+  modalType: ModalType;
 };
 
 type DRInformationProps = {
@@ -459,6 +508,7 @@ type ManagePolicyEmptyPageProps = {
   policyInfoLoaded: boolean;
   policyInfoLoadError: any;
   onClick: () => void;
+  modalType: ModalType;
 };
 
 type AggregatedDRInfo = {

packages/mco/components/modals/app-manage-policies/modal-context-viewer.tsx

@@ -14,6 +14,7 @@ import {
   ApplicationType,
   DRInfoType,
   DRPolicyType,
+  ModalType,
 } from './utils/types';
 
 export const ModalContextViewer: React.FC<ModalContextViewerProps> = ({
@@ -22,6 +23,7 @@ export const ModalContextViewer: React.FC<ModalContextViewerProps> = ({
   loaded,
   loadError,
   setCurrentModalContext,
+  modalType,
 }) => {
   const [state, dispatch] = React.useReducer(
     managePolicyStateReducer,
@@ -67,6 +69,7 @@ export const ModalContextViewer: React.FC<ModalContextViewerProps> = ({
           loaded={loaded}
           loadError={loadError}
           modalActionContext={state.modalActionContext}
+          modalType={modalType}
         />
       );
     }
@@ -80,6 +83,7 @@ export const ModalContextViewer: React.FC<ModalContextViewerProps> = ({
           dispatch={dispatch}
           setModalContext={setModalContext}
           setModalActionContext={setModalActionContext}
+          modalType={modalType}
         />
       );
     }
@@ -97,4 +101,5 @@ type ModalContextViewerProps = {
   setCurrentModalContext: React.Dispatch<
     React.SetStateAction<ModalViewContext>
   >;
+  modalType: ModalType;
 };

packages/mco/components/modals/app-manage-policies/parsers/application-set-parser.spec.tsx

@@ -296,8 +296,7 @@ describe('ApplicationSet manage disaster recovery modal', () => {
     expect(screen.getByText('Cancel')).toBeEnabled();
 
     // Headers
-    expect(screen.getByText('Data policy')).toBeInTheDocument();
-    expect(screen.getByText('Data policy')).toBeInTheDocument();
+    screen.getByText(/Policy/i, { selector: 'span' });
     // Labels
     expect(screen.getByText('Policy name:')).toBeInTheDocument();
     expect(screen.getByText('Clusters:')).toBeInTheDocument();

packages/mco/components/modals/app-manage-policies/parsers/application-set-parser.tsx

@@ -32,6 +32,7 @@ import {
   ApplicationType,
   DRPlacementControlType,
   DRPolicyType,
+  ModalType,
   PVCQueryFilter,
 } from '../utils/types';
 
@@ -97,6 +98,7 @@ export const ApplicationSetParser: React.FC<ApplicationSetParserProps> = ({
   isWatchApplication,
   pvcQueryFilter,
   setCurrentModalContext,
+  modalType,
 }) => {
   const namespace = getNamespace(application);
   const [drResources, drLoaded, drLoadError] = useDisasterRecoveryResourceWatch(
@@ -190,6 +192,7 @@ export const ApplicationSetParser: React.FC<ApplicationSetParserProps> = ({
       loaded={loaded}
       loadError={loadError}
       setCurrentModalContext={setCurrentModalContext}
+      modalType={modalType ?? ModalType.Application}
     />
   );
 };
@@ -204,4 +207,5 @@ type ApplicationSetParserProps = {
   >;
   // ACM search api PVC query filter
   pvcQueryFilter?: PVCQueryFilter;
+  modalType?: ModalType;
 };

packages/mco/components/modals/app-manage-policies/parsers/discovered-vm-parser.tsx

@@ -0,0 +1,123 @@
+import * as React from 'react';
+import { getPlacementKindObj } from '@odf/mco/components/discovered-application-wizard/utils/k8s-utils';
+import {
+  DISCOVERED_APP_NS,
+  DRApplication,
+  ODF_RESOURCE_TYPE_LABEL,
+} from '@odf/mco/constants';
+import {
+  getDRPlacementControlResourceObj,
+  getDRPolicyResourceObj,
+} from '@odf/mco/hooks';
+import { VirtualMachineModel } from '@odf/mco/models';
+import { DRPlacementControlKind, DRPolicyKind } from '@odf/mco/types';
+import { findDRPolicyUsingDRPC } from '@odf/mco/utils';
+import { getName, getNamespace } from '@odf/shared';
+import {
+  K8sResourceCommon,
+  useK8sWatchResource,
+} from '@openshift-console/dynamic-plugin-sdk';
+import { ModalContextViewer } from '../modal-context-viewer';
+import {
+  findDRPCUsingVM,
+  generateApplicationInfo,
+  generateDRInfo,
+  generateDRPlacementControlInfo,
+  generatePlacementInfo,
+  getMatchingDRPolicies,
+} from '../utils/parser-utils';
+import { ModalViewContext } from '../utils/reducer';
+import {
+  ApplicationInfoType,
+  ApplicationType,
+  DRPolicyType,
+  ModalType,
+  PVCQueryFilter,
+} from '../utils/types';
+
+export const DiscoveredVMParser: React.FC<DiscoveredVMParserProps> = ({
+  virtualMachine,
+  cluster,
+  pvcQueryFilter,
+  setCurrentModalContext,
+}) => {
+  // Fetch resources
+  const [drpcs, drpcsLoaded, drpcsLoadError] = useK8sWatchResource<
+    DRPlacementControlKind[]
+  >(
+    getDRPlacementControlResourceObj({
+      namespace: DISCOVERED_APP_NS,
+      selector: {
+        matchLabels: {
+          [ODF_RESOURCE_TYPE_LABEL]: VirtualMachineModel.kind.toLowerCase(),
+        },
+      },
+    })
+  );
+
+  const [drPolicies, drPoliciesLoaded, drPoliciesLoadError] =
+    useK8sWatchResource<DRPolicyKind[]>(getDRPolicyResourceObj());
+
+  // Compute loading states
+  const isLoaded = drpcsLoaded && drPoliciesLoaded;
+  const loadError = drPoliciesLoadError || drpcsLoadError;
+  const isLoadedWOError = isLoaded && !loadError;
+
+  const applicationInfo: ApplicationInfoType = React.useMemo(() => {
+    if (!isLoadedWOError) return {};
+
+    const vmName = getName(virtualMachine);
+    const vmNamespace = getNamespace(virtualMachine);
+    const drpc = findDRPCUsingVM(drpcs, vmName, vmNamespace);
+    const drPolicy = drpc && findDRPolicyUsingDRPC(drpc, drPolicies);
+    const placementName =
+      drpc?.spec.placementRef?.name ?? `${vmName}-placement-1`;
+    const placementInfo = generatePlacementInfo(
+      getPlacementKindObj(placementName),
+      [cluster]
+    );
+    const drpcInfo = generateDRPlacementControlInfo(drpc, placementInfo);
+
+    return generateApplicationInfo(
+      DRApplication.DISCOVERED,
+      virtualMachine,
+      vmNamespace,
+      drpcInfo.length ? [] : [placementInfo], // Skip placement if DRPC exists
+      generateDRInfo(drPolicy, drpcInfo),
+      pvcQueryFilter
+    );
+  }, [
+    virtualMachine,
+    cluster,
+    drpcs,
+    drPolicies,
+    isLoadedWOError,
+    pvcQueryFilter,
+  ]);
+
+  const matchingPolicies: DRPolicyType[] = React.useMemo(() => {
+    return Object.keys(applicationInfo).length
+      ? getMatchingDRPolicies(applicationInfo as ApplicationType, drPolicies)
+      : [];
+  }, [applicationInfo, drPolicies]);
+
+  return (
+    <ModalContextViewer
+      applicationInfo={applicationInfo}
+      matchingPolicies={matchingPolicies}
+      loaded={isLoaded}
+      loadError={loadError}
+      setCurrentModalContext={setCurrentModalContext}
+      modalType={ModalType.VirtualMachine}
+    />
+  );
+};
+
+type DiscoveredVMParserProps = {
+  virtualMachine: K8sResourceCommon;
+  cluster: string;
+  setCurrentModalContext: React.Dispatch<
+    React.SetStateAction<ModalViewContext>
+  >;
+  pvcQueryFilter?: PVCQueryFilter;
+};

packages/mco/components/modals/app-manage-policies/parsers/subscription-parser.spec.tsx

@@ -296,8 +296,7 @@ describe('Subscription manage disaster recovery modal', () => {
     expect(screen.getByText('Cancel')).toBeEnabled();
 
     // Headers
-    expect(screen.getByText('Data policy')).toBeInTheDocument();
-    expect(screen.getByText('Data policy')).toBeInTheDocument();
+    screen.getByText(/Policy/i, { selector: 'span' });
     // Labels
     expect(screen.getByText('Policy name:')).toBeInTheDocument();
     expect(screen.getByText('Clusters:')).toBeInTheDocument();

packages/mco/components/modals/app-manage-policies/parsers/subscription-parser.tsx

@@ -30,6 +30,7 @@ import {
   ApplicationType,
   DRPlacementControlType,
   DRPolicyType,
+  ModalType,
   PlacementType,
   PVCQueryFilter,
 } from '../utils/types';
@@ -90,6 +91,7 @@ export const SubscriptionParser: React.FC<SubscriptionParserProps> = ({
   isWatchApplication,
   pvcQueryFilter,
   setCurrentModalContext,
+  modalType,
 }) => {
   const namespace = getNamespace(application);
   const [drResources, drLoaded, drLoadError] = useDisasterRecoveryResourceWatch(
@@ -191,6 +193,7 @@ export const SubscriptionParser: React.FC<SubscriptionParserProps> = ({
       loaded={loaded}
       loadError={loadError}
       setCurrentModalContext={setCurrentModalContext}
+      modalType={modalType ?? ModalType.Application}
     />
   );
 };
@@ -208,4 +211,5 @@ type SubscriptionParserProps = {
   >;
   // ACM search api PVC query filter
   pvcQueryFilter?: PVCQueryFilter;
+  modalType?: ModalType;
 };

packages/mco/components/modals/app-manage-policies/parsers/virtual-machine-parser.tsx

@@ -6,12 +6,13 @@ import {
   ArgoApplicationSetModel,
   VirtualMachineModel,
 } from '@odf/mco/models';
-import { SearchResultItemType } from '@odf/mco/types';
+import { ArgoApplicationSetKind, SearchResultItemType } from '@odf/mco/types';
 import {
   getLabelsFromSearchResult,
   queryManagedApplicationResourcesForVM,
 } from '@odf/mco/utils';
 import {
+  ApplicationKind,
   ApplicationModel,
   getLabel,
   getName,
@@ -20,10 +21,38 @@ import {
 } from '@odf/shared';
 import { K8sResourceCommon } from '@openshift-console/dynamic-plugin-sdk';
 import { ModalViewContext } from '../utils/reducer';
-import { PVCQueryFilter } from '../utils/types';
+import { ModalType, PVCQueryFilter } from '../utils/types';
 import { ApplicationSetParser } from './application-set-parser';
+import { DiscoveredVMParser } from './discovered-vm-parser';
 import { SubscriptionParser } from './subscription-parser';
 
+const createApplicationSetObj = (
+  name: string,
+  namespace: string
+): ArgoApplicationSetKind => ({
+  apiVersion: `${ArgoApplicationSetModel.apiGroup}/${ArgoApplicationSetModel.apiVersion}`,
+  kind: ArgoApplicationSetModel.kind,
+  metadata: { name, namespace },
+  spec: {},
+});
+
+const createApplicationObj = (
+  name: string,
+  namespace: string
+): ApplicationKind => ({
+  apiVersion: `${ApplicationModel.apiGroup}/${ApplicationModel.apiVersion}`,
+  kind: ApplicationModel.kind,
+  metadata: {
+    name: name,
+    namespace,
+  },
+  spec: {
+    componentKinds: [
+      { group: ACMSubscriptionModel.apiGroup, kind: ACMSubscriptionModel.kind },
+    ],
+  },
+});
+
 const getPVCQueryFilter = (
   name: string,
   namespace: string,
@@ -71,46 +100,44 @@ export const VirtualMachineParser: React.FC<VirtualMachineParserProps> = ({
       (item) => item.cluster === HUB_CLUSTER_NAME
     );
 
-  const { name, namespace, kind, apigroup } = managedApplication || {};
+  const { name, namespace, kind } = managedApplication || {};
 
   if (kind === ArgoApplicationSetModel.kind) {
     return (
       <ApplicationSetParser
-        application={{
-          apiVersion: `${ArgoApplicationSetModel.apiGroup}/${ArgoApplicationSetModel.apiVersion}`,
-          kind,
-          metadata: { name, namespace },
-          spec: {},
-        }}
+        application={createApplicationSetObj(name, namespace)}
         setCurrentModalContext={setCurrentModalContext}
         isWatchApplication
         pvcQueryFilter={pvcQueryFilter}
+        modalType={ModalType.VirtualMachine}
       />
     );
   }
 
   if (kind === ACMSubscriptionModel.kind) {
     return (
       <SubscriptionParser
-        application={{
-          apiVersion: `${ApplicationModel.apiGroup}/${ApplicationModel.apiVersion}`,
-          kind: ApplicationModel.kind,
-          metadata: {
-            name: getLabelsFromSearchResult(managedApplication)?.app?.[0],
-            namespace,
-          },
-          spec: { componentKinds: [{ group: apigroup, kind }] },
-        }}
+        application={createApplicationObj(
+          getLabelsFromSearchResult(managedApplication)?.app?.[0],
+          namespace
+        )}
         subscriptionName={name}
         isWatchApplication
         setCurrentModalContext={setCurrentModalContext}
         pvcQueryFilter={pvcQueryFilter}
+        modalType={ModalType.VirtualMachine}
       />
     );
   }
 
-  // TODO: Add support for discovered application type
-  return null;
+  return (
+    <DiscoveredVMParser
+      virtualMachine={virtualMachine}
+      setCurrentModalContext={setCurrentModalContext}
+      pvcQueryFilter={pvcQueryFilter}
+      cluster={clusterName}
+    />
+  );
 };
 
 type VirtualMachineParserProps = {

packages/mco/components/modals/app-manage-policies/utils/k8s-utils.ts

@@ -3,11 +3,25 @@ import {
   ACMPlacementRuleModel,
   DRPlacementControlModel,
   DRPolicyModel,
+  VirtualMachineModel,
 } from '@odf/mco//models';
 import {
+  getDRPCKindObj as getDiscoveredDRPCKindObj,
+  getPlacementKindObj,
+} from '@odf/mco/components/discovered-application-wizard/utils/k8s-utils';
+import { ProtectionMethodType } from '@odf/mco/components/discovered-application-wizard/utils/reducer';
+import {
+  DISCOVERED_APP_NS,
   DO_NOT_DELETE_PVC_ANNOTATION_WO_SLASH,
   DR_SECHEDULER_NAME,
+  DRApplication,
+  K8S_RESOURCE_SELECTOR,
   PROTECTED_APP_ANNOTATION_WO_SLASH,
+  PVC_RESOURCE_SELECTOR,
+  PROTECTED_VMS,
+  VM_RECIPE_NAME,
+  VM_NAMESPACE,
+  ODF_RESOURCE_TYPE_LABEL,
 } from '@odf/mco/constants';
 import { DRPlacementControlKind } from '@odf/mco/types';
 import { convertLabelToExpression, matchClusters } from '@odf/mco/utils';
@@ -28,7 +42,7 @@ import * as _ from 'lodash-es';
 import { AssignPolicyViewState } from './reducer';
 import { DRPlacementControlType, PlacementType } from './types';
 
-export const getDRPCKindObj = (
+export const getManagedDRPCKindObj = (
   plsName: string,
   plsNamespace: string,
   plsKind: string,
@@ -161,7 +175,7 @@ const placementRuleAssignPromise = (placement: PlacementType) => {
 const getPlacement = (placementName: string, placements: PlacementType[]) =>
   placements.find((placement) => getName(placement) === placementName);
 
-export const assignPromises = (
+export const assignPromisesForManaged = (
   state: AssignPolicyViewState,
   placements: PlacementType[]
 ) => {
@@ -179,7 +193,7 @@ export const assignPromises = (
     promises.push(
       k8sCreate({
         model: DRPlacementControlModel,
-        data: getDRPCKindObj(
+        data: getManagedDRPCKindObj(
           getName(placement),
           getNamespace(placement),
           placement.kind,
@@ -195,3 +209,58 @@ export const assignPromises = (
 
   return promises;
 };
+
+export const assignPromisesForDiscovered = (
+  state: AssignPolicyViewState,
+  placements: PlacementType[],
+  vmNamespace: string,
+  vmName: string
+): Promise<K8sResourceKind>[] => {
+  const {
+    protectionType: { protectionName },
+    replication: { k8sSyncInterval, policy },
+  } = state;
+  const placementName = `${protectionName}-drpc-placement-1`;
+
+  return [
+    k8sCreate({
+      model: ACMPlacementModel,
+      data: getPlacementKindObj(placementName),
+    }),
+    k8sCreate({
+      model: DRPlacementControlModel,
+      data: getDiscoveredDRPCKindObj({
+        name: `${protectionName}-drpc`,
+        preferredCluster: placements[0].deploymentClusters[0],
+        namespaces: [vmNamespace],
+        protectionMethod: ProtectionMethodType.RECIPE,
+        recipeName: VM_RECIPE_NAME,
+        recipeNamespace: DISCOVERED_APP_NS,
+        drPolicyName: getName(policy),
+        k8sResourceReplicationInterval: k8sSyncInterval,
+        placementName,
+        pvcLabelExpressions: [],
+        recipeParameters: {
+          [K8S_RESOURCE_SELECTOR]: [protectionName],
+          [PVC_RESOURCE_SELECTOR]: [protectionName],
+          [PROTECTED_VMS]: [vmName],
+          [VM_NAMESPACE]: [vmNamespace],
+        },
+        labels: {
+          [ODF_RESOURCE_TYPE_LABEL]: VirtualMachineModel.kind.toLowerCase(),
+        },
+      }),
+    }),
+  ];
+};
+
+export const assignPromises = (
+  state: AssignPolicyViewState,
+  placements: PlacementType[],
+  appType: DRApplication,
+  vmNamespace?: string,
+  vmName?: string
+): Promise<K8sResourceKind>[] =>
+  appType === DRApplication.DISCOVERED
+    ? assignPromisesForDiscovered(state, placements, vmNamespace, vmName)
+    : assignPromisesForManaged(state, placements);

packages/mco/components/modals/app-manage-policies/utils/parser-utils.ts

@@ -1,11 +1,10 @@
-import { DRApplication } from '@odf/mco/constants';
+import { DRApplication, PROTECTED_VMS } from '@odf/mco/constants';
 import {
   getDRClusterResourceObj,
   getDRPlacementControlResourceObj,
   getDRPolicyResourceObj,
 } from '@odf/mco/hooks';
 import {
-  ACMApplicationKind,
   ACMPlacementType,
   DRPlacementControlKind,
   DRPolicyKind,
@@ -18,7 +17,10 @@ import {
 } from '@odf/mco/utils';
 import { getLatestDate } from '@odf/shared/details-page/datetime';
 import { arrayify } from '@odf/shared/modals/EditLabelModal';
-import { Selector } from '@openshift-console/dynamic-plugin-sdk';
+import {
+  K8sResourceCommon,
+  Selector,
+} from '@openshift-console/dynamic-plugin-sdk';
 import * as _ from 'lodash-es';
 import {
   ApplicationType,
@@ -93,7 +95,7 @@ export const generateDRPlacementControlInfo = (
 
 export const generateApplicationInfo = (
   appType: DRApplication,
-  application: ACMApplicationKind,
+  application: K8sResourceCommon,
   workloadNamespace: string,
   plsInfo: PlacementType[],
   drInfo: DRInfoType | {},
@@ -142,3 +144,19 @@ export const getDRResources = (namespace: string) => ({
     }),
   },
 });
+
+const getVMNamesFromRecipe = (
+  spec?: DRPlacementControlKind['spec']
+): string[] =>
+  spec?.kubeObjectProtection?.recipeParameters?.[PROTECTED_VMS] ?? [];
+
+export const findDRPCUsingVM = (
+  drpcs: DRPlacementControlKind[] = [],
+  vmName: string,
+  vmNamespace: string
+): DRPlacementControlKind | undefined =>
+  drpcs.find(
+    ({ spec }) =>
+      getVMNamesFromRecipe(spec).includes(vmName) &&
+      spec?.protectedNamespaces?.includes(vmNamespace)
+  );

packages/mco/components/modals/app-manage-policies/utils/reducer.ts

@@ -1,4 +1,4 @@
-import { DRPolicyType } from './types';
+import { DRPolicyType, VMProtectioType } from './types';
 
 export enum ModalViewContext {
   MANAGE_POLICY_VIEW = 'managePolicyView',
@@ -20,17 +20,30 @@ export enum ManagePolicyStateType {
   SET_SELECTED_POLICY = 'SET_SELECTED_POLICY',
   SET_PVC_SELECTORS = 'SET_PVC_SELECTORS',
   RESET_ASSIGN_POLICY_STATE = 'RESET_ASSIGN_POLICY_STATE',
+  SET_VM_PROTECTION_METHOD = 'SET_VM_PROTECTION_METHOD',
+  SET_VM_PROTECTION_NAME = 'SET_VM_PROTECTION_NAME',
+  SET_SELECTED_POLICY_FOR_REPLICATION = 'SET_SELECTED_POLICY_FOR_REPLICATION',
+  SET_K8S_SYNC_INTERVAL = 'SET_K8S_SYNC_INTERVAL',
 }
 
 export type PVCSelectorType = {
   placementName: string;
   labels: string[];
 };
+
 export type AssignPolicyViewState = {
   policy: DRPolicyType;
   persistentVolumeClaim: {
     pvcSelectors: PVCSelectorType[];
   };
+  protectionType?: {
+    protectionType: VMProtectioType;
+    protectionName: string;
+  };
+  replication?: {
+    policy: DRPolicyType;
+    k8sSyncInterval: string;
+  };
 };
 
 export type ManagePolicyState = {
@@ -46,6 +59,14 @@ export const initialPolicyState: ManagePolicyState = {
     persistentVolumeClaim: {
       pvcSelectors: [],
     },
+    protectionType: {
+      protectionType: VMProtectioType.STANDALONE,
+      protectionName: '',
+    },
+    replication: {
+      policy: undefined,
+      k8sSyncInterval: '5m',
+    },
   },
 };
 
@@ -71,6 +92,26 @@ export type ManagePolicyStateAction =
   | {
       type: ManagePolicyStateType.RESET_ASSIGN_POLICY_STATE;
       context: ModalViewContext;
+    }
+  | {
+      type: ManagePolicyStateType.SET_VM_PROTECTION_METHOD;
+      context: ModalViewContext;
+      payload: VMProtectioType;
+    }
+  | {
+      type: ManagePolicyStateType.SET_VM_PROTECTION_NAME;
+      context: ModalViewContext;
+      payload: string;
+    }
+  | {
+      type: ManagePolicyStateType.SET_SELECTED_POLICY_FOR_REPLICATION;
+      context: ModalViewContext;
+      payload: DRPolicyType;
+    }
+  | {
+      type: ManagePolicyStateType.SET_K8S_SYNC_INTERVAL;
+      context: ModalViewContext;
+      payload: string;
     };
 
 export const managePolicyStateReducer = (
@@ -120,6 +161,54 @@ export const managePolicyStateReducer = (
         },
       };
     }
+    case ManagePolicyStateType.SET_VM_PROTECTION_METHOD: {
+      return {
+        ...state,
+        [action.context]: {
+          ...state[action.context],
+          protectionType: {
+            ...state[action.context]['protectionType'],
+            protectionType: action.payload,
+          },
+        },
+      };
+    }
+    case ManagePolicyStateType.SET_VM_PROTECTION_NAME: {
+      return {
+        ...state,
+        [action.context]: {
+          ...state[action.context],
+          protectionType: {
+            ...state[action.context]['protectionType'],
+            protectionName: action.payload,
+          },
+        },
+      };
+    }
+    case ManagePolicyStateType.SET_SELECTED_POLICY_FOR_REPLICATION: {
+      return {
+        ...state,
+        [action.context]: {
+          ...state[action.context],
+          replication: {
+            ...state[action.context]['replication'],
+            policy: action.payload,
+          },
+        },
+      };
+    }
+    case ManagePolicyStateType.SET_K8S_SYNC_INTERVAL: {
+      return {
+        ...state,
+        [action.context]: {
+          ...state[action.context],
+          replication: {
+            ...state[action.context]['replication'],
+            k8sSyncInterval: action.payload,
+          },
+        },
+      };
+    }
     default:
       return state;
   }

packages/mco/components/modals/app-manage-policies/utils/types.ts

@@ -55,3 +55,13 @@ export type ApplicationType = K8sResourceCommon & {
 };
 
 export type ApplicationInfoType = ApplicationType | {};
+
+export enum ModalType {
+  Application = 'Application',
+  VirtualMachine = 'VirtualMachine',
+}
+
+export enum VMProtectioType {
+  STANDALONE = 'STANDALONE',
+  SHARED = 'SHARED',
+}

packages/mco/constants/common.ts

@@ -23,3 +23,6 @@ export const ADMIN_FLAG = 'ADMIN';
 export const DISCOVERED_APP_NS = 'openshift-dr-ops';
 
 export const NAME_NAMESPACE_SPLIT_CHAR = '/';
+
+// Console search optimization selector
+export const ODF_RESOURCE_TYPE_LABEL = 'odf.console.search/resourcetype';

packages/mco/constants/disaster-recovery.ts

@@ -82,11 +82,15 @@ export enum AssignPolicySteps {
   Policy = 'policy',
   PersistentVolumeClaim = 'persistent-volume-claim',
   ReviewAndAssign = 'review-and-assign',
+  ProtectionType = 'protection-type',
+  Replication = 'replication',
 }
 export const AssignPolicyStepsNames = (t: TFunction) => ({
   [AssignPolicySteps.Policy]: t('Policy'),
   [AssignPolicySteps.PersistentVolumeClaim]: t('PersistentVolumeClaim'),
   [AssignPolicySteps.ReviewAndAssign]: t('Review and assign'),
+  [AssignPolicySteps.ProtectionType]: t('Protection type'),
+  [AssignPolicySteps.Replication]: t('Replication'),
 });
 
 export const ENROLLED_APP_QUERY_PARAMS_KEY = 'enrolledApp';
@@ -111,3 +115,12 @@ export const MCO_CREATED_BY_LABEL_KEY =
   'multicluster.odf.openshift.io/created-by';
 export const MCO_CREATED_BY_MC_CONTROLLER =
   'odf-multicluster-managedcluster-controller';
+
+// Recipe parameter keys
+export const VM_RECIPE_NAME = 'vm-recipe';
+export const K8S_RESOURCE_SELECTOR = 'K8S_RESOURCE_SELECTOR';
+export const PVC_RESOURCE_SELECTOR = 'PVC_RESOURCE_SELECTOR';
+export const PROTECTED_VMS = 'PROTECTED_VMS';
+export const VM_NAMESPACE = 'VM_NAMESPACE';
+export const K8S_RESOURCE_SELECTOR_LABEL_KEY =
+  'ramendr.openshift.io/k8s-resource-selector';

packages/mco/hooks/mco-resources.ts

@@ -52,6 +52,7 @@ export const getDRPlacementControlResourceObj = (
   kind: referenceForModel(DRPlacementControlModel),
   ...(!props?.name ? { isList: true } : {}),
   namespaced: !!props?.namespace ? false : true,
+  ...(!!props?.selector ? { selector: props?.selector } : {}),
   optional: true,
 });
 

packages/mco/types/ramen.ts

@@ -66,6 +66,8 @@ export type DRPlacementControlKind = K8sResourceCommon & {
       // To identify all the kube objects that need DR protection.
       //  N/A for the managed  applications.
       kubeObjectSelector?: Selector;
+      // Recipe parameter definitions
+      recipeParameters?: Record<string, string[]>;
     };
     //  A list of namespaces that are protected by the DRPC.
     //  N/A for the managed  applications.

packages/shared/src/input-with-requirements/nameInputWithValidation.tsx

@@ -0,0 +1,107 @@
+import * as React from 'react';
+import validationRegEx from '@odf/shared/utils/validation';
+import { useForm } from 'react-hook-form';
+import { TFunction } from 'react-i18next';
+import * as Yup from 'yup';
+import { fieldRequirementsTranslations, formSettings } from '../constants';
+import { useCustomTranslation } from '../useCustomTranslationHook';
+import { useYupValidationResolver } from '../yup-validation-resolver';
+import TextInputWithFieldRequirements from './TextInputWithFieldRequirements';
+
+const getInputValidationSchema = (t: TFunction, existingNames: string[]) => {
+  const fieldRequirements = [
+    fieldRequirementsTranslations.maxChars(t, 63),
+    fieldRequirementsTranslations.startAndEndName(t),
+    fieldRequirementsTranslations.alphaNumericPeriodAdnHyphen(t),
+    fieldRequirementsTranslations.cannotBeUsedBefore(t),
+  ];
+
+  return {
+    schema: Yup.object({
+      'name-input': Yup.string()
+        .required()
+        .max(63, fieldRequirements[0])
+        .matches(
+          validationRegEx.startAndEndsWithAlphanumerics,
+          fieldRequirements[1]
+        )
+        .matches(
+          validationRegEx.alphaNumericsPeriodsHyphensNonConsecutive,
+          fieldRequirements[2]
+        )
+        .test(
+          'unique-name',
+          fieldRequirements[3],
+          (value: string) => !existingNames.includes(value)
+        ),
+    }),
+    fieldRequirements,
+  };
+};
+
+const NameInput: React.FC<NameInputProps> = ({
+  name,
+  existingNames = [],
+  label,
+  helperText,
+  fieldId = 'name-input',
+  dataTest = 'name-input',
+  onChange,
+}) => {
+  const { t } = useCustomTranslation();
+  const { schema, fieldRequirements } = React.useMemo(
+    () => getInputValidationSchema(t, existingNames),
+    [t, existingNames]
+  );
+
+  const resolver = useYupValidationResolver(schema);
+  const {
+    control,
+    watch,
+    formState: { isValid },
+  } = useForm({ ...formSettings, resolver });
+
+  const newName = watch(fieldId);
+
+  React.useEffect(() => {
+    onChange(isValid ? newName : '');
+  }, [isValid, name, onChange, newName]);
+
+  return (
+    <TextInputWithFieldRequirements
+      control={control}
+      fieldRequirements={fieldRequirements}
+      defaultValue={name}
+      popoverProps={{
+        headerContent: t('Name requirements'),
+        footerContent: `${t('Example')}: my-name`,
+      }}
+      formGroupProps={{
+        className: 'pf-v5-u-w-50',
+        label: label ?? t('Name'),
+        fieldId,
+        isRequired: true,
+      }}
+      textInputProps={{
+        id: fieldId,
+        name: fieldId,
+        placeholder: t('Enter a unique name'),
+        'data-test': dataTest,
+        'aria-label': t('Name input'),
+      }}
+      helperText={helperText}
+    />
+  );
+};
+
+export type NameInputProps = {
+  name: string;
+  existingNames?: string[];
+  label?: string;
+  helperText?: string;
+  fieldId?: string;
+  dataTest?: string;
+  onChange: (text: string) => void;
+};
+
+export default NameInput;