public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
PsBackupProviderManager providerManager = new PsBackupProviderManager(
new Dictionary <System.Enum, object>()
{
{ VaultParams.VaultName, vaultName },
{ VaultParams.ResourceGroupName, resourceGroupName },
{ ContainerParams.ContainerType, ContainerType.Windows },
{ ContainerParams.Name, Name }
}, ServiceClientAdapter);
IPsBackupProvider psBackupProvider =
providerManager.GetProviderInstanceForBackupManagementServer();
var backupServerModels = psBackupProvider.ListBackupManagementServers();
if (!string.IsNullOrEmpty(this.Name))
{
if (backupServerModels != null)
{
backupServerModels = backupServerModels.Where(x => x.Name == this.Name).ToList();
}
}
WriteObject(backupServerModels, enumerateCollection: true);
});
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
PsBackupProviderManager providerManager =
new PsBackupProviderManager(new Dictionary <Enum, object>()
{
{ VaultParams.VaultName, vaultName },
{ VaultParams.ResourceGroupName, resourceGroupName },
{ ItemParams.Item, Item },
{ ItemParams.ExpiryDateTimeUTC, ExpiryDateTimeUTC },
{ ItemParams.BackupType, BackupType },
{ ItemParams.EnableCompression, EnableCompression.IsPresent },
}, ServiceClientAdapter);
IPsBackupProvider psBackupProvider =
providerManager.GetProviderInstance(Item.WorkloadType, Item.BackupManagementType);
var jobResponse = psBackupProvider.TriggerBackup();
HandleCreatedJob(
jobResponse,
Resources.TriggerBackupOperation,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
}, ShouldProcess(Item.Name, VerbsData.Backup));
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
BackupManagementType?backupManagementTypeNullable = null;
BackupManagementType backupManagementType;
if (BackupManagementType != null)
{
Enum.TryParse(BackupManagementType, out backupManagementType);
backupManagementTypeNullable = backupManagementType;
}
// Forcing this cmdlet to return only Registered containers for now.
// Once we support containers returning other status types, one can undo this behavior.
Status = ContainerRegistrationStatus.Registered;
PsBackupProviderManager providerManager =
new PsBackupProviderManager(new Dictionary <Enum, object>()
{
{ ContainerParams.ContainerType, ContainerType },
{ ContainerParams.BackupManagementType, backupManagementTypeNullable },
{ ContainerParams.Name, Name },
{ ContainerParams.FriendlyName, FriendlyName },
{ ContainerParams.ResourceGroupName, ResourceGroupName },
{ ContainerParams.Status, Status },
}, ServiceClientAdapter);
IPsBackupProvider psBackupProvider =
providerManager.GetProviderInstance(ContainerType, backupManagementTypeNullable);
var containerModels = psBackupProvider.ListProtectionContainers();
WriteObject(containerModels, enumerateCollection: true);
});
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
string name = Name;
string resourceGroupName = ResourceGroupName;
string type = Type;
if (ParameterSetName == IdParamSet)
{
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(ResourceId);
name = resourceIdentifier.ResourceName;
resourceGroupName = resourceIdentifier.ResourceGroupName;
type = resourceIdentifier.ResourceType;
}
PsBackupProviderManager providerManager =
new PsBackupProviderManager(new Dictionary <Enum, object>()
{
{ ProtectionCheckParams.Name, name },
{ ProtectionCheckParams.ResourceGroupName, resourceGroupName },
}, ServiceClientAdapter);
IPsBackupProvider psBackupProvider =
providerManager.GetProviderInstance(type);
WriteObject(psBackupProvider.CheckBackupStatus());
});
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
PsBackupProviderManager providerManager =
new PsBackupProviderManager(new Dictionary <Enum, object>()
{
{ ItemParams.Container, Container },
{ ItemParams.BackupManagementType, BackupManagementType },
{ ItemParams.AzureVMName, Name },
{ ItemParams.ProtectionStatus, ProtectionStatus },
{ ItemParams.ProtectionState, ProtectionState },
{ ItemParams.WorkloadType, WorkloadType },
}, ServiceClientAdapter);
IPsBackupProvider psBackupProvider = null;
if (this.ParameterSetName == GetItemsForVaultParamSet)
{
psBackupProvider =
providerManager.GetProviderInstance(WorkloadType, BackupManagementType);
}
else
{
psBackupProvider = providerManager.GetProviderInstance(WorkloadType,
(Container as ManagementContext).BackupManagementType);
}
var itemModels = psBackupProvider.ListProtectedItems();
WriteObject(itemModels, enumerateCollection: true);
});
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
PsBackupProviderManager providerManager =
new PsBackupProviderManager(new Dictionary <System.Enum, object>()
{
{ ItemParams.AzureVMName, Name },
{ ItemParams.AzureVMCloudServiceName, ServiceName },
{ ItemParams.AzureVMResourceGroupName, ResourceGroupName },
{ ItemParams.Policy, Policy },
{ ItemParams.Item, Item },
{ ItemParams.ParameterSetName, this.ParameterSetName },
}, ServiceClientAdapter);
IPsBackupProvider psBackupProvider = (Item != null) ?
providerManager.GetProviderInstance(Item.WorkloadType, Item.BackupManagementType)
: providerManager.GetProviderInstance(Policy.WorkloadType);
var itemResponse = psBackupProvider.EnableProtection();
// Track Response and display job details
HandleCreatedJob(itemResponse, Resources.EnableProtectionOperation);
});
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
PsBackupProviderManager providerManager =
new PsBackupProviderManager(new Dictionary <System.Enum, object>()
{
{ VaultParams.VaultName, vaultName },
{ VaultParams.ResourceGroupName, resourceGroupName },
{ ItemParams.Item, Item },
}, ServiceClientAdapter);
IPsBackupProvider psBackupProvider =
providerManager.GetProviderInstance(Item.WorkloadType,
Item.BackupManagementType);
var itemResponse = psBackupProvider.UndeleteProtection();
HandleCreatedJob(
itemResponse,
Resources.DisableProtectionOperation,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
}, ShouldProcess(Item.Name, VerbsLifecycle.Disable));
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
PsBackupProviderManager providerManager = new PsBackupProviderManager(
new Dictionary <Enum, object>()
{
{ VaultParams.VaultName, vaultName },
{ VaultParams.ResourceGroupName, resourceGroupName },
{ RestoreBackupItemParams.RecoveryPoint, RecoveryPoint }
}, ServiceClientAdapter);
IPsBackupProvider psBackupProvider = providerManager.GetProviderInstance(
RecoveryPoint.WorkloadType, RecoveryPoint.BackupManagementType);
string content = string.Empty;
psBackupProvider.RevokeItemLevelRecoveryAccess();
if (PassThru.IsPresent)
{
WriteObject(RecoveryPoint);
}
WriteDebug(string.Format("Disabled the mount script of recovery point"));
}, ShouldProcess(RecoveryPoint.ItemName, VerbsLifecycle.Disable));
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
GenericResource storageAccountResource = GetStorageAccountResource();
WriteDebug(string.Format("StorageId = {0}", storageAccountResource.Id));
PsBackupProviderManager providerManager = new PsBackupProviderManager(
new Dictionary <Enum, object>()
{
{ RestoreBackupItemParams.RecoveryPoint, RecoveryPoint },
{ RestoreBackupItemParams.StorageAccountId, storageAccountResource.Id },
{ RestoreBackupItemParams.StorageAccountLocation, storageAccountResource.Location },
{ RestoreBackupItemParams.StorageAccountType, storageAccountResource.Type }
}, ServiceClientAdapter);
IPsBackupProvider psBackupProvider = providerManager.GetProviderInstance(
RecoveryPoint.WorkloadType, RecoveryPoint.BackupManagementType);
var jobResponse = psBackupProvider.TriggerRestore();
WriteDebug(string.Format("Restore submitted"));
HandleCreatedJob(jobResponse, Resources.RestoreOperation);
}, ShouldProcess(RecoveryPoint.ItemName, VerbsData.Restore));
}
public override void ExecuteCmdlet()
{
ConfirmAction(
Force.IsPresent,
string.Format(Resources.DisableProtectionWarning, Item.Name),
Resources.DisableProtectionMessage,
Item.Name, () =>
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
PsBackupProviderManager providerManager =
new PsBackupProviderManager(new Dictionary <System.Enum, object>()
{
{ ItemParams.Item, Item },
{ ItemParams.DeleteBackupData, this.DeleteBackupData },
}, ServiceClientAdapter);
IPsBackupProvider psBackupProvider =
providerManager.GetProviderInstance(Item.WorkloadType,
Item.BackupManagementType);
var itemResponse = psBackupProvider.DisableProtection();
// Track Response and display job details
HandleCreatedJob(itemResponse, Resources.DisableProtectionOperation);
});
});
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
BackupManagementType?backupManagementTypeNullable = null;
BackupManagementType backupManagementType;
if (BackupManagementType != null)
{
Enum.TryParse <BackupManagementType>(BackupManagementType, out backupManagementType);
backupManagementTypeNullable = backupManagementType;
}
PsBackupProviderManager providerManager =
new PsBackupProviderManager(new Dictionary <System.Enum, object>()
{
{ ContainerParams.ContainerType, ContainerType },
{ ContainerParams.BackupManagementType, backupManagementTypeNullable },
{ ContainerParams.Name, Name },
{ ContainerParams.FriendlyName, FriendlyName },
{ ContainerParams.ResourceGroupName, ResourceGroupName },
{ ContainerParams.Status, Status },
}, ServiceClientAdapter);
IPsBackupProvider psBackupProvider =
providerManager.GetProviderInstance(ContainerType, backupManagementTypeNullable);
var containerModels = psBackupProvider.ListProtectionContainers();
WriteObject(containerModels, enumerateCollection: true);
});
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
Dictionary <Enum, object> providerParameters = new Dictionary <Enum, object>();
providerParameters.Add(PolicyParams.ScheduleRunFrequency, ScheduleRunFrequency);
if (ScheduleRunFrequency != ScheduleRunType.Daily && WorkloadType != WorkloadType.AzureVM && WorkloadType != WorkloadType.AzureFiles)
{
throw new ArgumentException(Resources.UnexpectedParamScheduleRunFrequency);
}
if (ScheduleRunFrequency == ScheduleRunType.Weekly && WorkloadType == WorkloadType.AzureFiles)
{
throw new ArgumentException(Resources.WeeklyScheduleNotSupported);
}
PsBackupProviderManager providerManager =
new PsBackupProviderManager(providerParameters, ServiceClientAdapter);
IPsBackupProvider psBackupProvider =
providerManager.GetProviderInstance(WorkloadType, BackupManagementType);
WriteObject(psBackupProvider.GetDefaultRetentionPolicyObject());
});
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
PsBackupProviderManager providerManager = new PsBackupProviderManager(
new Dictionary <Enum, object>()
{
{ VaultParams.VaultName, vaultName },
{ VaultParams.ResourceGroupName, resourceGroupName },
{ RestoreBackupItemParams.RecoveryPoint, RecoveryPoint },
{ RecoveryPointParams.FileDownloadLocation, Path }
}, ServiceClientAdapter);
IPsBackupProvider psBackupProvider = providerManager.GetProviderInstance(
RecoveryPoint.WorkloadType, RecoveryPoint.BackupManagementType);
var response = psBackupProvider.ProvisionItemLevelRecoveryAccess();
WriteDebug(string.Format("Mount Script download completed"));
WriteObject(response);
}, ShouldProcess(RecoveryPoint.ItemName, "Downloading script"));
}
/// <summary>
/// To get provider instance using provider type.
/// </summary>
public IPsBackupProvider GetProviderInstance(PsBackupProviderTypes providerType)
{
IPsBackupProvider psBackupProvider = null;
switch (providerType)
{
case PsBackupProviderTypes.IaasVm:
psBackupProvider = new IaasVmPsBackupProvider();
break;
case PsBackupProviderTypes.AzureSql:
psBackupProvider = new AzureSqlPsBackupProvider();
break;
case PsBackupProviderTypes.Mab:
psBackupProvider = new MabPsBackupProvider();
break;
case PsBackupProviderTypes.Dpm:
psBackupProvider = new DpmPsBackupProvider();
break;
default:
break;
}
psBackupProvider.Initialize(providerData, serviceClientAdapter);
return(psBackupProvider);
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
WriteDebug(string.Format("Input params - Name:{0}, WorkloadType:{1}, " +
"BackupManagementType: {2}, " +
"RetentionPolicy:{3}, SchedulePolicy:{4}",
Name, WorkloadType.ToString(),
BackupManagementType.HasValue ? BackupManagementType.ToString() : "NULL",
RetentionPolicy == null ? "NULL" : RetentionPolicy.ToString(),
SchedulePolicy == null ? "NULL" : SchedulePolicy.ToString()));
// validate policy name
PolicyCmdletHelpers.ValidateProtectionPolicyName(Name);
// Validate if policy already exists
if (PolicyCmdletHelpers.GetProtectionPolicyByName(
Name,
ServiceClientAdapter,
vaultName: vaultName,
resourceGroupName: resourceGroupName) != null)
{
throw new ArgumentException(string.Format(Resources.PolicyAlreadyExistException, Name));
}
Dictionary <Enum, object> providerParameters = new Dictionary <Enum, object>();
providerParameters.Add(VaultParams.VaultName, vaultName);
providerParameters.Add(VaultParams.ResourceGroupName, resourceGroupName);
providerParameters.Add(PolicyParams.PolicyName, Name);
providerParameters.Add(PolicyParams.WorkloadType, WorkloadType);
providerParameters.Add(PolicyParams.RetentionPolicy, RetentionPolicy);
providerParameters.Add(PolicyParams.SchedulePolicy, SchedulePolicy);
PsBackupProviderManager providerManager = new PsBackupProviderManager(providerParameters, ServiceClientAdapter);
IPsBackupProvider psBackupProvider =
providerManager.GetProviderInstance(WorkloadType, BackupManagementType);
psBackupProvider.CreatePolicy();
WriteDebug("Successfully created policy, now fetching it from service: " + Name);
// now get the created policy and return
ServiceClientModel.ProtectionPolicyResource policy = PolicyCmdletHelpers.GetProtectionPolicyByName(
Name,
ServiceClientAdapter,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
// now convert service Policy to PSObject
WriteObject(ConversionHelpers.GetPolicyModel(policy));
}, ShouldProcess(Name, VerbsCommon.New));
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
PsBackupProviderManager providerManager =
new PsBackupProviderManager(new Dictionary <Enum, object>()
{
{ VaultParams.VaultName, vaultName },
{ VaultParams.ResourceGroupName, resourceGroupName },
{ ItemParams.DeleteState, DeleteState },
{ ItemParams.Container, Container },
{ ItemParams.BackupManagementType, BackupManagementType },
{ ItemParams.ItemName, Name },
{ PolicyParams.ProtectionPolicy, Policy },
{ ItemParams.ProtectionStatus, ProtectionStatus },
{ ItemParams.ProtectionState, ProtectionState },
{ ItemParams.WorkloadType, WorkloadType },
{ ItemParams.FriendlyName, FriendlyName },
{ CRRParams.UseSecondaryRegion, UseSecondaryRegion.IsPresent }
}, ServiceClientAdapter);
IPsBackupProvider psBackupProvider = null;
List <ItemBase> itemModels = null;
if (BackupManagementType == BackupManagementType.MAB ||
(this.ParameterSetName == GetItemsForContainerParamSet && (Container as ContainerContext).ContainerType == ContainerType.Windows))
{
AzureWorkloadProviderHelper provider = new AzureWorkloadProviderHelper(ServiceClientAdapter);
itemModels = provider.GetMABProtectedItems(vaultName, resourceGroupName, Container);
}
else
{
if (this.ParameterSetName == GetItemsForVaultParamSet)
{
psBackupProvider =
providerManager.GetProviderInstance(WorkloadType, BackupManagementType);
}
else if (this.ParameterSetName == GetItemsForContainerParamSet)
{
psBackupProvider = providerManager.GetProviderInstance(WorkloadType,
(Container as ManagementContext).BackupManagementType);
}
else
{
psBackupProvider = providerManager.GetProviderInstance(Policy.WorkloadType);
}
itemModels = psBackupProvider.ListProtectedItems();
}
WriteObject(itemModels, enumerateCollection: true);
});
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
//Validate start time < end time
base.ExecuteCmdlet();
Dictionary <System.Enum, object> parameter = new Dictionary <System.Enum, object>();
parameter.Add(GetRecoveryPointParams.Item, Item);
if (this.ParameterSetName == DateTimeFilterParameterSet)
{
//User want list of RPs between given time range
WriteDebug(String.Format("ParameterSet = DateTimeFilterParameterSet. \n" +
"StartDate = {0} EndDate = {1}, Item.Name = {2}, Item.ContainerName = {3}",
StartDate, EndDate, Item.Name, Item.ContainerName));
if (StartDate >= EndDate)
{
throw new ArgumentException(Resources.RecoveryPointEndDateShouldBeGreater);
}
if (StartDate.Kind != DateTimeKind.Utc || EndDate.Kind != DateTimeKind.Utc)
{
throw new ArgumentException(Resources.GetRPErrorInputDatesShouldBeInUTC);
}
parameter.Add(GetRecoveryPointParams.StartDate, StartDate);
parameter.Add(GetRecoveryPointParams.EndDate, EndDate);
PsBackupProviderManager providerManager =
new PsBackupProviderManager(parameter, ServiceClientAdapter);
IPsBackupProvider psBackupProvider =
providerManager.GetProviderInstance(Item.ContainerType, Item.BackupManagementType);
var rpList = psBackupProvider.ListRecoveryPoints();
WriteDebug(String.Format("RPCount in Response = {0}", rpList.Count));
WriteObject(rpList, enumerateCollection: true);
}
else if (this.ParameterSetName == RecoveryPointIdParameterSet)
{
//User want details of a particular recovery point
WriteDebug(String.Format("ParameterSet = DateTimeFilterParameterSet. \n" +
"StartDate = {0} EndDate = {1}, RPId = {2}",
StartDate, EndDate, RecoveryPointId));
parameter.Add(GetRecoveryPointParams.RecoveryPointId, RecoveryPointId);
PsBackupProviderManager providerManager =
new PsBackupProviderManager(parameter, ServiceClientAdapter);
IPsBackupProvider psBackupProvider =
providerManager.GetProviderInstance(Item.ContainerType, Item.BackupManagementType);
WriteObject(psBackupProvider.GetRecoveryPointDetails());
}
else
{
throw new Exception(Resources.RecoveryPointUnsupportedParamet);
}
});
}
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));
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
ConfirmAction(
Force.IsPresent,
string.Format(Resources.DisableProtectionWarning, Item.Name),
Resources.DisableProtectionMessage,
Item.Name, () =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
PsBackupProviderManager providerManager =
new PsBackupProviderManager(new Dictionary <System.Enum, object>()
{
{ VaultParams.VaultName, vaultName },
{ VaultParams.ResourceGroupName, resourceGroupName },
{ ItemParams.Item, Item },
{ ItemParams.DeleteBackupData, this.DeleteBackupData },
}, ServiceClientAdapter);
IPsBackupProvider psBackupProvider =
providerManager.GetProviderInstance(Item.WorkloadType,
Item.BackupManagementType);
if (DeleteBackupData)
{
var itemResponse = psBackupProvider.DisableProtectionWithDeleteData();
// Track Response and display job details
HandleCreatedJob(
itemResponse,
Resources.DisableProtectionOperation,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
}
else
{
var itemResponse = psBackupProvider.DisableProtection();
// Track Response and display job details
HandleCreatedJob(
itemResponse,
Resources.DisableProtectionOperation,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
}
}
);
}, ShouldProcess(Item.Name, VerbsLifecycle.Disable));
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
StorageAccountName = StorageAccountName.ToLower();
ResourceIdentity identity = new ResourceIdentity();
identity.ResourceName = StorageAccountName;
identity.ResourceProviderNamespace = "Microsoft.ClassicStorage/storageAccounts";
identity.ResourceProviderApiVersion = "2015-12-01";
identity.ResourceType = string.Empty;
ResourcesNS.Models.ResourceGetResult resource = null;
try
{
WriteDebug(String.Format("Query Microsoft.ClassicStorage with name = {0}",
StorageAccountName));
resource = RmClient.Resources.GetAsync(StorageAccountResourceGroupName,
identity, CancellationToken.None).Result;
}
catch (Exception)
{
identity.ResourceProviderNamespace = "Microsoft.Storage/storageAccounts";
identity.ResourceProviderApiVersion = "2016-01-01";
resource = RmClient.Resources.GetAsync(StorageAccountResourceGroupName,
identity, CancellationToken.None).Result;
}
string storageAccountId = resource.Resource.Id;
string storageAccountlocation = resource.Resource.Location;
string storageAccountType = resource.Resource.Type;
WriteDebug(String.Format("StorageId = {0}", storageAccountId));
PsBackupProviderManager providerManager = new PsBackupProviderManager(
new Dictionary <System.Enum, object>()
{
{ RestoreBackupItemParams.RecoveryPoint, RecoveryPoint },
{ RestoreBackupItemParams.StorageAccountId, storageAccountId },
{ RestoreBackupItemParams.StorageAccountLocation, storageAccountlocation },
{ RestoreBackupItemParams.StorageAccountType, storageAccountType }
}, ServiceClientAdapter);
IPsBackupProvider psBackupProvider = providerManager.GetProviderInstance(
RecoveryPoint.WorkloadType, RecoveryPoint.BackupManagementType);
var jobResponse = psBackupProvider.TriggerRestore();
WriteDebug(String.Format("Restore submitted"));
HandleCreatedJob(jobResponse, Resources.RestoreOperation);
});
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
PsBackupProviderManager providerManager =
new PsBackupProviderManager(new Dictionary <Enum, object>(), ServiceClientAdapter);
IPsBackupProvider psBackupProvider =
providerManager.GetProviderInstance(WorkloadType, BackupManagementType);
WriteObject(psBackupProvider.GetDefaultRetentionPolicyObject());
});
}
public override void ExecuteCmdlet()
{
base.ExecuteCmdlet();
PsBackupProviderManager providerManager =
new PsBackupProviderManager(new Dictionary <System.Enum, object>()
{
{ ItemParams.Item, Item },
}, ServiceClientAdapter);
IPsBackupProvider psBackupProvider =
providerManager.GetProviderInstance(Item.WorkloadType, Item.BackupManagementType);
var jobResponse = psBackupProvider.TriggerBackup();
HandleCreatedJob(jobResponse, Resources.TriggerBackupOperation);
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
PsBackupProviderManager providerManager =
new PsBackupProviderManager(new Dictionary <Enum, object>()
{
{ VaultParams.VaultName, vaultName },
{ VaultParams.ResourceGroupName, resourceGroupName },
{ ItemParams.DeleteState, DeleteState },
{ ItemParams.Container, Container },
{ ItemParams.BackupManagementType, BackupManagementType },
{ ItemParams.ItemName, Name },
{ PolicyParams.ProtectionPolicy, Policy },
{ ItemParams.ProtectionStatus, ProtectionStatus },
{ ItemParams.ProtectionState, ProtectionState },
{ ItemParams.WorkloadType, WorkloadType },
{ ItemParams.FriendlyName, FriendlyName }
}, ServiceClientAdapter);
IPsBackupProvider psBackupProvider = null;
if (this.ParameterSetName == GetItemsForVaultParamSet)
{
psBackupProvider =
providerManager.GetProviderInstance(WorkloadType, BackupManagementType);
}
else if (this.ParameterSetName == GetItemsForContainerParamSet)
{
psBackupProvider = providerManager.GetProviderInstance(WorkloadType,
(Container as ManagementContext).BackupManagementType);
}
else
{
psBackupProvider = providerManager.GetProviderInstance(Policy.WorkloadType);
}
var itemModels = psBackupProvider.ListProtectedItems();
WriteObject(itemModels, enumerateCollection: true);
});
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
string shouldProcessName = Name;
if (ParameterSetName == ModifyProtectionParameterSet)
{
shouldProcessName = Item.Name;
}
if (ShouldProcess(shouldProcessName, VerbsLifecycle.Enable))
{
PsBackupProviderManager providerManager =
new PsBackupProviderManager(new Dictionary <Enum, object>()
{
{ VaultParams.VaultName, vaultName },
{ VaultParams.ResourceGroupName, resourceGroupName },
{ ItemParams.StorageAccountName, StorageAccountName },
{ ItemParams.ItemName, Name },
{ ItemParams.AzureVMCloudServiceName, ServiceName },
{ ItemParams.AzureVMResourceGroupName, ResourceGroupName },
{ ItemParams.Policy, Policy },
{ ItemParams.Item, Item },
{ ItemParams.ParameterSetName, this.ParameterSetName },
}, ServiceClientAdapter);
IPsBackupProvider psBackupProvider = (Item != null) ?
providerManager.GetProviderInstance(Item.WorkloadType, Item.BackupManagementType)
: providerManager.GetProviderInstance(Policy.WorkloadType);
var itemResponse = psBackupProvider.EnableProtection();
// Track Response and display job details
HandleCreatedJob(
itemResponse,
Resources.EnableProtectionOperation,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
}
});
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
Dictionary <Enum, object> providerParameters = new Dictionary <Enum, object>();
providerParameters.Add(PolicyParams.ScheduleRunFrequency, ScheduleRunFrequency);
PsBackupProviderManager providerManager = new PsBackupProviderManager(
providerParameters, ServiceClientAdapter);
IPsBackupProvider psBackupProvider = providerManager.GetProviderInstance(
WorkloadType, BackupManagementType);
WriteObject(psBackupProvider.GetDefaultSchedulePolicyObject());
});
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
WriteDebug(string.Format("Input params - Name:{0}, WorkloadType:{1}, " +
"BackupManagementType: {2}, " +
"RetentionPolicy:{3}, SchedulePolicy:{4}",
Name, WorkloadType.ToString(),
BackupManagementType.HasValue ? BackupManagementType.ToString() : "NULL",
RetentionPolicy == null ? "NULL" : RetentionPolicy.ToString(),
SchedulePolicy == null ? "NULL" : SchedulePolicy.ToString()));
// validate policy name
PolicyCmdletHelpers.ValidateProtectionPolicyName(Name);
// Validate if policy already exists
if (PolicyCmdletHelpers.GetProtectionPolicyByName(Name, ServiceClientAdapter) != null)
{
throw new ArgumentException(string.Format(Resources.PolicyAlreadyExistException, Name));
}
PsBackupProviderManager providerManager =
new PsBackupProviderManager(new Dictionary <System.Enum, object>()
{
{ PolicyParams.PolicyName, Name },
{ PolicyParams.WorkloadType, WorkloadType },
{ PolicyParams.RetentionPolicy, RetentionPolicy },
{ PolicyParams.SchedulePolicy, SchedulePolicy },
}, ServiceClientAdapter);
IPsBackupProvider psBackupProvider =
providerManager.GetProviderInstance(WorkloadType, BackupManagementType);
psBackupProvider.CreatePolicy();
WriteDebug("Successfully created policy, now fetching it from service: " + Name);
// now get the created policy and return
ServiceClientModel.ProtectionPolicyResponse policy = PolicyCmdletHelpers.GetProtectionPolicyByName(
Name,
ServiceClientAdapter);
// now convert service Policy to PSObject
WriteObject(ConversionHelpers.GetPolicyModel(policy.Item));
});
}
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();
PsBackupProviderManager providerManager =
new PsBackupProviderManager(new Dictionary <Enum, object>()
{
{ ItemParams.Item, Item },
{ ItemParams.ExpiryDateTimeUTC, ExpiryDateTimeUTC },
}, ServiceClientAdapter);
IPsBackupProvider psBackupProvider =
providerManager.GetProviderInstance(Item.WorkloadType, Item.BackupManagementType);
var jobResponse = psBackupProvider.TriggerBackup();
HandleCreatedJob(jobResponse, Resources.TriggerBackupOperation);
}, ShouldProcess(Item.Name, VerbsData.Backup));
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
//Validate start time < end time
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
// initialize values to default
DateTime rangeEnd = DateTime.UtcNow;
DateTime rangeStart = rangeEnd.AddDays(-30);
Dictionary <Enum, object> providerParameters = new Dictionary <Enum, object>();
providerParameters.Add(VaultParams.VaultName, vaultName);
providerParameters.Add(VaultParams.ResourceGroupName, resourceGroupName);
providerParameters.Add(RecoveryPointParams.Item, Item);
if (ParameterSetName == DateTimeFilterParameterSet ||
ParameterSetName == NoFilterParameterSet)
{
// if both start and end date are given by user
if (StartDate.HasValue && EndDate.HasValue)
{
rangeStart = StartDate.Value;
rangeEnd = EndDate.Value;
}
// if only start date is given by user
else if (StartDate.HasValue && EndDate.HasValue == false)
{
rangeStart = StartDate.Value;
rangeEnd = rangeStart.AddDays(30);
}
// if only end date is given by user
else if (EndDate.HasValue && StartDate.HasValue == false)
{
rangeEnd = EndDate.Value;
rangeStart = rangeEnd.AddDays(-30);
}
//User want list of RPs between given time range
WriteDebug(string.Format("ParameterSet = DateTimeFilterParameterSet. \n" +
"StartDate = {0} EndDate = {1}, Item.Name = {2}, Item.ContainerName = {3}",
rangeStart, rangeEnd, Item.Name, Item.ContainerName));
if (rangeStart >= rangeEnd)
{
throw new ArgumentException(Resources.RecoveryPointEndDateShouldBeGreater);
}
if (rangeStart.Kind != DateTimeKind.Utc || rangeEnd.Kind != DateTimeKind.Utc)
{
throw new ArgumentException(Resources.GetRPErrorInputDatesShouldBeInUTC);
}
if (rangeStart > DateTime.UtcNow)
{
throw new ArgumentException(
Resources.GetRPErrorStartTimeShouldBeLessThanUTCNow);
}
providerParameters.Add(RecoveryPointParams.StartDate, rangeStart);
providerParameters.Add(RecoveryPointParams.EndDate, rangeEnd);
PsBackupProviderManager providerManager =
new PsBackupProviderManager(providerParameters, ServiceClientAdapter);
IPsBackupProvider psBackupProvider =
providerManager.GetProviderInstance(Item.ContainerType, Item.BackupManagementType);
var rpList = psBackupProvider.ListRecoveryPoints();
WriteDebug(string.Format("RPCount in Response = {0}", rpList.Count));
WriteObject(rpList, enumerateCollection: true);
}
else if (ParameterSetName == RecoveryPointIdParameterSet)
{
//User want details of a particular recovery point
WriteDebug(string.Format("ParameterSet = DateTimeFilterParameterSet. \n" +
"StartDate = {0} EndDate = {1}, RPId = {2}, KeyFileDownloadLocation = {3}",
StartDate, EndDate, RecoveryPointId, KeyFileDownloadLocation));
providerParameters.Add(RecoveryPointParams.RecoveryPointId, RecoveryPointId);
providerParameters.Add(
RecoveryPointParams.KeyFileDownloadLocation, KeyFileDownloadLocation);
PsBackupProviderManager providerManager =
new PsBackupProviderManager(providerParameters, ServiceClientAdapter);
IPsBackupProvider psBackupProvider =
providerManager.GetProviderInstance(Item.ContainerType, Item.BackupManagementType);
WriteObject(psBackupProvider.GetRecoveryPointDetails());
}
else
{
throw new Exception(Resources.RecoveryPointUnsupportedParamet);
}
});
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
WriteDebug(string.Format("Input params - Policy: {0}" +
"RetentionPolicy:{1}, SchedulePolicy:{2}",
Policy == null ? "NULL" : Policy.ToString(),
RetentionPolicy == null ? "NULL" : RetentionPolicy.ToString(),
SchedulePolicy == null ? "NULL" : SchedulePolicy.ToString()));
// Validate policy name
PolicyCmdletHelpers.ValidateProtectionPolicyName(Policy.Name);
// Validate if policy already exists
ProtectionPolicyResponse servicePolicy = PolicyCmdletHelpers.GetProtectionPolicyByName(
Policy.Name, ServiceClientAdapter);
if (servicePolicy == null)
{
throw new ArgumentException(string.Format(Resources.PolicyNotFoundException,
Policy.Name));
}
PsBackupProviderManager providerManager = new PsBackupProviderManager(
new Dictionary <System.Enum, object>()
{
{ PolicyParams.ProtectionPolicy, Policy },
{ PolicyParams.RetentionPolicy, RetentionPolicy },
{ PolicyParams.SchedulePolicy, SchedulePolicy },
}, ServiceClientAdapter);
IPsBackupProvider psBackupProvider = providerManager.GetProviderInstance(
Policy.WorkloadType,
Policy.BackupManagementType);
ProtectionPolicyResponse policyResponse = psBackupProvider.ModifyPolicy();
WriteDebug("ModifyPolicy http response from service: " +
policyResponse.StatusCode.ToString());
if (policyResponse.StatusCode == System.Net.HttpStatusCode.Accepted)
{
WriteDebug("Tracking operation status URL for completion: " +
policyResponse.AzureAsyncOperation);
// Track OperationStatus URL for operation completion
BackUpOperationStatusResponse operationResponse =
TrackingHelpers.WaitForOperationCompletionUsingStatusLink(
policyResponse.AzureAsyncOperation,
ServiceClientAdapter.GetProtectionPolicyOperationStatusByURL);
WriteDebug("Final operation status: " + operationResponse.OperationStatus.Status);
if (operationResponse.OperationStatus.Properties != null &&
((OperationStatusJobsExtendedInfo)operationResponse.OperationStatus.Properties).JobIds != null)
{
// get list of jobIds and return jobResponses
WriteObject(GetJobObject(
((OperationStatusJobsExtendedInfo)operationResponse.OperationStatus.Properties).JobIds));
}
if (operationResponse.OperationStatus.Status == OperationStatusValues.Failed.ToString())
{
// if operation failed, then trace error and throw exception
if (operationResponse.OperationStatus.OperationStatusError != null)
{
WriteDebug(string.Format(
"OperationStatus Error: {0} " +
"OperationStatus Code: {1}",
operationResponse.OperationStatus.OperationStatusError.Message,
operationResponse.OperationStatus.OperationStatusError.Code));
}
}
}
else
{
// ServiceClient will return OK if NO datasources are associated with this policy
WriteDebug("No datasources are associated with Policy, http response code: " +
policyResponse.StatusCode.ToString());
}
});
}
