/// <summary>
/// Merge attributes with source attribute collection.
/// </summary>
/// <param name="coll">Source attribute collection.</param>
/// <param name="res">The parameters determine the resolution of attributes name conflicts</param>
public void Merge(DDAttributesCollection coll, ResolveConflict res)
{
foreach (var item in coll)
{
Add(item.Key, item.Value, res);
}
}
/// <summary>
/// Moves current node as child to destination node. The current and the destination nodes should have the same root.
/// </summary>
/// <param name="destinationNode">destination node. New parent for current node</param>
public DDNode Move(DDNode destinationNode, ResolveConflict resolve)
{
throw new NotImplementedException();
//if (destinationNode == null) throw new DDNodeNullException();
//if (IsRoot) throw new DDNodeException("Cannot move root node.");
////****
//// need protect move to child node
//if (AreTheseNodesGrowFromATree(this, destinationNode) == false) throw new DDNodesBelongDifferentTrees(Name, destinationNode.Name);
//switch (resolve)
//{
// case ResolveConflict.OVERWRITE:
// if (destinationNode.Contains(Name))
// {
// Parent.Remove(Name); //remove self
// }
// break;
// case ResolveConflict.SKIP:
// if (destinationNode.Contains(Name))
// {
// return null; // return null because the node was not added
// }
// break;
//}
//try
//{
// Parent = destinationNode;
//}
//catch (ArgumentException e)
//{
// throw new DDNodeExistsException(Name, e);
//}
}
/// <summary>
/// Add the new value with name.
/// </summary>
/// <param name="name">uniq name for with value. If specified name exists in this collection the subsequent behavior depends of the specified rules</param>
/// <param name="value">value</param>
/// <param name="resolve">Rules of behavior in conflict resolution names.
/// Throw a new exception;
/// Update the existing value;
/// Skip this action and preserve exists value
/// </param>
/// <returns>If the value was successfully added or overwritten - returns name of this value, otherwise, for example, when used ResolveConflict.SKIP, returns null</returns>
/// <remarks>Generates events when overwriting or saving the current value</remarks>
public virtual string Add(string name, DDValue value, ResolveConflict resolve)
{
switch (resolve)
{
case ResolveConflict.OVERWRITE:
if (Contains(name))
{
//this.OnDoLogIn(Res.Msg.OVERWRITE_EXISTS_VALUE, name, value);
Remove(name); //remove exists name
}
break;
case ResolveConflict.SKIP:
if (this.Contains(name))
{
//this.OnDoLogIn(Res.Msg.PRESERVE_EXISTS_VALUE, name, value);
return(null); // return null because the item was not added
}
break;
}
try
{
attributes.Add(name, value);
}
catch (ArgumentException e)
{
throw new DDAttributeExistsException(name, e);
}
return(name); // return name of new value
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
Dictionary <Enum, object> providerParameters = new Dictionary <Enum, object>();
providerParameters.Add(VaultParams.VaultName, vaultName);
providerParameters.Add(VaultParams.ResourceGroupName, resourceGroupName);
providerParameters.Add(VaultParams.VaultLocation, VaultLocation);
providerParameters.Add(RestoreBackupItemParams.RecoveryPoint, RecoveryPoint);
providerParameters.Add(RestoreVMBackupItemParams.OsaOption, UseOriginalStorageAccount.IsPresent);
providerParameters.Add(RestoreFSBackupItemParams.ResolveConflict, ResolveConflict.ToString());
providerParameters.Add(RestoreFSBackupItemParams.SourceFilePath, SourceFilePath);
providerParameters.Add(RestoreFSBackupItemParams.TargetStorageAccountName, TargetStorageAccountName);
providerParameters.Add(RestoreFSBackupItemParams.TargetFileShareName, TargetFileShareName);
providerParameters.Add(RestoreFSBackupItemParams.TargetFolder, TargetFolder);
if (StorageAccountName != null)
{
providerParameters.Add(RestoreBackupItemParams.StorageAccountName, StorageAccountName);
}
if (StorageAccountResourceGroupName != null)
{
providerParameters.Add(RestoreBackupItemParams.StorageAccountResourceGroupName, StorageAccountResourceGroupName);
}
if (TargetResourceGroupName != null)
{
providerParameters.Add(RestoreVMBackupItemParams.TargetResourceGroupName, TargetResourceGroupName);
}
if (SourceFileType != null)
{
providerParameters.Add(RestoreFSBackupItemParams.SourceFileType, SourceFileType.ToString());
}
PsBackupProviderManager providerManager =
new PsBackupProviderManager(providerParameters, ServiceClientAdapter);
IPsBackupProvider psBackupProvider = providerManager.GetProviderInstance(
RecoveryPoint.WorkloadType, RecoveryPoint.BackupManagementType);
var jobResponse = psBackupProvider.TriggerRestore();
WriteDebug(string.Format("Restore submitted"));
HandleCreatedJob(
jobResponse,
Resources.RestoreOperation,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
}, ShouldProcess(RecoveryPoint.ItemName, VerbsData.Restore));
}
/// <summary>
/// Returns attributes collection contains merged all attributes from all parent nodes (including root node) for specific node
/// </summary>
/// <param name="n">node</param>
/// <param name="rc">conflict resolution</param>
public static DDAttributesCollection GetMergedParentAttributes(DDNode n, ResolveConflict rc)
{
var current = new DDAttributesCollection();
while (n != null)
{
current.Merge(n.Attributes, rc);
n = n.Parent;
}
return(current);
}
/// <summary>
/// Adds the specified node as child
/// </summary>
/// <param name="node">child node</param>
/// <param name="resolve">Rules of behavior in conflict resolution names.
/// Throw a new exception; <exception cref="DDNodeExistsException"/>
/// Update the existing value;
/// Skip this action and preserve exists node
/// </param>
/// <returns>added child node</returns>
/// <exception cref="DDNodeNullException"/>
public virtual DDNode Add(DDNode node, ResolveConflict resolve)
{
if (null == node)
{
throw new DDNodeNullException();
}
if (Equals(node))
{
throw new DDNodeAddSelf(node.Path);
}
if (node.Parent == null)
{
node.Parent = this;
}
else
if (!this.Equals(node.Parent))
{
throw new DDNodeAddNodeWithParent(node.Path);
}
switch (resolve)
{
case ResolveConflict.OVERWRITE:
if (Contains(node.Name))
{
Remove(node.Name); //remove exists node
}
break;
case ResolveConflict.SKIP:
if (this.Contains(node.Name))
{
return(null); // return null because the node was not added
}
break;
}
try
{
childNodes.Add(node.Name, node);
}
catch (ArgumentException e)
{
throw new DDNodeExistsException(node.Name, e);
}
return(node);
}
/// <summary>
/// Deserializes and returns the object's value, using the provided deserializer.
/// </summary>
/// <typeparam name="T">The value's target type.</typeparam>
/// <param name="deserializeObject">A delegate to handle deserialization of an byte[] serialized object to it's original type.</param>
/// <param name="resolveConflict">
/// A delegate to handle resolution of sibling objects.
/// Takes all the sibling objects as input and returns one "resolved" object.
/// </param>
/// <returns>The deserialized value.</returns>
public T GetObject <T>(DeserializeObject <T> deserializeObject, ResolveConflict <T> resolveConflict = null)
{
if (deserializeObject == null)
{
throw new ArgumentException("deserializeObject must not be null");
}
if (Siblings.Count > 1 && resolveConflict != null)
{
var conflictedObjects = Siblings.Select(s => deserializeObject(s.Value, ContentType)).ToList();
return(resolveConflict(conflictedObjects));
}
return(deserializeObject(Value, ContentType));
}
/// <summary>
/// Merges all attributes from all parent nodes (including root node) for attribute collection of specific node
/// </summary>
/// <param name="n">node</param>
/// <param name="mergeParentAttributes">Merges all attributes from all parent nodes (including root node) for attribute collection of cloned node only</param>
/// <param name="rc">conflict resolution for merge attributes</param>
/// <returns>The cloned node.</returns>
public virtual DDNode Clone(bool deep, bool mergeParentAttributes, ResolveConflict rc)
{
var newNode = new DDNode(this.Name, this.Type);
if ((HasAttributes) && (!mergeParentAttributes))
{
newNode.attributes = (DDAttributesCollection)Attributes.Clone();
}
if (mergeParentAttributes)
{
newNode.attributes = GetMergedParentAttributes(this, rc);
}
if (deep)
{
foreach (var childNode in this)
{
newNode.Add(childNode.Value.Clone(true));
}
}
return(newNode);
}
/// <summary>
/// Merge data with source node
/// </summary>
/// <param name="node">Source node. Node will be taken to transfer the data to destination node</param>
/// <param name="option">Options of merge nodes</param>
/// <param name="res">The option determine the resolution of conflicts of merge nodes</param>
public void Merge(DDNode node, DDNODE_MERGE_OPTION option, ResolveConflict res)
{
var bMergeAttributes = ((option & DDNODE_MERGE_OPTION.ATTRIBUTES) == DDNODE_MERGE_OPTION.ATTRIBUTES);
if (bMergeAttributes)
{
Attributes.Merge(node.Attributes, res); // merge attributes
}
if ((option & DDNODE_MERGE_OPTION.CHILD_NODES) == DDNODE_MERGE_OPTION.CHILD_NODES)
{
foreach (var item in node)
{
if (!Contains(item.Key)) // if child node doesn't exists
{
DDNode newNode;
if (bMergeAttributes) // if need to copy attributes -> copy all: hierarchy and attributes
{
newNode = item.Value.Clone(true);
Add(newNode);
}
else // if need to copy only hierarchy
{
newNode = Add(item.Value.Name);
newNode.Merge(item.Value, option, res);
}
}
else
{
if (res == ResolveConflict.THROW_EXCEPTION)
{
throw new DDNodeMergeNameException(item.Value.Name, Path);
}
//if (res == ResolveConflict.SKIP) continue ; // skip only attributes. this line must be commented
GetNode(item.Value.Name).Merge(item.Value, option, res);
}
}
}
}
/// <summary>
/// Add the new value by name.
/// </summary>
/// <param name="name">uniq name for with value. If specified name exists in this collection the subsequent behavior depends of the specified rules</param>
/// <param name="value">value</param>
/// <param name="resolve">Rules of behavior in conflict resolution names.
/// Throw a new exception;
/// Update the existing value;
/// Skip this action and preserve exists value
/// </param>
/// <returns>If the value was successfully added or overwritten - returns name of this value, otherwise, for example, when used ResolveConflict.SKIP, returns null</returns>
/// <remarks>Generates events when overwriting or saving the current value</remarks>
public virtual string Add(Enum name, DDValue value, ResolveConflict resolve)
{
return(Add(name.ToString(), value, resolve));
}
private void TestMergeNodeWithAnotherNode(DDNode nDestination, DDNode.DDNODE_MERGE_OPTION option, ResolveConflict res)
{
var nSource = XMLDeserialize(UTestDrDataCommon.GetMemoryStreamFromFile(".\\XML\\" + UTestDrDataCommon.GetTestMethodName() + ".Source.xml"));
UTestDrDataCommon.WriteMemmoryStreamToFile(XMLSerialize(nDestination), UTestDrDataCommon.GetTestMethodName() + ".Destination.xml");
UTestDrDataCommon.WriteMemmoryStreamToFile(XMLSerialize(nSource), UTestDrDataCommon.GetTestMethodName() + ".Source.xml");
nDestination.Merge(nSource, option, res);
UTestDrDataCommon.WriteMemmoryStreamToFile(XMLSerialize(nDestination), UTestDrDataCommon.GetTestMethodName() + ".Actual.xml");
var nExpected = XMLDeserialize(UTestDrDataCommon.GetMemoryStreamFromFile(".\\XML\\" + UTestDrDataCommon.GetTestMethodName() + ".Expected.xml"));
UTestDrDataCommon.WriteMemmoryStreamToFile(XMLSerialize(nExpected), UTestDrDataCommon.GetTestMethodName() + ".Expected.xml");
Assert.IsTrue(nDestination == nExpected, "The actual node is not equal expected node. See xml files in the bin folder.");
}
private void TestMergeStockCollectionWithAnotherCollection(DDNode.DDNODE_MERGE_OPTION option, ResolveConflict res)
{
TestMergeNodeWithAnotherNode(GetStockHierarhy(), option, res);
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
Dictionary <Enum, object> providerParameters = new Dictionary <Enum, object>();
string secondaryRegion = "";
if (RestoreToSecondaryRegion.IsPresent)
{
ARSVault vault = ServiceClientAdapter.GetVault(resourceGroupName, vaultName);
secondaryRegion = BackupUtils.regionMap[vault.Location];
providerParameters.Add(CRRParams.SecondaryRegion, secondaryRegion);
}
if (RehydratePriority != null)
{
Logger.Instance.WriteDebug("Rehydrate priority is " + RehydratePriority);
int rehydrateExpiryInDays = Int32.Parse(RehydrateDuration); // Rehydrate duration is taken as days
if (rehydrateExpiryInDays < 10 || rehydrateExpiryInDays > 30)
{
throw new ArgumentException(Resources.InvalidRehydrateDuration);
}
providerParameters.Add(RecoveryPointParams.RehydrateDuration, RehydrateDuration);
providerParameters.Add(RecoveryPointParams.RehydratePriority, RehydratePriority);
}
if (UseSystemAssignedIdentity.IsPresent || UserAssignedIdentityId != null)
{
if (UseSystemAssignedIdentity.IsPresent && UserAssignedIdentityId != null)
{
throw new ArgumentException(Resources.MultipleMSIProvidedForRestore);
}
/*if (UseSystemAssignedIdentity.IsPresent)
* {
* // check to be added on vault.Identity
* }
* else
* {
* // check whether given User MSI is present on vault
* }*/
}
string RestoreType = null;
if (string.Compare(ParameterSetName, AzureManagedVMReplaceExistingParameterSet) == 0)
{
RestoreType = "OriginalLocation";
}
providerParameters.Add(VaultParams.VaultName, vaultName);
providerParameters.Add(VaultParams.ResourceGroupName, resourceGroupName);
providerParameters.Add(VaultParams.VaultLocation, VaultLocation);
providerParameters.Add(RestoreBackupItemParams.RecoveryPoint, RecoveryPoint);
providerParameters.Add(RestoreVMBackupItemParams.OsaOption, UseOriginalStorageAccount.IsPresent);
providerParameters.Add(RestoreFSBackupItemParams.ResolveConflict, ResolveConflict.ToString());
providerParameters.Add(RestoreFSBackupItemParams.SourceFilePath, SourceFilePath);
providerParameters.Add(RestoreFSBackupItemParams.TargetStorageAccountName, TargetStorageAccountName);
providerParameters.Add(RestoreFSBackupItemParams.TargetFileShareName, TargetFileShareName);
providerParameters.Add(RestoreFSBackupItemParams.TargetFolder, TargetFolder);
providerParameters.Add(RestoreWLBackupItemParams.WLRecoveryConfig, WLRecoveryConfig);
providerParameters.Add(RestoreVMBackupItemParams.RestoreDiskList, RestoreDiskList);
providerParameters.Add(RestoreVMBackupItemParams.RestoreOnlyOSDisk, RestoreOnlyOSDisk);
providerParameters.Add(RestoreVMBackupItemParams.RestoreAsUnmanagedDisks, RestoreAsUnmanagedDisks);
providerParameters.Add(CRRParams.UseSecondaryRegion, RestoreToSecondaryRegion.IsPresent);
providerParameters.Add(RestoreVMBackupItemParams.RestoreAsManagedDisk, RestoreAsManagedDisk.IsPresent);
providerParameters.Add(RestoreVMBackupItemParams.UseSystemAssignedIdentity, UseSystemAssignedIdentity.IsPresent);
providerParameters.Add(RestoreVMBackupItemParams.UserAssignedIdentityId, UserAssignedIdentityId);
providerParameters.Add(RestoreVMBackupItemParams.RestoreType, RestoreType);
providerParameters.Add(RestoreVMBackupItemParams.TargetVMName, TargetVMName);
providerParameters.Add(RestoreVMBackupItemParams.TargetVNetName, TargetVNetName);
providerParameters.Add(RestoreVMBackupItemParams.TargetVNetResourceGroup, TargetVNetResourceGroup);
providerParameters.Add(RestoreVMBackupItemParams.TargetSubnetName, TargetSubnetName);
if (DiskEncryptionSetId != null)
{
AzureVmRecoveryPoint rp = (AzureVmRecoveryPoint)RecoveryPoint;
ServiceClientModel.BackupResourceEncryptionConfigExtendedResource vaultEncryptionSettings = ServiceClientAdapter.GetVaultEncryptionConfig(resourceGroupName, vaultName);
if ((vaultEncryptionSettings.Properties.EncryptionAtRestType == "CustomerManaged") && rp.IsManagedVirtualMachine && !(rp.EncryptionEnabled) && !(RestoreToSecondaryRegion.IsPresent))
{
providerParameters.Add(RestoreVMBackupItemParams.DiskEncryptionSetId, DiskEncryptionSetId);
}
}
if (TargetZoneNumber != null)
{
// get storage type
ServiceClientModel.BackupResourceConfigResource getStorageResponse = ServiceClientAdapter.GetVaultStorageType(resourceGroupName, vaultName);
string storageType = getStorageResponse.Properties.StorageType;
bool crrEnabled = (bool)getStorageResponse.Properties.CrossRegionRestoreFlag;
if (storageType == AzureRmRecoveryServicesBackupStorageRedundancyType.ZoneRedundant.ToString() ||
(storageType == AzureRmRecoveryServicesBackupStorageRedundancyType.GeoRedundant.ToString() && crrEnabled))
{
AzureVmRecoveryPoint rp = (AzureVmRecoveryPoint)RecoveryPoint;
if (rp.RecoveryPointTier == RecoveryPointTier.VaultStandard) // RP recovery type should be vault only
{
if (rp.Zones != null)
{
//target region should support Zones
/*if (RestoreToSecondaryRegion.IsPresent)
* {
* FeatureSupportRequest iaasvmFeatureRequest = new FeatureSupportRequest();
* ServiceClientAdapter.BmsAdapter.Client.FeatureSupport.ValidateWithHttpMessagesAsync(secondaryRegion, iaasvmFeatureRequest);
* }*/
providerParameters.Add(RecoveryPointParams.TargetZone, TargetZoneNumber);
}
else
{
throw new ArgumentException(string.Format(Resources.RecoveryPointZonePinnedException));
}
}
else
{
throw new ArgumentException(string.Format(Resources.RecoveryPointVaultRecoveryTypeException));
}
}
else
{
throw new ArgumentException(string.Format(Resources.ZonalRestoreVaultStorageRedundancyException));
}
}
if (StorageAccountName != null)
{
providerParameters.Add(RestoreBackupItemParams.StorageAccountName, StorageAccountName);
}
if (StorageAccountResourceGroupName != null)
{
providerParameters.Add(RestoreBackupItemParams.StorageAccountResourceGroupName, StorageAccountResourceGroupName);
}
if (TargetResourceGroupName != null)
{
providerParameters.Add(RestoreVMBackupItemParams.TargetResourceGroupName, TargetResourceGroupName);
}
if (SourceFileType != null)
{
providerParameters.Add(RestoreFSBackupItemParams.SourceFileType, SourceFileType.ToString());
}
if (MultipleSourceFilePath != null)
{
providerParameters.Add(RestoreFSBackupItemParams.MultipleSourceFilePath, MultipleSourceFilePath);
}
PsBackupProviderManager providerManager =
new PsBackupProviderManager(providerParameters, ServiceClientAdapter);
IPsBackupProvider psBackupProvider = null;
if (string.Compare(ParameterSetName, AzureWorkloadParameterSet) != 0)
{
psBackupProvider = providerManager.GetProviderInstance(
RecoveryPoint.WorkloadType, RecoveryPoint.BackupManagementType);
}
else
{
psBackupProvider = providerManager.GetProviderInstance(
WorkloadType.MSSQL, BackupManagementType.AzureWorkload);
}
var jobResponse = psBackupProvider.TriggerRestore();
if (RestoreToSecondaryRegion.IsPresent)
{
var operationId = jobResponse.Request.RequestUri.Segments.Last();
var response = ServiceClientAdapter.GetCrrOperationStatus(secondaryRegion, operationId);
string jobIdJson = JsonConvert.SerializeObject(response.Body.Properties);
string[] jobSplits = jobIdJson.Split(new char[] { '\"' });
string jobId = jobSplits[jobSplits.Length - 2];
WriteObject(GetCrrJobObject(secondaryRegion, VaultId, jobId));
}
else
{
HandleCreatedJob(
jobResponse,
Resources.RestoreOperation,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
}
}, ShouldProcess(RecoveryPoint != null ? RecoveryPoint.ItemName : WLRecoveryConfig.ToString(), VerbsData.Restore));
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
Dictionary <Enum, object> providerParameters = new Dictionary <Enum, object>();
string secondaryRegion = "";
if (RestoreToSecondaryRegion.IsPresent)
{
ARSVault vault = ServiceClientAdapter.GetVault(resourceGroupName, vaultName);
secondaryRegion = BackupUtils.regionMap[vault.Location];
providerParameters.Add(CRRParams.SecondaryRegion, secondaryRegion);
}
providerParameters.Add(VaultParams.VaultName, vaultName);
providerParameters.Add(VaultParams.ResourceGroupName, resourceGroupName);
providerParameters.Add(VaultParams.VaultLocation, VaultLocation);
providerParameters.Add(RestoreBackupItemParams.RecoveryPoint, RecoveryPoint);
providerParameters.Add(RestoreVMBackupItemParams.OsaOption, UseOriginalStorageAccount.IsPresent);
providerParameters.Add(RestoreFSBackupItemParams.ResolveConflict, ResolveConflict.ToString());
providerParameters.Add(RestoreFSBackupItemParams.SourceFilePath, SourceFilePath);
providerParameters.Add(RestoreFSBackupItemParams.TargetStorageAccountName, TargetStorageAccountName);
providerParameters.Add(RestoreFSBackupItemParams.TargetFileShareName, TargetFileShareName);
providerParameters.Add(RestoreFSBackupItemParams.TargetFolder, TargetFolder);
providerParameters.Add(RestoreWLBackupItemParams.WLRecoveryConfig, WLRecoveryConfig);
providerParameters.Add(RestoreVMBackupItemParams.RestoreDiskList, RestoreDiskList);
providerParameters.Add(RestoreVMBackupItemParams.RestoreOnlyOSDisk, RestoreOnlyOSDisk);
providerParameters.Add(RestoreVMBackupItemParams.RestoreAsUnmanagedDisks, RestoreAsUnmanagedDisks);
providerParameters.Add(CRRParams.UseSecondaryRegion, RestoreToSecondaryRegion.IsPresent);
if (DiskEncryptionSetId != null)
{
AzureVmRecoveryPoint rp = (AzureVmRecoveryPoint)RecoveryPoint;
BackupResourceEncryptionConfigResource vaultEncryptionSettings = ServiceClientAdapter.GetVaultEncryptionConfig(resourceGroupName, vaultName);
if ((vaultEncryptionSettings.Properties.EncryptionAtRestType == "CustomerManaged") && rp.IsManagedVirtualMachine && !(rp.EncryptionEnabled) && !(RestoreToSecondaryRegion.IsPresent))
{
providerParameters.Add(RestoreVMBackupItemParams.DiskEncryptionSetId, DiskEncryptionSetId);
}
}
if (StorageAccountName != null)
{
providerParameters.Add(RestoreBackupItemParams.StorageAccountName, StorageAccountName);
}
if (StorageAccountResourceGroupName != null)
{
providerParameters.Add(RestoreBackupItemParams.StorageAccountResourceGroupName, StorageAccountResourceGroupName);
}
if (TargetResourceGroupName != null)
{
providerParameters.Add(RestoreVMBackupItemParams.TargetResourceGroupName, TargetResourceGroupName);
}
if (SourceFileType != null)
{
providerParameters.Add(RestoreFSBackupItemParams.SourceFileType, SourceFileType.ToString());
}
if (MultipleSourceFilePath != null)
{
providerParameters.Add(RestoreFSBackupItemParams.MultipleSourceFilePath, MultipleSourceFilePath);
}
PsBackupProviderManager providerManager =
new PsBackupProviderManager(providerParameters, ServiceClientAdapter);
IPsBackupProvider psBackupProvider = null;
if (string.Compare(ParameterSetName, AzureWorkloadParameterSet) != 0)
{
psBackupProvider = providerManager.GetProviderInstance(
RecoveryPoint.WorkloadType, RecoveryPoint.BackupManagementType);
}
else
{
psBackupProvider = providerManager.GetProviderInstance(
WorkloadType.MSSQL, BackupManagementType.AzureWorkload);
}
var jobResponse = psBackupProvider.TriggerRestore();
if (RestoreToSecondaryRegion.IsPresent)
{
var operationId = jobResponse.Request.RequestUri.Segments.Last();
var response = ServiceClientAdapter.GetCrrOperationStatus(secondaryRegion, operationId);
string jobIDJson = JsonConvert.SerializeObject(response.Body.Properties);
string[] jobSplits = jobIDJson.Split(new char[] { '\"' });
string jobID = jobSplits[jobSplits.Length - 2];
WriteObject(GetCrrJobObject(secondaryRegion, VaultId, jobID));
}
else
{
HandleCreatedJob(
jobResponse,
Resources.RestoreOperation,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
}
}, ShouldProcess(RecoveryPoint != null ? RecoveryPoint.ItemName : WLRecoveryConfig.ToString(), VerbsData.Restore));
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
Dictionary <Enum, object> providerParameters = new Dictionary <Enum, object>();
providerParameters.Add(VaultParams.VaultName, vaultName);
providerParameters.Add(VaultParams.ResourceGroupName, resourceGroupName);
providerParameters.Add(VaultParams.VaultLocation, VaultLocation);
providerParameters.Add(RestoreBackupItemParams.RecoveryPoint, RecoveryPoint);
providerParameters.Add(RestoreVMBackupItemParams.OsaOption, UseOriginalStorageAccount.IsPresent);
providerParameters.Add(RestoreFSBackupItemParams.ResolveConflict, ResolveConflict.ToString());
providerParameters.Add(RestoreFSBackupItemParams.SourceFilePath, SourceFilePath);
providerParameters.Add(RestoreFSBackupItemParams.TargetStorageAccountName, TargetStorageAccountName);
providerParameters.Add(RestoreFSBackupItemParams.TargetFileShareName, TargetFileShareName);
providerParameters.Add(RestoreFSBackupItemParams.TargetFolder, TargetFolder);
providerParameters.Add(RestoreWLBackupItemParams.WLRecoveryConfig, WLRecoveryConfig);
providerParameters.Add(RestoreVMBackupItemParams.RestoreDiskList, RestoreDiskList);
providerParameters.Add(RestoreVMBackupItemParams.RestoreOnlyOSDisk, RestoreOnlyOSDisk);
providerParameters.Add(RestoreVMBackupItemParams.RestoreAsUnmanagedDisks, RestoreAsUnmanagedDisks);
if (DiskEncryptionSetId != null)
{
AzureVmRecoveryPoint rp = (AzureVmRecoveryPoint)RecoveryPoint;
BackupResourceEncryptionConfigResource vaultEncryptionSettings = ServiceClientAdapter.GetVaultEncryptionConfig(resourceGroupName, vaultName);
// do not allow for CRR - to be added
if ((vaultEncryptionSettings.Properties.EncryptionAtRestType == "CustomerManaged") && rp.IsManagedVirtualMachine && !(rp.EncryptionEnabled))
{
providerParameters.Add(RestoreVMBackupItemParams.DiskEncryptionSetId, DiskEncryptionSetId);
}
}
if (StorageAccountName != null)
{
providerParameters.Add(RestoreBackupItemParams.StorageAccountName, StorageAccountName);
}
if (StorageAccountResourceGroupName != null)
{
providerParameters.Add(RestoreBackupItemParams.StorageAccountResourceGroupName, StorageAccountResourceGroupName);
}
if (TargetResourceGroupName != null)
{
providerParameters.Add(RestoreVMBackupItemParams.TargetResourceGroupName, TargetResourceGroupName);
}
if (SourceFileType != null)
{
providerParameters.Add(RestoreFSBackupItemParams.SourceFileType, SourceFileType.ToString());
}
if (MultipleSourceFilePath != null)
{
providerParameters.Add(RestoreFSBackupItemParams.MultipleSourceFilePath, MultipleSourceFilePath);
}
PsBackupProviderManager providerManager =
new PsBackupProviderManager(providerParameters, ServiceClientAdapter);
IPsBackupProvider psBackupProvider = null;
if (string.Compare(ParameterSetName, AzureWorkloadParameterSet) != 0)
{
psBackupProvider = providerManager.GetProviderInstance(
RecoveryPoint.WorkloadType, RecoveryPoint.BackupManagementType);
}
else
{
psBackupProvider = providerManager.GetProviderInstance(
WorkloadType.MSSQL, BackupManagementType.AzureWorkload);
}
var jobResponse = psBackupProvider.TriggerRestore();
WriteDebug(string.Format("Restore submitted"));
HandleCreatedJob(
jobResponse,
Resources.RestoreOperation,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
}, ShouldProcess(RecoveryPoint != null ? RecoveryPoint.ItemName : WLRecoveryConfig.ToString(), VerbsData.Restore));
}
public DDNode Copy(DDNode destinationNode, ResolveConflict resolve)
{
throw new NotImplementedException();
}
