/// <summary>
/// ProcessRecord of the command.
/// </summary>
public override void ExecuteSiteRecoveryCmdlet()
{
base.ExecuteSiteRecoveryCmdlet();
string armName = string.Format(
"StrgMap_{0}_{1}_{2}",
PrimaryStorageClassification.Name,
RecoveryStorageClassification.Name,
Guid.NewGuid());
var props = new StorageClassificationMappingInputProperties()
{
TargetStorageClassificationId = RecoveryStorageClassification.Id
};
var input = new StorageClassificationMappingInput()
{
Properties = props
};
LongRunningOperationResponse operationResponse =
RecoveryServicesClient.MapStorageClassification(
PrimaryStorageClassification,
input,
armName);
JobResponse jobResponse =
RecoveryServicesClient.GetAzureSiteRecoveryJobDetails(
PSRecoveryServicesClient.GetJobIdFromReponseLocation(operationResponse.Location));
base.WriteObject(new ASRJob(jobResponse.Job));
}
/// <summary>
/// Pairs storage to a given storage.
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.Azure.Management.SiteRecovery.IStorageClassificationMappingOperations.
/// </param>
/// <param name='fabricName'>
/// Required. Fabric name.
/// </param>
/// <param name='storageClassificationName'>
/// Required. Storage name.
/// </param>
/// <param name='storageClassificationMappingName'>
/// Required. Storage mapping name.
/// </param>
/// <param name='input'>
/// Required. Create mapping input.
/// </param>
/// <param name='customRequestHeaders'>
/// Optional. Request header parameters.
/// </param>
/// <returns>
/// A standard service response for long running operations.
/// </returns>
public static LongRunningOperationResponse BeginPairStorageClassification(this IStorageClassificationMappingOperations operations, string fabricName, string storageClassificationName, string storageClassificationMappingName, StorageClassificationMappingInput input, CustomRequestHeaders customRequestHeaders)
{
return Task.Factory.StartNew((object s) =>
{
return ((IStorageClassificationMappingOperations)s).BeginPairStorageClassificationAsync(fabricName, storageClassificationName, storageClassificationMappingName, input, customRequestHeaders);
}
, operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
}
/// <summary>
/// Pairs storage to a given storage.
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.Azure.Management.SiteRecovery.IStorageClassificationMappingOperations.
/// </param>
/// <param name='fabricName'>
/// Required. Fabric name.
/// </param>
/// <param name='storageClassificationName'>
/// Required. Storage name.
/// </param>
/// <param name='storageClassificationMappingName'>
/// Required. Storage mapping name.
/// </param>
/// <param name='input'>
/// Required. Create mapping input.
/// </param>
/// <param name='customRequestHeaders'>
/// Optional. Request header parameters.
/// </param>
/// <returns>
/// A standard service response for long running operations.
/// </returns>
public static Task<LongRunningOperationResponse> BeginPairStorageClassificationAsync(this IStorageClassificationMappingOperations operations, string fabricName, string storageClassificationName, string storageClassificationMappingName, StorageClassificationMappingInput input, CustomRequestHeaders customRequestHeaders)
{
return operations.BeginPairStorageClassificationAsync(fabricName, storageClassificationName, storageClassificationMappingName, input, customRequestHeaders, CancellationToken.None);
}
public void EndToEndE2ESingleVM()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
var client = GetSiteRecoveryClient(CustomHttpHandler);
bool pairClouds = true;
bool StorageClassificationMapping = true;
bool enableDR = true;
bool pfo = true;
bool commit = true;
bool tfo = true;
bool pfoReverse = true;
bool commitReverse = true;
bool rr = true;
bool rrReverse = true;
bool disableDR = true;
bool unpair = true;
bool StorageClassificationUnmap = true;
bool removePolicy = true;
var fabrics = client.Fabrics.List(RequestHeaders);
Fabric selectedFabric = null;
foreach (var fabric in fabrics.Fabrics)
{
if (fabric.Properties.CustomDetails.InstanceType.Contains("VMM"))
{
selectedFabric = fabric;
}
}
string priCld = string.Empty;
string recCldGuid = string.Empty;
string recCld = string.Empty;
string policyName = "Hydra-EndToEndE2ESingleVM-" + (new Random()).Next();
string mappingName = "Mapping-EndToEndE2ESingleVM-" + (new Random()).Next();
string StorageClassificationMappingName = "StrgMapping-EndToEndE2ESingleVM-453834979";// "StrgMapping-EndToEndE2ESingleVM-" + (new Random()).Next();
string replicationProtectedItemName = "PE" + (new Random()).Next();
string enableDRVmName = string.Empty;
Policy currentPolicy = null;
var policies = client.Policies.List(RequestHeaders);
if (string.IsNullOrEmpty(recCldGuid))
{
var containers = client.ProtectionContainer.List(selectedFabric.Name, RequestHeaders);
foreach (var container in containers.ProtectionContainers)
{
if (container.Properties.PairingStatus.Equals("NotPaired", StringComparison.InvariantCultureIgnoreCase))
{
if (string.IsNullOrEmpty(priCld))
{
priCld = container.Name;
}
else if (string.IsNullOrEmpty(recCld) && priCld != container.Name)
{
recCld = container.Id;
recCldGuid = container.Name;
}
}
}
}
else
{
recCld = client.ProtectionContainer.Get(selectedFabric.Name, recCldGuid, RequestHeaders).ProtectionContainer.Id;
}
StorageClassification selectedStorageClassification = null;
if (StorageClassificationMapping)
{
IList<StorageClassification> StorageClassifications = client.StorageClassification.List(selectedFabric.Name, RequestHeaders).StorageClassifications;
if (StorageClassifications.Count > 1)
{
StorageClassificationMappingInputProperties strgInputProps = new StorageClassificationMappingInputProperties()
{
TargetStorageClassificationId = StorageClassifications[1].Id
};
StorageClassificationMappingInput strgInput = new StorageClassificationMappingInput()
{
Properties = strgInputProps
};
var mapStorageClassifications = client.StorageClassificationMapping.PairStorageClassification(selectedFabric.Name, StorageClassifications[0].Name, StorageClassificationMappingName, strgInput, RequestHeaders);
selectedStorageClassification = StorageClassifications[0];
}
}
if (pairClouds)
{
HyperVReplica2012R2PolicyInput hvrProfileInput = new HyperVReplica2012R2PolicyInput()
{
ApplicationConsistentSnapshotFrequencyInHours = 0,
AllowedAuthenticationType = 1,
Compression = "Enable",
InitialReplicationMethod = "OverNetwork",
OnlineReplicationStartTime = null,
RecoveryPoints = 0,
ReplicaDeletion = "Required",
ReplicationPort = 8083,
ReplicationFrequencyInSeconds = 300
};
CreatePolicyInputProperties policyCreationProp = new CreatePolicyInputProperties()
{
ProviderSpecificInput = hvrProfileInput
};
CreatePolicyInput policyCreationInput = new CreatePolicyInput()
{
Properties = policyCreationProp
};
var policyCreateResp = client.Policies.Create(policyName, policyCreationInput, RequestHeaders);
currentPolicy = client.Policies.Get(policyName, RequestHeaders).Policy;
CreateProtectionContainerMappingInputProperties pairingProps = new CreateProtectionContainerMappingInputProperties()
{
PolicyId = currentPolicy.Id,
TargetProtectionContainerId = recCld,
ProviderSpecificInput = new ReplicationProviderContainerMappingInput()
};
CreateProtectionContainerMappingInput pairingInput = new CreateProtectionContainerMappingInput()
{
Properties = pairingProps
};
var pairingResponse = client.ProtectionContainerMapping.ConfigureProtection(
selectedFabric.Name,
priCld,
mappingName,
pairingInput,
RequestHeaders);
// Adding SP1 Profile too
HyperVReplica2012PolicyInput hvrsp1ProfileInput = new HyperVReplica2012PolicyInput()
{
ApplicationConsistentSnapshotFrequencyInHours = 0,
AllowedAuthenticationType = 1,
Compression = "Enable",
InitialReplicationMethod = "OverNetwork",
OnlineReplicationStartTime = null,
RecoveryPoints = 0,
ReplicaDeletion = "Required",
ReplicationPort = 8083
};
CreatePolicyInputProperties policySp1CreationProp = new CreatePolicyInputProperties()
{
ProviderSpecificInput = hvrsp1ProfileInput
};
CreatePolicyInput policySp1CreationInput = new CreatePolicyInput()
{
Properties = policySp1CreationProp
};
var policySp1CreateResp = client.Policies.Create(policyName + "SP1", policySp1CreationInput, RequestHeaders);
var currentSp1Policy = client.Policies.Get(policyName + "SP1", RequestHeaders).Policy;
CreateProtectionContainerMappingInputProperties pairingSp1Props = new CreateProtectionContainerMappingInputProperties()
{
PolicyId = currentSp1Policy.Id,
TargetProtectionContainerId = recCld,
ProviderSpecificInput = new ReplicationProviderContainerMappingInput()
};
CreateProtectionContainerMappingInput pairingSp1Input = new CreateProtectionContainerMappingInput()
{
Properties = pairingSp1Props
};
var pairingSp1Response = client.ProtectionContainerMapping.ConfigureProtection(
selectedFabric.Name,
priCld,
mappingName + "sp1",
pairingSp1Input,
RequestHeaders);
}
else
{
currentPolicy = client.Policies.Get(policyName, RequestHeaders).Policy;
}
if (enableDR)
{
EnableProtectionInputProperties enableDRProp = new EnableProtectionInputProperties();
if (string.IsNullOrEmpty(enableDRVmName))
{
var protectableItem = GetUnprotectedItem(client, selectedFabric.Name, priCld);
enableDRProp = new EnableProtectionInputProperties()
{
PolicyId = currentPolicy.Id,
ProtectableItemId = protectableItem.Id,
ProviderSpecificDetails = new EnableProtectionProviderSpecificInput()
};
}
else
{
var item = client.ProtectableItem.Get(selectedFabric.Name, priCld, enableDRVmName, RequestHeaders);
enableDRProp = new EnableProtectionInputProperties()
{
PolicyId = currentPolicy.Id,
ProtectableItemId = item.ProtectableItem.Id,
ProviderSpecificDetails = new EnableProtectionProviderSpecificInput()
};
}
EnableProtectionInput enableInput = new EnableProtectionInput()
{
Properties = enableDRProp
};
var enableDRStartTime = DateTime.Now;
var enableDRresp = client.ReplicationProtectedItem.EnableProtection(
selectedFabric.Name,
priCld,
replicationProtectedItemName,
enableInput,
RequestHeaders);
MonitoringHelper.MonitorJobs(MonitoringHelper.SecondaryIrJobName, enableDRStartTime, client, RequestHeaders);
}
///////////////////////////// PFO ////////////////////////////////
PlannedFailoverInputProperties plannedFailoverProp = new PlannedFailoverInputProperties()
{
ProviderSpecificDetails = new ProviderSpecificFailoverInput()
};
PlannedFailoverInput plannedFailoverInput = new PlannedFailoverInput()
{
Properties = plannedFailoverProp
};
////////////////////////////// RR ////////////////////////////////
ReverseReplicationInputProperties rrProp = new ReverseReplicationInputProperties()
{
ProviderSpecificDetails = new ReverseReplicationProviderSpecificInput()
};
ReverseReplicationInput rrInput = new ReverseReplicationInput()
{
Properties = rrProp
};
////////////////////////////////// UFO /////////////////////////////
UnplannedFailoverInputProperties ufoProp = new UnplannedFailoverInputProperties()
{
ProviderSpecificDetails = new ProviderSpecificFailoverInput(),
SourceSiteOperations = "NotRequired"
};
UnplannedFailoverInput ufoInput = new UnplannedFailoverInput()
{
Properties = ufoProp
};
/////////////////////////////////// TFO //////////////////////////////
TestFailoverInputProperties tfoProp = new TestFailoverInputProperties()
{
ProviderSpecificDetails = new ProviderSpecificFailoverInput()
};
TestFailoverInput tfoInput = new TestFailoverInput()
{
Properties = tfoProp
};
/////////////////////////////////////
if (pfo)
{
var protectedItem = client.ReplicationProtectedItem.Get(
selectedFabric.Name,
priCld,
replicationProtectedItemName,
RequestHeaders);
var plannedfailover = client.ReplicationProtectedItem.PlannedFailover(selectedFabric.Name, priCld, replicationProtectedItemName, plannedFailoverInput, RequestHeaders);
//var unplannedFailoverReverse = client.ReplicationProtectedItem.UnplannedFailover(
// selectedFabric.Name,
// priCld,
// replicationProtectedItemName,
// ufoInput,
// RequestHeaders);
}
if (commit)
{
var commitFailover = client.ReplicationProtectedItem.CommitFailover(selectedFabric.Name, priCld, replicationProtectedItemName, RequestHeaders);
}
if (rr)
{
var rrOp = client.ReplicationProtectedItem.Reprotect(selectedFabric.Name, priCld, replicationProtectedItemName, rrInput, RequestHeaders);
}
if (pfoReverse)
{
//var unplannedFailoverReverse = client.ReplicationProtectedItem.UnplannedFailover(
// selectedFabric.Name, priCld, replicationProtectedItemName, ufoInput, RequestHeaders);
var plannedFailoverReverse = client.ReplicationProtectedItem.PlannedFailover(selectedFabric.Name, priCld, replicationProtectedItemName, plannedFailoverInput, RequestHeaders);
}
if (commitReverse)
{
var commitFailoverReverse = client.ReplicationProtectedItem.CommitFailover(selectedFabric.Name, priCld, replicationProtectedItemName, RequestHeaders);
}
if (rrReverse)
{
DateTime rrPostUfoStartTime = DateTime.UtcNow;
var rrReverseOp = client.ReplicationProtectedItem.Reprotect(selectedFabric.Name, priCld, replicationProtectedItemName, rrInput, RequestHeaders);
/*while (true)
{
Thread.Sleep(5000 * 60);
Job ufoJob = MonitoringHelper.GetJobId(
MonitoringHelper.ReverseReplicationJobName,
rrPostUfoStartTime,
client,
RequestHeaders);
if (ufoJob.Properties.StateDescription.Equals(
"WaitingForFinalizeProtection",
StringComparison.InvariantCultureIgnoreCase))
{
break;
}
}
MonitoringHelper.MonitorJobs(MonitoringHelper.PrimaryIrJobName, rrPostUfoStartTime, client, RequestHeaders);
MonitoringHelper.MonitorJobs(MonitoringHelper.SecondaryIrJobName, rrPostUfoStartTime, client, RequestHeaders);*/
}
if (tfo)
{
DateTime startTFO = DateTime.UtcNow;
var tfoOp = client.ReplicationProtectedItem.TestFailover(selectedFabric.Name, priCld, replicationProtectedItemName, tfoInput, RequestHeaders);
var jobs = MonitoringHelper.GetJobId(MonitoringHelper.TestFailoverJobName, startTFO, client, RequestHeaders);
ResumeJobParamsProperties resProp = new ResumeJobParamsProperties()
{
Comments = "Res TFO"
};
ResumeJobParams resParam = new ResumeJobParams()
{
Properties = resProp
};
var resJob = client.Jobs.Resume(jobs.Name, resParam, RequestHeaders);
}
if (disableDR)
{
var disableDROperation = client.ReplicationProtectedItem.DisableProtection(selectedFabric.Name, priCld, replicationProtectedItemName, new DisableProtectionInput(), RequestHeaders);
}
if (unpair)
{
var unpaiClouds = client.ProtectionContainerMapping.UnconfigureProtection(
selectedFabric.Name,
priCld,
mappingName,
new RemoveProtectionContainerMappingInput(),
RequestHeaders);
}
if (StorageClassificationUnmap)
{
var unmapStorageClassifications = client.StorageClassificationMapping.UnpairStorageClassification(selectedFabric.Name, selectedStorageClassification.Name, StorageClassificationMappingName, RequestHeaders);
}
if (removePolicy)
{
var policyDeletion = client.Policies.Delete(currentPolicy.Name, RequestHeaders);
}
}
}
/// <summary>
/// Starts job for mapping storage classification.
/// </summary>
/// <param name="primaryClassification">Primary classification.</param>
/// <param name="input">Mapping input.</param>
/// <param name="armName">Optional. ARM name of the mapping.</param>
/// <returns>Operation response.</returns>
public LongRunningOperationResponse MapStorageClassification(
ASRStorageClassification primaryClassification,
StorageClassificationMappingInput input,
string armName)
{
string[] tokens = primaryClassification.Id.UnFormatArmId(
ARMResourceIdPaths.StorageClassificationResourceIdPath);
return this.GetSiteRecoveryClient().StorageClassificationMapping
.BeginPairStorageClassification(
tokens[0],
tokens[1],
armName,
input,
this.GetRequestHeaders());
}
public static StorageClassificationMappingOperationResponse PairStorageClassification(
this SiteRecoveryManagementClient client,
Fabric primaryFabric,
StorageClassification primaryClassification,
StorageClassification recoveryClassification,
string armResourceName)
{
StorageClassificationMappingInputProperties props = new StorageClassificationMappingInputProperties()
{
TargetStorageClassificationId = recoveryClassification.Id
};
StorageClassificationMappingInput input = new StorageClassificationMappingInput()
{
Properties = props
};
return client.StorageClassificationMapping.PairStorageClassification(
primaryFabric.Name,
primaryClassification.Name,
armResourceName,
input,
GetRequestHeaders()) as StorageClassificationMappingOperationResponse;
}
public void PairUnpairStorageClassifications()
{
using (UndoContext context = UndoContext.Current)
{
context.Start();
var client = GetSiteRecoveryClient(CustomHttpHandler);
FabricListResponse responseServers = client.Fabrics.List(RequestHeaders);
foreach (Fabric fabric in responseServers.Fabrics)
{
if (fabric.Properties.CustomDetails.InstanceType == "VMM")
{
var storageClassifications = client.StorageClassification.List(fabric.Name, RequestHeaders);
if (storageClassifications.StorageClassifications.Count > 1)
{
StorageClassificationMappingInputProperties mapProps = new StorageClassificationMappingInputProperties()
{
TargetStorageClassificationId = storageClassifications.StorageClassifications[1].Id
};
StorageClassificationMappingInput mapInput = new StorageClassificationMappingInput()
{
Properties = mapProps
};
string mappingName = "StorageClassificationMapping-" + (new Random()).Next();
var pairResp = client.StorageClassificationMapping.PairStorageClassification(
fabric.Name,
storageClassifications.StorageClassifications[0].Name,
mappingName,
mapInput,
RequestHeaders);
var mappings = client.StorageClassificationMapping.List(
fabric.Name,
storageClassifications.StorageClassifications[0].Name,
RequestHeaders);
var mapping = client.StorageClassificationMapping.Get(
fabric.Name,
storageClassifications.StorageClassifications[0].Name,
mappings.StorageClassificationMappings[0].Name,
RequestHeaders);
var unpairResp = client.StorageClassificationMapping.UnpairStorageClassification(
fabric.Name,
storageClassifications.StorageClassifications[0].Name,
mappingName,
RequestHeaders);
}
}
}
}
}