/// <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(); }