public IList <SQLDataDirectory> GetRpDetails(string vaultName, string resourceGroupName)
{
Dictionary <UriEnums, string> uriDict = HelperUtils.ParseUri(RecoveryPoint.Id);
string containerUri = HelperUtils.GetContainerUri(uriDict, RecoveryPoint.Id);
string protectedItemName = HelperUtils.GetProtectedItemUri(uriDict, RecoveryPoint.Id);
var rpResponse = ServiceClientAdapter.GetRecoveryPointDetails(
containerUri,
protectedItemName,
RecoveryPoint.RecoveryPointId,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
AzureWorkloadSQLRecoveryPoint recoveryPoint = rpResponse.Properties as AzureWorkloadSQLRecoveryPoint;
return(recoveryPoint.ExtendedInfo.DataDirectoryPaths);
}
public override void ExecuteCmdlet()
{
try
{
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
BackupResourceVaultConfigResource result = ServiceClientAdapter.GetVaultProperty(vaultName, resourceGroupName);
WriteObject(result.Properties);
}
catch (Exception exception)
{
WriteExceptionError(exception);
}
}
private List <ProtectableContainerResource> GetUnRegisteredVmContainers(string vaultName = null,
string vaultResourceGroupName = null)
{
ODataQuery <BMSContainerQueryObject> queryParams = null;
queryParams = new ODataQuery <BMSContainerQueryObject>(
q => q.BackupManagementType == ServiceClientModel.BackupManagementType.AzureWorkload);
var listResponse = ServiceClientAdapter.ListUnregisteredContainers(
queryParams,
vaultName: vaultName,
resourceGroupName: vaultResourceGroupName);
List <ProtectableContainerResource> containerModels = listResponse.ToList();
return(containerModels);
}
private List <ContainerBase> GetRegisteredStorageAccounts(string vaultName = null,
string vaultResourceGroupName = null)
{
ODataQuery <BMSContainerQueryObject> queryParams = null;
queryParams = new ODataQuery <BMSContainerQueryObject>(
q => q.BackupManagementType == ServiceClientModel.BackupManagementType.AzureStorage);
var listResponse = ServiceClientAdapter.ListContainers(
queryParams,
vaultName: vaultName,
resourceGroupName: vaultResourceGroupName);
List <ContainerBase> containerModels = ConversionHelpers.GetContainerModelList(listResponse);
return(containerModels);
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
if (ParameterSetName == JobFilterSet)
{
JobId = Job.JobId;
}
WriteDebug("Fetching job with ID: " + JobId);
var adapterResponse = ServiceClientAdapter.GetJob(JobId);
WriteObject(JobConversions.GetPSJob(adapterResponse));
});
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
string containerName = Container != null ? Container.Name : ResourceId.Split('/')[8];
ConfirmAction(
Force.IsPresent,
string.Format(Resources.RegisterContainerWarning, containerName),
Resources.RegisterContainerMessage,
containerName, () =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string vaultResourceGroupName = resourceIdentifier.ResourceGroupName;
PsBackupProviderManager providerManager =
new PsBackupProviderManager(new Dictionary <Enum, object>()
{
{ VaultParams.VaultName, vaultName },
{ VaultParams.ResourceGroupName, vaultResourceGroupName },
{ ContainerParams.Name, containerName },
{ ContainerParams.ContainerType, ServiceClientHelpers.GetServiceClientWorkloadType(WorkloadType).ToString() },
{ ContainerParams.BackupManagementType, BackupManagementType.ToString() },
{ ContainerParams.Container, Container }
}, ServiceClientAdapter);
IPsBackupProvider psBackupProvider =
providerManager.GetProviderInstance(WorkloadType, BackupManagementType);
psBackupProvider.RegisterContainer();
// List containers
string backupManagementType = BackupManagementType.ToString();
ODataQuery <BMSContainerQueryObject> queryParams = new ODataQuery <BMSContainerQueryObject>(
q => q.FriendlyName == containerName &&
q.BackupManagementType == backupManagementType);
var listResponse = ServiceClientAdapter.ListContainers(queryParams,
vaultName: vaultName, resourceGroupName: vaultResourceGroupName);
var containerModels = ConversionHelpers.GetContainerModelList(listResponse);
WriteObject(containerModels, enumerateCollection: true);
});
}, ShouldProcess(ResourceId, VerbsLifecycle.Register));
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
if (Container.ContainerType != ContainerType.Windows || Container.BackupManagementType
!= BackupManagementType.MARS)
{
throw new ArgumentException(String.Format(Resources.UnsupportedContainerException,
Container.ContainerType, Container.BackupManagementType));
}
MabContainer mabContainer =
Container as MabContainer;
string containerName = mabContainer.Name;
ServiceClientAdapter.UnregisterContainers(containerName);
});
}
/// <summary>
/// Fetches policies by name
/// </summary>
/// <param name="policyName">Name of the policy to be fetched</param>
/// <param name="serviceClientAdapter">Service client adapter with which to make calls</param>
/// <param name="vaultName"></param>
/// <param name="resourceGroupName"></param>
/// <returns></returns>
public static ProtectionPolicyResource GetProtectionPolicyByName(
string policyName,
ServiceClientAdapter serviceClientAdapter,
string vaultName = null,
string resourceGroupName = null)
{
ProtectionPolicyResource response = null;
try
{
response = serviceClientAdapter.GetProtectionPolicy(
policyName,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
Logger.Instance.WriteDebug("Successfully fetched policy from service: " + policyName);
}
catch (AggregateException exception)
{
// if http response is NotFound - then ignore and return NULL response
if (exception.InnerException != null && exception.InnerException is CloudException)
{
var cloudEx = exception.InnerException as CloudException;
if (cloudEx.Response != null)
{
if (cloudEx.Response.StatusCode != SystemNet.HttpStatusCode.NotFound)
{
Logger.Instance.WriteDebug("CloudException Response statusCode: " +
cloudEx.Response.StatusCode);
throw;
}
}
else
{
throw;
}
}
else
{
throw;
}
}
return(response);
}
public override void ExecuteCmdlet()
{
if (ParameterSetName == JobFilterSet)
{
JobId = Job.JobId;
}
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
WriteDebug("Stopping job with ID: " + JobId);
var cancelResponse = ServiceClientAdapter.CancelJob(
JobId,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
var operationStatus = TrackingHelpers.GetOperationResult(
cancelResponse,
operationId => ServiceClientAdapter.GetCancelJobOperationResult(
operationId,
vaultName: vaultName,
resourceGroupName: resourceGroupName));
if (operationStatus.Response.StatusCode != HttpStatusCode.NoContent)
{
throw new Exception(string.Format(Resources.JobCouldNotCancelJob,
cancelResponse.Response.StatusCode.ToString()));
}
else
{
WriteObject(JobConversions.GetPSJob(ServiceClientAdapter.GetJob(
JobId,
vaultName: vaultName,
resourceGroupName: resourceGroupName)));
}
}, ShouldProcess(JobId, "Stop"));
}
/// <summary>
/// Initializes the service clients and the logging utility
/// </summary>
protected void InitializeAzureBackupCmdlet()
{
ServiceClientAdapter = new ServiceClientAdapter(DefaultContext);
WriteDebug("Inside Restore. Going to create ResourceClient.");
RmClient = AzureSession.Instance.ClientFactory.CreateArmClient <ResourcesNS.ResourceManagementClient>(DefaultContext, AzureEnvironment.Endpoint.ResourceManager);
// use dependency injection to override the behavior of GetGuid in a test context
var getGuidComponent = _guid;
if (AzureSession.Instance.TryGetComponent(GetGuidComponentName, out getGuidComponent))
{
_guid = getGuidComponent;
}
WriteDebug("Client Created successfully");
Logger.Instance = new Logger(WriteWarning, WriteDebug, WriteVerbose, WriteError, ThrowTerminatingError);
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
try
{
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
if (SoftDeleteFeatureState != null)
{
BackupResourceVaultConfigResource currentConfig = ServiceClientAdapter.GetVaultProperty(vaultName, resourceGroupName);
BackupResourceVaultConfigResource param = new BackupResourceVaultConfigResource();
param.Properties = new BackupResourceVaultConfig();
param.Properties.SoftDeleteFeatureState = SoftDeleteFeatureState + "d";
param.Properties.EnhancedSecurityState = currentConfig.Properties.EnhancedSecurityState;
BackupResourceVaultConfigResource result = ServiceClientAdapter.SetVaultProperty(vaultName, resourceGroupName, param);
WriteObject(result.Properties);
}
else if (EncryptionKeyId != null)
{
BackupResourceEncryptionConfigResource vaultEncryptionSettings = new BackupResourceEncryptionConfigResource();
vaultEncryptionSettings.Properties = new BackupResourceEncryptionConfig();
vaultEncryptionSettings.Properties.EncryptionAtRestType = "CustomerManaged";
vaultEncryptionSettings.Properties.KeyUri = EncryptionKeyId;
if (InfrastructureEncryption.IsPresent)
{
vaultEncryptionSettings.Properties.InfrastructureEncryptionState = "Enabled";
}
vaultEncryptionSettings.Properties.SubscriptionId = KeyVaultSubscriptionId;
vaultEncryptionSettings.Properties.LastUpdateStatus = null;
var response = ServiceClientAdapter.UpdateVaultEncryptionConfig(resourceGroupName, vaultName, vaultEncryptionSettings);
}
}
catch (Exception exception)
{
WriteExceptionError(exception);
}
}, ShouldProcess(VaultId, VerbsCommon.Set));
}
public RestAzureNS.AzureOperationResponse TriggerBackup()
{
string vaultName = (string)ProviderData[VaultParams.VaultName];
string vaultResourceGroupName = (string)ProviderData[VaultParams.ResourceGroupName];
ItemBase item = (ItemBase)ProviderData[ItemParams.Item];
DateTime? expiryDateTime = (DateTime?)ProviderData[ItemParams.ExpiryDateTimeUTC];
AzureFileShareItem azureFileShareItem = item as AzureFileShareItem;
BackupRequestResource triggerBackupRequest = new BackupRequestResource();
AzureFileShareBackupRequest azureFileShareBackupRequest = new AzureFileShareBackupRequest();
azureFileShareBackupRequest.RecoveryPointExpiryTimeInUTC = expiryDateTime;
triggerBackupRequest.Properties = azureFileShareBackupRequest;
return(ServiceClientAdapter.TriggerBackup(
IdUtils.GetValueByName(azureFileShareItem.Id, IdUtils.IdNames.ProtectionContainerName),
IdUtils.GetValueByName(azureFileShareItem.Id, IdUtils.IdNames.ProtectedItemName),
triggerBackupRequest,
vaultName: vaultName,
resourceGroupName: vaultResourceGroupName));
}
public override void ExecuteCmdlet()
{
try
{
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
BackupResourceEncryptionConfigExtendedResource vaultEncryptionSetting = ServiceClientAdapter.GetVaultEncryptionConfig(resourceGroupName, vaultName);
BackupResourceVaultConfigResource vaultConfigResource = ServiceClientAdapter.GetVaultProperty(vaultName, resourceGroupName);
VaultProperty vaultProperty = new VaultProperty(vaultConfigResource.Properties, vaultEncryptionSetting);
WriteObject(vaultProperty);
}
catch (Exception exception)
{
WriteExceptionError(exception);
}
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
try
{
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
string resourceGuardMappingName = "VaultProxy";
Rest.Azure.AzureOperationResponse result = ServiceClientAdapter.DeleteResourceGuardMapping(vaultName, resourceGroupName, resourceGuardMappingName, Token);
WriteObject(result);
}
catch (Exception exception)
{
WriteExceptionError(exception);
}
}, ShouldProcess("ResourceGuardMapping", VerbsCommon.Remove));
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
// fetch source vault and target vault subscription
Dictionary <CmdletModel.UriEnums, string> SourceVaultDict = HelperUtils.ParseUri(SourceVault.ID);
string sourceSub = SourceVaultDict[CmdletModel.UriEnums.Subscriptions];
// change subscription for HTTP requests
string subscriptionContext = ServiceClientAdapter.BmsAdapter.Client.SubscriptionId;
// Prepare Data Move
ServiceClientAdapter.BmsAdapter.Client.SubscriptionId = sourceSub;
PrepareDataMoveRequest prepareMoveRequest = new PrepareDataMoveRequest();
prepareMoveRequest.TargetResourceId = TargetVault.ID;
prepareMoveRequest.TargetRegion = TargetVault.Location;
/// currently only allowing vault level data move
prepareMoveRequest.DataMoveLevel = "Vault";
if (RetryOnlyFailed.IsPresent)
{
prepareMoveRequest.IgnoreMoved = true;
}
else
{
prepareMoveRequest.IgnoreMoved = false;
}
Logger.Instance.WriteDebug("Retry only with failed items : " + prepareMoveRequest.IgnoreMoved);
Logger.Instance.WriteDebug("Location of Target vault: " + TargetVault.Location);
/* move Prepare move function to vault APIs */
string correlationId = ServiceClientAdapter.PrepareDataMove(SourceVault.Name, SourceVault.ResourceGroupName, prepareMoveRequest);
ServiceClientAdapter.BmsAdapter.Client.SubscriptionId = subscriptionContext; // set subscription to original
WriteObject(correlationId);
}, ShouldProcess(TargetVault.Name, VerbsCommon.Set));
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
string resourceId = ResourceId;
if (ParameterSetName == NameParamSet)
{
// Form ID from name
ResourceIdentifier resourceIdentifier = new ResourceIdentifier();
resourceIdentifier.Subscription = ServiceClientAdapter.SubscriptionId;
resourceIdentifier.ResourceGroupName = ResourceGroupName;
resourceIdentifier.ResourceType = ConversionUtils.GetARMResourceType(Type);
resourceIdentifier.ResourceName = Name;
resourceId = resourceIdentifier.ToString();
}
else if (ParameterSetName == IdParamSet)
{
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(resourceId);
Type = ConversionUtils.GetWorkloadTypeFromArmType(resourceIdentifier.ResourceType);
}
else
{
// Pass on the ID
}
GenericResource resource = ServiceClientAdapter.GetAzureResource(resourceId);
BackupStatusResponse backupStatus = ServiceClientAdapter.CheckBackupStatus(Type, resourceId, resource.Location, ProtectableObjectName).Body;
Boolean isProtected = String.Equals(backupStatus.ProtectionStatus, "Protected", StringComparison.OrdinalIgnoreCase);
WriteObject(new ResourceBackupStatus(
isProtected == true ? backupStatus.VaultId : null,
isProtected));
});
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
if (ParameterSetName == JobFilterSet)
{
JobId = Job.JobId;
}
WriteDebug("Fetching job with ID: " + JobId);
if (UseSecondaryRegion.IsPresent)
{
CrrModel.CrrJobRequest jobRequest = new CrrModel.CrrJobRequest();
jobRequest.JobName = JobId;
jobRequest.ResourceId = VaultId;
// check this GetVault for rainy day scenario
ARSVault vault = ServiceClientAdapter.GetVault(resourceGroupName, vaultName);
string secondaryRegion = BackupUtils.regionMap[vault.Location];
CrrModel.JobResource jobDetailsCrr = ServiceClientAdapter.GetCRRJobDetails(secondaryRegion, jobRequest);
WriteObject(JobConversions.GetPSJobCrr(jobDetailsCrr));
}
else
{
JobResource jobDetails = ServiceClientAdapter.GetJob(
JobId,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
WriteObject(JobConversions.GetPSJob(jobDetails));
}
});
}
/// <summary>
/// This method prepares the source vault for Data Move operation.
/// </summary>
/// <param name="vaultName"></param>
/// <param name="resourceGroupName"></param>
/// <param name="prepareMoveRequest"></param>
public string PrepareDataMove(string vaultName, string resourceGroupName, PrepareDataMoveRequest prepareMoveRequest)
{
// prepare move
var prepareMoveOperationResponse = ServiceClientAdapter.BmsAdapter.Client.BeginBMSPrepareDataMoveWithHttpMessagesAsync(
vaultName, resourceGroupName, prepareMoveRequest).Result;
// track prepare-move operation to success
var operationStatus = TrackingHelpers.GetOperationStatusDataMove(
prepareMoveOperationResponse,
operationId => ServiceClientAdapter.GetDataMoveOperationStatus(operationId, vaultName, resourceGroupName));
Logger.Instance.WriteDebug("Prepare move operation: " + operationStatus.Body.Status);
// get the correlation Id and return it for trigger data move
var operationResult = TrackingHelpers.GetCorrelationId(
prepareMoveOperationResponse,
operationId => ServiceClientAdapter.GetPrepareDataMoveOperationResult(operationId, vaultName, resourceGroupName));
Logger.Instance.WriteDebug("Prepare move - correlationId:" + operationResult.CorrelationId);
return(operationResult.CorrelationId);
}
/// <summary>
/// Based on the response from the service, handles the job created in the service appropriately.
/// </summary>
/// <param name="response">Response from service</param>
/// <param name="operationName">Name of the operation</param>
protected void HandleCreatedJob(AzureRestNS.AzureOperationResponse response, string operationName)
{
WriteDebug(Resources.TrackingOperationStatusURLForCompletion +
response.Response.Headers.GetAzureAsyncOperationHeader());
var operationStatus = TrackingHelpers.GetOperationStatus(
response,
operationId => ServiceClientAdapter.GetProtectedItemOperationStatus(operationId));
if (response != null && operationStatus != null)
{
WriteDebug(Resources.FinalOperationStatus + operationStatus.Status);
if (operationStatus.Properties != null)
{
var jobExtendedInfo =
(OperationStatusJobExtendedInfo)operationStatus.Properties;
if (jobExtendedInfo.JobId != null)
{
var jobStatusResponse =
(OperationStatusJobExtendedInfo)operationStatus.Properties;
WriteObject(GetJobObject(jobStatusResponse.JobId));
}
}
if (operationStatus.Status == OperationStatusValues.Failed &&
operationStatus.Error != null)
{
var errorMessage = string.Format(
Resources.OperationFailed,
operationName,
operationStatus.Error.Code,
operationStatus.Error.Message);
throw new Exception(errorMessage);
}
}
}
public override void ExecuteCmdlet()
{
PolicyName = (this.ParameterSetName == PolicyNameParameterSet) ? Name : Policy.Name;
if (string.IsNullOrEmpty(PolicyName))
{
throw new ArgumentException(Resources.PolicyNameIsEmptyOrNull);
}
ExecutionBlock(() =>
{
ConfirmAction(
Force.IsPresent,
string.Format(Resources.RemoveProtectionPolicyWarning, PolicyName),
Resources.RemoveProtectionPolicyMessage,
PolicyName, () =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
WriteDebug(Resources.MakingClientCall);
ServiceClientAdapter.RemoveProtectionPolicy(
PolicyName,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
WriteDebug(Resources.ProtectionPolicyDeleted);
}
);
if (PassThru.IsPresent)
{
WriteObject(Policy);
}
}, ShouldProcess(PolicyName, VerbsCommon.Remove));
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
if (!((Container.ContainerType == ContainerType.Windows &&
Container.BackupManagementType == BackupManagementType.MARS) ||
(Container.ContainerType == ContainerType.AzureSQL &&
Container.BackupManagementType == BackupManagementType.AzureSQL) ||
(Container.ContainerType == ContainerType.AzureStorage &&
Container.BackupManagementType == BackupManagementType.AzureStorage)))
{
throw new ArgumentException(string.Format(Resources.UnsupportedContainerException,
Container.ContainerType, Container.BackupManagementType));
}
string containerName = Container.Name;
if (Container.ContainerType == ContainerType.AzureSQL)
{
containerName = ContainerConstansts.SqlContainerNamePrefix + containerName;
}
ServiceClientAdapter.UnregisterContainers(
containerName,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
if (PassThru.IsPresent)
{
WriteObject(Container);
}
}, ShouldProcess(Container.Name, VerbsLifecycle.Unregister));
}
private List <RecoveryPointBase> GetMoveRecommendedRecoveryPoints(Dictionary <Enum, object> ProviderData)
{
string vaultName = (string)ProviderData[VaultParams.VaultName];
string resourceGroupName = (string)ProviderData[VaultParams.ResourceGroupName];
ItemBase item = ProviderData[RecoveryPointParams.Item] as ItemBase;
Dictionary <UriEnums, string> uriDict = HelperUtils.ParseUri(item.Id);
string containerUri = HelperUtils.GetContainerUri(uriDict, item.Id);
string protectedItemName = HelperUtils.GetProtectedItemUri(uriDict, item.Id);
ServiceClientModel.ListRecoveryPointsRecommendedForMoveRequest moveRequest = new ServiceClientModel.ListRecoveryPointsRecommendedForMoveRequest();
List <ServiceClientModel.RecoveryPointResource> rpListResponse;
rpListResponse = ServiceClientAdapter.GetMoveRecommendedRecoveryPoints(
containerUri,
protectedItemName,
moveRequest,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
return(RecoveryPointConversions.GetPSAzureRecoveryPoints(rpListResponse, item));
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
if ((AzureRmBackupManagementServer.BackupEngineType !=
BackupEngineType.DpmBackupEngine.ToString() &&
AzureRmBackupManagementServer.BackupEngineType !=
BackupEngineType.AzureBackupServerEngine.ToString()) ||
AzureRmBackupManagementServer.BackupManagementType.ToString() !=
BackupManagementType.SCDPM.ToString() &&
AzureRmBackupManagementServer.BackupManagementType.ToString() !=
BackupManagementType.AzureBackupServer.ToString())
{
throw new ArgumentException(string.Format(
Resources.UnsupportedAzureRmBackupManagementServerException,
AzureRmBackupManagementServer.BackupEngineType,
AzureRmBackupManagementServer.BackupManagementType));
}
string azureRmBackupManagementServer = AzureRmBackupManagementServer.Name;
ServiceClientAdapter.UnregisterContainers(
azureRmBackupManagementServer,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
if (PassThru.IsPresent)
{
WriteObject(AzureRmBackupManagementServer);
}
}, ShouldProcess(AzureRmBackupManagementServer.Name, VerbsLifecycle.Unregister));
}
public List <SQLDataDirectory> GetDataDirectory(string vaultName, string resourceGroupName, string itemId, DateTime pointInTime)
{
Dictionary <UriEnums, string> uriDict = HelperUtils.ParseUri(itemId);
string containerUri = HelperUtils.GetContainerUri(uriDict, itemId);
string protectedItemName = HelperUtils.GetProtectedItemUri(uriDict, itemId);
var queryFilterString = QueryBuilder.Instance.GetQueryString(new BMSRPQueryObject()
{
RestorePointQueryType = RestorePointQueryType.Log,
ExtendedInfo = true
});
ODataQuery <BMSRPQueryObject> queryFilter = new ODataQuery <BMSRPQueryObject>();
queryFilter.Filter = queryFilterString;
var rpResponse = ServiceClientAdapter.GetRecoveryPoints(
containerUri,
protectedItemName,
queryFilter,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
List <SQLDataDirectory> dataDirectoryPaths = new List <SQLDataDirectory>();
if (rpResponse[0].Properties.GetType() == typeof(AzureWorkloadSQLPointInTimeRecoveryPoint))
{
AzureWorkloadSQLPointInTimeRecoveryPoint recoveryPoint =
rpResponse[0].Properties as AzureWorkloadSQLPointInTimeRecoveryPoint;
if (recoveryPoint.ExtendedInfo != null)
{
foreach (SQLDataDirectory dataDirectoryPath in recoveryPoint.ExtendedInfo.DataDirectoryPaths)
{
dataDirectoryPaths.Add(dataDirectoryPath);
}
}
}
return(dataDirectoryPaths);
}
/// <summary>
/// Get Protected Items for particular workload type
/// </summary>
public static List <ProtectedItemResource> GetProtectedItems(
string vaultName,
string resourceGroupName,
string BackupManagementType,
string DataSourceType,
ServiceClientAdapter serviceClientAdapter)
{
ODataQuery <ProtectedItemQueryObject> queryParams = new ODataQuery <ProtectedItemQueryObject>(
q => q.BackupManagementType
== BackupManagementType &&
q.ItemType == DataSourceType);
List <ProtectedItemResource> protectedItems = new List <ProtectedItemResource>();
var listResponse = serviceClientAdapter.ListProtectedItem(
queryParams,
skipToken: null,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
protectedItems.AddRange(listResponse);
return(protectedItems);
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
if (ParameterSetName == JobFilterSet)
{
JobId = Job.JobId;
}
WriteDebug("Fetching job with ID: " + JobId);
var adapterResponse = ServiceClientAdapter.GetJob(
JobId,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
WriteObject(JobConversions.GetPSJob(adapterResponse));
});
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
if (!((Container.ContainerType == ContainerType.Windows &&
Container.BackupManagementType == BackupManagementType.MARS) ||
(Container.ContainerType == ContainerType.AzureSQL &&
Container.BackupManagementType == BackupManagementType.AzureSQL)))
{
throw new ArgumentException(String.Format(Resources.UnsupportedContainerException,
Container.ContainerType, Container.BackupManagementType));
}
string containerName = Container.Name;
if (Container.ContainerType == ContainerType.AzureSQL)
{
containerName = ContainerConstansts.SqlContainerNamePrefix + containerName;
}
ServiceClientAdapter.UnregisterContainers(containerName);
});
}
public RestAzureNS.AzureOperationResponse TriggerBackup()
{
string vaultName = (string)ProviderData[VaultParams.VaultName];
string vaultResourceGroupName = (string)ProviderData[VaultParams.ResourceGroupName];
ItemBase item = (ItemBase)ProviderData[ItemParams.Item];
DateTime?expiryDateTime = (DateTime?)ProviderData[ItemParams.ExpiryDateTimeUTC];
string backupType = ProviderData[ItemParams.BackupType].ToString();
bool enableCompression = (bool)ProviderData[ItemParams.EnableCompression];
AzureWorkloadSQLDatabaseProtectedItem azureWorkloadProtectedItem = item as AzureWorkloadSQLDatabaseProtectedItem;
BackupRequestResource triggerBackupRequest = new BackupRequestResource();
AzureWorkloadBackupRequest azureWorkloadBackupRequest = new AzureWorkloadBackupRequest();
azureWorkloadBackupRequest.RecoveryPointExpiryTimeInUTC = expiryDateTime;
azureWorkloadBackupRequest.BackupType = backupType;
azureWorkloadBackupRequest.EnableCompression = enableCompression;
triggerBackupRequest.Properties = azureWorkloadBackupRequest;
return(ServiceClientAdapter.TriggerBackup(
IdUtils.GetValueByName(azureWorkloadProtectedItem.Id, IdUtils.IdNames.ProtectionContainerName),
IdUtils.GetValueByName(azureWorkloadProtectedItem.Id, IdUtils.IdNames.ProtectedItemName),
triggerBackupRequest,
vaultName: vaultName,
resourceGroupName: vaultResourceGroupName));
}
public override void ExecuteCmdlet()
{
PolicyName = (this.ParameterSetName == PolicyNameParameterSet) ? Name : Policy.Name;
if (string.IsNullOrEmpty(PolicyName))
{
throw new ArgumentException(Resources.PolicyNameIsEmptyOrNull);
}
ConfirmAction(
Force.IsPresent,
string.Format(Resources.RemoveProtectionPolicyWarning, PolicyName),
Resources.RemoveProtectionPolicyMessage,
PolicyName, () =>
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
WriteDebug(Resources.MakingClientCall);
ServiceClientAdapter.RemoveProtectionPolicy(PolicyName);
WriteDebug(Resources.ProtectionPolicyDeleted);
});
});
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
List <string> jobsToWaitOn = new List <string>();
List <JobBase> finalJobs = new List <JobBase>();
object castedObj;
if (GetCastedObjFromPSObj <JobBase>(Job, out castedObj))
{
JobBase justJob = castedObj as JobBase;
jobsToWaitOn.Add(justJob.JobId);
}
else if (GetCastedObjFromPSObj <List <JobBase> >(Job, out castedObj))
{
List <JobBase> jobsList = castedObj as List <JobBase>;
foreach (var job in jobsList)
{
jobsToWaitOn.Add(job.JobId);
}
}
else if (Job.GetType() == typeof(System.Object[]))
{
System.Object[] castedJobsList = Job as System.Object[];
object castedJob;
foreach (var job in castedJobsList)
{
if (GetCastedObjFromPSObj <JobBase>(job, out castedJob))
{
jobsToWaitOn.Add((castedJob as JobBase).JobId);
}
else
{
throw new Exception(string.Format(Resources.JobWaitJobInvalidInput,
Job.GetType().FullName));
}
}
}
else
{
// not a valid object. throw exception.
throw new Exception(string.Format(Resources.JobWaitJobInvalidInput,
Job.GetType().FullName));
}
// now wait until timeout happens or all jobs complete execution
DateTime waitBeginning = DateTime.UtcNow;
while (true)
{
if (Timeout.HasValue)
{
if (DateTime.UtcNow.Subtract(waitBeginning) >=
TimeSpan.FromSeconds(Timeout.Value))
{
break;
}
}
bool hasUnfinishedJob = false;
finalJobs.Clear();
for (int i = 0; i < jobsToWaitOn.Count; i++)
{
string jobId = jobsToWaitOn[i];
var updatedJob = JobConversions.GetPSJob(
ServiceClientAdapter.GetJob(jobId)
);
if (IsJobInProgress(updatedJob))
{
hasUnfinishedJob = true;
}
else
{
// removing finished job from list
jobsToWaitOn.RemoveAt(i);
i--;
}
finalJobs.Add(updatedJob);
}
if (!hasUnfinishedJob)
{
break;
}
// sleep for 30 seconds before checking again
TestMockSupport.Delay(30 * 1000);
}
WriteObject(finalJobs, enumerateCollection: true);
});
}
public UnitOfWork()
{
_adapter = new ServiceClientAdapter();
_client = _adapter.Connect();
}
