// Token: 0x060075F5 RID: 30197 RVA: 0x0018411C File Offset: 0x0018231C
public virtual ResourceLoad GetResourceLoad(WorkloadType type, bool raw = false, object optionalData = null)
{
VariantConfigurationSnapshot snapshot = VariantConfiguration.GetSnapshot(MachineSettingsContext.Local, null, null);
IWorkloadSettings @object = snapshot.WorkloadManagement.GetObject <IWorkloadSettings>(type, new object[0]);
return(this.GetResourceLoad(@object.Classification, raw, optionalData));
}
public ADReplicationHealthMonitor(WlmResource owner) : base(owner, ADResourceKey.Key)
{
WorkloadType wlmWorkloadType = owner.WlmWorkloadType;
if (wlmWorkloadType == WorkloadType.MailboxReplicationService)
{
base.ResourceHealthPerfCounter = MailboxReplicationServicePerformanceCounters.ADReplicationResourceHealth;
base.DynamicCapacityPerfCounter = MailboxReplicationServicePerformanceCounters.ADReplicationDynamicCapacity;
return;
}
if (wlmWorkloadType == WorkloadType.MailboxReplicationServiceHighPriority)
{
base.ResourceHealthPerfCounter = MailboxReplicationServicePerformanceCounters.ADReplicationResourceHealthHiPri;
base.DynamicCapacityPerfCounter = MailboxReplicationServicePerformanceCounters.ADReplicationDynamicCapacityHiPri;
return;
}
switch (wlmWorkloadType)
{
case WorkloadType.MailboxReplicationServiceInternalMaintenance:
base.ResourceHealthPerfCounter = MailboxReplicationServicePerformanceCounters.ADReplicationResourceHealthInternalMaintenance;
base.DynamicCapacityPerfCounter = MailboxReplicationServicePerformanceCounters.ADReplicationDynamicCapacityInternalMaintenance;
return;
case WorkloadType.MailboxReplicationServiceInteractive:
base.ResourceHealthPerfCounter = MailboxReplicationServicePerformanceCounters.ADReplicationResourceHealthCustomerExpectation;
base.DynamicCapacityPerfCounter = MailboxReplicationServicePerformanceCounters.ADReplicationDynamicCapacityCustomerExpectation;
return;
default:
return;
}
}
private DatabaseReadResource(Guid mdbGuid, WorkloadType workloadType) : base(mdbGuid, workloadType)
{
MDBPerfCounterHelper mdbhelper = MDBPerfCounterHelperCollection.GetMDBHelper(mdbGuid, true);
WorkloadType wlmWorkloadType = base.WlmWorkloadType;
if (wlmWorkloadType != WorkloadType.MailboxReplicationService)
{
if (wlmWorkloadType != WorkloadType.MailboxReplicationServiceHighPriority)
{
switch (wlmWorkloadType)
{
case WorkloadType.MailboxReplicationServiceInternalMaintenance:
base.UtilizationPerfCounter = mdbhelper.PerfCounter.UtilizationReadInternalMaintenance;
break;
case WorkloadType.MailboxReplicationServiceInteractive:
base.UtilizationPerfCounter = mdbhelper.PerfCounter.UtilizationReadCustomerExpectation;
break;
}
}
else
{
base.UtilizationPerfCounter = mdbhelper.PerfCounter.UtilizationReadHiPri;
}
}
else
{
base.UtilizationPerfCounter = mdbhelper.PerfCounter.UtilizationRead;
}
base.TransferRatePerfCounter = mdbhelper.ReadTransferRate;
}
/// <summary>
/// To get provider instance using workload type.
/// </summary>
public IPsBackupProvider GetProviderInstance(WorkloadType workloadType)
{
PsBackupProviderTypes providerType = 0;
switch (workloadType)
{
case WorkloadType.AzureVM:
providerType = PsBackupProviderTypes.IaasVm;
break;
case WorkloadType.AzureFiles:
providerType = PsBackupProviderTypes.AzureFiles;
break;
case WorkloadType.MSSQL:
providerType = PsBackupProviderTypes.AzureWorkload;
break;
default:
throw new ArgumentException(
string.Format(Resources.BackupManagementTypeRequiredForWorkloadType,
workloadType.ToString()));
}
return(GetProviderInstance(providerType));
}
private LocalServerWriteResource(WorkloadType workloadType) : base(workloadType)
{
WorkloadType wlmWorkloadType = base.WlmWorkloadType;
if (wlmWorkloadType != WorkloadType.MailboxReplicationService)
{
if (wlmWorkloadType != WorkloadType.MailboxReplicationServiceHighPriority)
{
switch (wlmWorkloadType)
{
case WorkloadType.MailboxReplicationServiceInternalMaintenance:
base.UtilizationPerfCounter = MailboxReplicationServicePerformanceCounters.UtilizationWriteInternalMaintenance;
break;
case WorkloadType.MailboxReplicationServiceInteractive:
base.UtilizationPerfCounter = MailboxReplicationServicePerformanceCounters.UtilizationWriteCustomerExpectation;
break;
}
}
else
{
base.UtilizationPerfCounter = MailboxReplicationServicePerformanceCounters.UtilizationWriteHiPri;
}
}
else
{
base.UtilizationPerfCounter = MailboxReplicationServicePerformanceCounters.UtilizationWrite;
}
base.TransferRatePerfCounter = LocalServerWriteResource.WriteTransferRatePerfCounter;
}
/// <summary>
/// To get provider instance using workload and backup management type.
/// </summary>
public IPsBackupProvider GetProviderInstance(
WorkloadType workloadType, BackupManagementType?backupManagementType)
{
PsBackupProviderTypes psProviderType;
switch (workloadType)
{
case WorkloadType.AzureVM:
// validate backupManagementType is valid
if (backupManagementType.HasValue && backupManagementType
!= BackupManagementType.AzureVM)
{
// throw exception that it is not expected
throw new ArgumentException(
String.Format(Resources.BackupManagementTypeNotExpectedForWorkloadType,
workloadType.ToString()));
}
psProviderType = PsBackupProviderTypes.IaasVm;
break;
default:
throw new ArgumentException(
String.Format(Resources.UnsupportedWorkloadTypeException,
workloadType.ToString()));
}
return(GetProviderInstance(psProviderType));
}
public MDBReplicationHealthMonitor(WlmResource owner, Guid mdbGuid) : base(owner, new MdbReplicationResourceHealthMonitorKey(mdbGuid))
{
MailboxReplicationServicePerMdbPerformanceCountersInstance perfCounter = MDBPerfCounterHelperCollection.GetMDBHelper(mdbGuid, true).PerfCounter;
WorkloadType wlmWorkloadType = owner.WlmWorkloadType;
if (wlmWorkloadType == WorkloadType.MailboxReplicationService)
{
base.ResourceHealthPerfCounter = perfCounter.ResourceHealthMDBReplication;
base.DynamicCapacityPerfCounter = perfCounter.DynamicCapacityMDBReplication;
return;
}
if (wlmWorkloadType == WorkloadType.MailboxReplicationServiceHighPriority)
{
base.ResourceHealthPerfCounter = perfCounter.ResourceHealthMDBReplicationHiPri;
base.DynamicCapacityPerfCounter = perfCounter.DynamicCapacityMDBReplicationHiPri;
return;
}
switch (wlmWorkloadType)
{
case WorkloadType.MailboxReplicationServiceInternalMaintenance:
base.ResourceHealthPerfCounter = perfCounter.ResourceHealthMDBReplicationInternalMaintenance;
base.DynamicCapacityPerfCounter = perfCounter.DynamicCapacityMDBReplicationInternalMaintenance;
return;
case WorkloadType.MailboxReplicationServiceInteractive:
base.ResourceHealthPerfCounter = perfCounter.ResourceHealthMDBReplicationCustomerExpectation;
base.DynamicCapacityPerfCounter = perfCounter.DynamicCapacityMDBReplicationCustomerExpectation;
return;
default:
return;
}
}
private static ICTLScenario CreateScenario(WorkloadType workloadType)
{
return(workloadType switch
{
WorkloadType.ReadWriteQuery => new ReadWriteQueryScenario(),
_ => throw new NotImplementedException($"No mapping for {workloadType}"),
});
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));
}
private WorkloadType GetWorkloadType(WorkloadType workloadType)
{
if (workloadType == WorkloadType.Unknown)
{
return(this.WorkloadTypeFromJob);
}
return(workloadType);
}
public TaskRunSyncTest(TestParameters_RunSync parameters)
{
_preTaskStatus = parameters.PreTaskStatus;
_postRunSyncAction = parameters.PostRunSyncAction;
_workloadType = parameters.WorkloadType;
_option = parameters.TaskCreationOptions;
_taskSchedulerType = parameters.TaskSchedulerType;
}
public TestParameters_RunSync(PreTaskStatus preTaskStatus, PostRunSyncAction postRunSyncAction, WorkloadType workType, TaskCreationOptions taskCreationOptions, TaskSchedulerType taskScheduler)
{
PreTaskStatus = preTaskStatus;
PostRunSyncAction = postRunSyncAction;
WorkloadType = workType;
TaskCreationOptions = taskCreationOptions;
TaskSchedulerType = taskScheduler;
}
// Token: 0x06000594 RID: 1428 RVA: 0x00010BA4 File Offset: 0x0000EDA4
internal static CallContext CreateAndSetCallContext(Message request, WorkloadType workloadType, bool duplicatedActionDetectionEnabled, string owaUserContextKey = "")
{
CallContext callContext = CallContextUtilities.CreateCallContext(request, null, duplicatedActionDetectionEnabled, owaUserContextKey);
callContext.OwaExplicitLogonUser = UserContextUtilities.GetExplicitLogonUser(HttpContext.Current);
callContext.WorkloadType = workloadType;
CallContext.SetCurrent(callContext);
return(callContext);
}
private static ICTLScenario CreateScenario(WorkloadType workloadType)
{
return(workloadType switch
{
WorkloadType.ReadWriteQuery => new ReadWriteQueryScenario(),
WorkloadType.ChangeFeedProcessor => new ChangeFeedProcessorScenario(),
WorkloadType.ChangeFeedPull => new ChangeFeedPullScenario(),
WorkloadType.Query => new QueryScenario(),
_ => throw new NotImplementedException($"No mapping for {workloadType}"),
});
private void VerifyResult(TaskInfo current)
{
TaskInfo ti = current;
WorkloadType workType = ti.WorkType;
if (workType == WorkloadType.Exceptional && _api != API.Cancel)
{
bool expCaught = FindException((ex) =>
{
TPLTestException expectedExp = ex as TPLTestException;
return(expectedExp != null && expectedExp.FromTaskId == ti.Task.Id);
});
if (!expCaught)
{
Assert.True(false, string.Format("expected TPLTestException in Task.Name = Task{0} NOT caught", current.Name));
}
}
else
{
if (ti.Task.Exception != null && _api == API.Wait)
{
Assert.True(false, string.Format("UNEXPECTED exception in Task.Name = Task{0} caught. Exception: {1}", current.Name, ti.Task.Exception));
}
if (ti.Task.IsCanceled && ti.Result != -42)
{
//this means that the task was not scheduled - it was cancelled or it is still in the queue
//-42 = UNINITIALED_RESULT
Assert.True(false, string.Format("Result must remain uninitialized for unstarted task"));
}
else if (ti.Task.IsCompleted)
{
//Function point comparison cant be done by rounding off to nearest decimal points since
//1.64 could be represented as 1.63999999 or as 1.6499999999. To perform floating point comparisons,
//a range has to be defined and check to ensure that the result obtained is within the specified range
double minLimit = 1.63;
double maxLimit = 1.65;
if (ti.Result < minLimit || ti.Result > maxLimit)
{
Assert.True(ti.Task.IsCanceled || ti.Task.IsFaulted,
string.Format(
"Expected Result to lie between {0} and {1} for completed task. Actual Result {2}. Using n={3} IsCanceled={4}",
minLimit,
maxLimit,
ti.Result,
workType,
ti.Task.IsCanceled));
}
}
}
}
public TResource GetInstance(Guid resourceID, WorkloadType workloadType)
{
ResourceCache<TResource> resourceCache;
lock (this.locker)
{
if (!this.resourceCaches.TryGetValue(workloadType, out resourceCache))
{
resourceCache = new ResourceCache<TResource>((Guid id) => this.createResourceDelegate(id, workloadType));
this.resourceCaches.Add(workloadType, resourceCache);
}
}
return resourceCache.GetInstance(resourceID);
}
public FormSelectCourseInWork(Database AmyDatabase, Employee filterEmployee, Group filterGroup,
Semestr filterSemestr, SchoolYear filterSchoolYear, WorkloadType filterWorkloadType,
CourseInWork exceptCourseInWork)
{
InitializeComponent();
myDatabase = AmyDatabase;
_filterEmployee = filterEmployee;
_filterGroup = filterGroup;
_filterSemestr = filterSemestr;
_filterSchoolYear = filterSchoolYear;
_filterWorkloadType = filterWorkloadType;
_exceptCourseInWork = exceptCourseInWork;
}
private static JobScheduler GetScheduler(WorkloadType workloadType)
{
JobScheduler jobScheduler;
if (!MailboxSyncerJobs.schedulers.TryGetValue(workloadType, out jobScheduler))
{
jobScheduler = new JobScheduler(workloadType);
jobScheduler.Start();
jobScheduler.JobStateChanged += MailboxSyncerJobs.JobStateChangedHandler;
MailboxSyncerJobs.schedulers.Add(workloadType, jobScheduler);
}
return(jobScheduler);
}
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 TaskInfo(TaskInfo parent, string TaskInfo_CancelWaitName, WorkloadType workType, string optionsString, bool cancelChildren)
: this(parent, TaskInfo_CancelWaitName, workType, optionsString)
{
CancelChildren = cancelChildren;
}
public TaskInfo(TaskInfo parent, string TaskInfo_CancelWaitName, WorkloadType workType, string optionsString)
{
Children = new LinkedList<TaskInfo>();
Result = s_UNINITIALED_RESULT;
Option = s_DEFAULT_OPTION;
Name = TaskInfo_CancelWaitName;
WorkType = workType;
Parent = parent;
CancelChildren = false;
CancellationTokenSource = new CancellationTokenSource();
CancellationToken = CancellationTokenSource.Token;
if (string.IsNullOrEmpty(optionsString))
return;
//
// Parse Task CreationOptions, if RespectParentCancellation we would want to acknowledge that
// and passed the remaining options for creation
//
string[] options = optionsString.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
int index = -1;
for (int i = 0; i < options.Length; i++)
{
string o = options[i].Trim(); // remove any white spaces.
options[i] = o;
if (o.Equals("RespectParentCancellation", StringComparison.OrdinalIgnoreCase))
{
IsRespectParentCancellation = true;
index = i;
}
}
if (index != -1)
{
string[] temp = new string[options.Length - 1];
int excludeIndex = index + 1;
Array.Copy(options, 0, temp, 0, index);
int leftToCopy = options.Length - excludeIndex;
Array.Copy(options, excludeIndex, temp, index, leftToCopy);
options = temp;
}
if (options.Length > 0)
{
TaskCreationOptions parsedOptions;
string joinedOptions = string.Join(",", options);
bool parsed = Enum.TryParse<TaskCreationOptions>(joinedOptions, out parsedOptions);
if (!parsed)
throw new NotSupportedException("could not parse the options string: " + joinedOptions);
Option = parsedOptions;
}
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
string backupManagementType = "";
string workloadType = "";
string containerName = "";
if (ParameterSetName == IdParamSet)
{
Dictionary <UriEnums, string> keyValueDict = HelperUtils.ParseUri(ParentID);
containerName = HelperUtils.GetContainerUri(keyValueDict, ParentID);
if (containerName.Split(new string[] { ";" }, System.StringSplitOptions.None)[0].ToLower() == "vmappcontainer")
{
backupManagementType = ServiceClientModel.BackupManagementType.AzureWorkload;
}
string protectableItem = HelperUtils.GetProtectableItemUri(keyValueDict, ParentID);
if (protectableItem.Split(new string[] { ";" }, System.StringSplitOptions.None)[0].ToLower() == "sqlinstance" ||
protectableItem.Split(new string[] { ";" }, System.StringSplitOptions.None)[0].ToLower() == "sqlavailabilitygroupcontainer")
{
workloadType = ServiceClientModel.WorkloadType.SQLDataBase;
}
}
else
{
backupManagementType = Container.BackupManagementType.ToString();
workloadType = ConversionUtils.GetServiceClientWorkloadType(WorkloadType.ToString());
containerName = Container.Name;
}
ODataQuery <BMSPOQueryObject> queryParam = new ODataQuery <BMSPOQueryObject>(
q => q.BackupManagementType
== backupManagementType &&
q.WorkloadType == workloadType &&
q.ContainerName == containerName);
WriteDebug("going to query service to get list of protectable items");
List <WorkloadProtectableItemResource> protectableItems =
ServiceClientAdapter.ListProtectableItem(
queryParam,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
WriteDebug("Successfully got response from service");
List <ProtectableItemBase> itemModels = ConversionHelpers.GetProtectableItemModelList(protectableItems);
if (ParameterSetName == FilterParamSet)
{
string protectableItemType = ItemType.ToString();
itemModels = itemModels.Where(itemModel =>
{
return(((AzureWorkloadProtectableItem)itemModel).ProtectableItemType == protectableItemType);
}).ToList();
}
WriteObject(itemModels, enumerateCollection: true);
});
}
public TaskInfo(TaskInfo parent, string TaskInfo_CancelWaitName, WorkloadType workType, string optionsString, bool cancelChildren)
: this(parent, TaskInfo_CancelWaitName, workType, optionsString)
{
CancelChildren = cancelChildren;
}
public TaskInfo(WorkloadType workType)
{
CancellationTokenSource = new CancellationTokenSource();
CancellationToken = CancellationTokenSource.Token;
Result = s_UNINITIALED_RESULT;
WorkType = workType;
}
public DatabaseResource(Guid mdbGuid, WorkloadType workloadType) : base(workloadType)
{
base.ResourceGuid = mdbGuid;
base.ConfigContext = new DatabaseSettingsContext(base.ResourceGuid, base.ConfigContext);
}
public WlmResource(WorkloadType workloadType)
{
this.WlmWorkloadType = workloadType;
this.ResourceGuid = Guid.Empty;
base.ConfigContext = new GenericSettingsContext("WorkloadType", this.WlmWorkloadType.ToString(), base.ConfigContext);
}
/// <summary>
/// To get provider instance using workload type.
/// </summary>
public IPsBackupProvider GetProviderInstance(WorkloadType workloadType)
{
PsBackupProviderTypes providerType = 0;
switch (workloadType)
{
case WorkloadType.AzureVM:
providerType = PsBackupProviderTypes.IaasVm;
break;
default:
throw new ArgumentException(
String.Format(Resources.BackupManagementTypeRequiredForWorkloadType,
workloadType.ToString()));
}
return GetProviderInstance(providerType);
}
/// <summary>
/// To get provider instance using workload and backup management type.
/// </summary>
public IPsBackupProvider GetProviderInstance(
WorkloadType workloadType, BackupManagementType? backupManagementType)
{
PsBackupProviderTypes psProviderType;
switch (workloadType)
{
case WorkloadType.AzureVM:
// validate backupManagementType is valid
if (backupManagementType.HasValue && backupManagementType
!= BackupManagementType.AzureVM)
{
// throw exception that it is not expected
throw new ArgumentException(
String.Format(Resources.BackupManagementTypeNotExpectedForWorkloadType,
workloadType.ToString()));
}
psProviderType = PsBackupProviderTypes.IaasVm;
break;
default:
throw new ArgumentException(
String.Format(Resources.UnsupportedWorkloadTypeException,
workloadType.ToString()));
}
return GetProviderInstance(psProviderType);
}
public object?[] CrateArgument(KeyValuePair <string, string>[] arguments)
{
var ctors = WorkloadType.GetConstructors();
if (ctors.Length == 0)
{
return(Array.Empty <object>());
}
var ctor = ctors[0];
var dict = arguments.ToDictionary(x => x.Key, x => x.Value);
var parameters = ctor.GetParameters();
var result = parameters
.Where(x => !isService.IsService(x.ParameterType))
.Select(p =>
{
if (!dict.TryGetValue(p.Name !, out string?parameterValue))
{
parameterValue = null;
}
var elementType = p.ParameterType;
var parameterType = ConvertToAllowParameterType(ref elementType, out var isNullable, out var isArray) !.Value;
// case of T[]
if (isArray)
{
if (string.IsNullOrEmpty(parameterValue))
{
return(Array.CreateInstance(elementType, 0));
}
var values = parameterValue !.Split(',');
var array = Array.CreateInstance(elementType, values.Length);
for (int i = 0; i < array.Length; i++)
{
array.SetValue(Parse(values[i]), i);
}
return(array);
}
else
{
return(Parse(parameterValue));
}
object?Parse(string?v)
{
if (v == null || (elementType != typeof(string) && (v == "null") || v == ""))
{
if (p.HasDefaultValue)
{
return(p.DefaultValue);
}
else if (isNullable || parameterType == AllowParameterType.String)
{
return(null);
}
throw new InvalidOperationException($"Required parameter is not exist, Type: {p.ParameterType.FullName} ParameterName: {p.Name}");
}
return(ParseAllowParameterType(parameterType, elementType, p, v));
}
})
.ToArray();
return(result);
}
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}, " +
"ParameterSetName: {3}",
Name == null ? "NULL" : Name,
WorkloadType.HasValue ? WorkloadType.ToString() : "NULL",
BackupManagementType.HasValue ?
BackupManagementType.ToString() : "NULL",
this.ParameterSetName));
if (ParameterSetName == PolicyNameParamSet)
{
// validate policyName
PolicyCmdletHelpers.ValidateProtectionPolicyName(Name);
// query service
ServiceClientModel.ProtectionPolicyResource policy =
PolicyCmdletHelpers.GetProtectionPolicyByName(
Name,
ServiceClientAdapter,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
if (policy == null)
{
throw new ArgumentException(string.Format(Resources.PolicyNotFoundException, Name));
}
WriteObject(ConversionHelpers.GetPolicyModel(policy));
}
else
{
List <PolicyBase> policyList = new List <PolicyBase>();
string serviceClientProviderType = null;
switch (this.ParameterSetName)
{
case WorkloadParamSet:
if (WorkloadType == Models.WorkloadType.AzureVM)
{
serviceClientProviderType =
ServiceClientHelpers.GetServiceClientProviderType(Models.WorkloadType.AzureVM);
}
else if (WorkloadType == Models.WorkloadType.AzureSQLDatabase)
{
serviceClientProviderType = ServiceClientHelpers.GetServiceClientProviderType(Models.WorkloadType.AzureSQLDatabase);
}
else if (WorkloadType == Models.WorkloadType.AzureFiles)
{
serviceClientProviderType = ServiceClientHelpers.GetServiceClientProviderType(Models.WorkloadType.AzureFiles);
}
else if (WorkloadType == Models.WorkloadType.MSSQL)
{
serviceClientProviderType = ServiceClientHelpers.GetServiceClientProviderType(Models.WorkloadType.MSSQL);
}
break;
case WorkloadBackupMangementTypeParamSet:
if (WorkloadType == Models.WorkloadType.AzureVM)
{
if (BackupManagementType != Models.BackupManagementType.AzureVM)
{
throw new ArgumentException(
Resources.AzureVMUnsupportedBackupManagementTypeException);
}
serviceClientProviderType = ServiceClientHelpers.
GetServiceClientProviderType(Models.WorkloadType.AzureVM);
}
else if (WorkloadType == Models.WorkloadType.AzureSQLDatabase)
{
if (BackupManagementType != Models.BackupManagementType.AzureSQL)
{
throw new ArgumentException(
Resources.AzureSqlUnsupportedBackupManagementTypeException);
}
serviceClientProviderType =
ServiceClientHelpers.GetServiceClientProviderType(
Models.WorkloadType.AzureSQLDatabase);
}
else if (WorkloadType == Models.WorkloadType.AzureFiles)
{
if (BackupManagementType != Models.BackupManagementType.AzureStorage)
{
throw new ArgumentException(
Resources.AzureFileUnsupportedBackupManagementTypeException);
}
serviceClientProviderType =
ServiceClientHelpers.GetServiceClientProviderType(
Models.WorkloadType.AzureFiles);
}
else if (WorkloadType == Models.WorkloadType.AzureFiles)
{
if (BackupManagementType != Models.BackupManagementType.AzureStorage)
{
throw new ArgumentException(
Resources.AzureFileUnsupportedBackupManagementTypeException);
}
serviceClientProviderType =
ServiceClientHelpers.GetServiceClientProviderType(
Models.WorkloadType.AzureFiles);
}
else if (WorkloadType == Models.WorkloadType.MSSQL)
{
if (BackupManagementType != Models.BackupManagementType.AzureWorkload)
{
throw new ArgumentException(
Resources.AzureFileUnsupportedBackupManagementTypeException);
}
serviceClientProviderType =
ServiceClientHelpers.GetServiceClientProviderType(
Models.WorkloadType.MSSQL);
}
else
{
throw new ArgumentException(string.Format(
Resources.UnsupportedWorkloadBackupManagementTypeException,
WorkloadType.ToString(),
BackupManagementType.ToString()));
}
break;
default:
break;
}
var backupManagementTypeFilter = serviceClientProviderType;
ODataQuery <ServiceClientModel.ProtectionPolicyQueryObject> queryParams
= new ODataQuery <ServiceClientModel.ProtectionPolicyQueryObject>(
q => q.BackupManagementType == backupManagementTypeFilter);
WriteDebug("going to query service to get list of policies");
List <ServiceClientModel.ProtectionPolicyResource> respList =
ServiceClientAdapter.ListProtectionPolicy(
queryParams,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
WriteDebug("Successfully got response from service");
policyList = ConversionHelpers.GetPolicyModelList(respList);
WriteObject(policyList, enumerateCollection: true);
}
});
}
public TestParameters_RunSync(PreTaskStatus preTaskStatus, PostRunSyncAction postRunSyncAction, WorkloadType workType, TaskCreationOptions taskCreationOptions, TaskSchedulerType taskScheduler)
{
PreTaskStatus = preTaskStatus;
PostRunSyncAction = postRunSyncAction;
WorkloadType = workType;
TaskCreationOptions = taskCreationOptions;
TaskSchedulerType = taskScheduler;
}
public TaskRunSyncTest(TestParameters_RunSync parameters)
{
_preTaskStatus = parameters.PreTaskStatus;
_postRunSyncAction = parameters.PostRunSyncAction;
_workloadType = parameters.WorkloadType;
_option = parameters.TaskCreationOptions;
_taskSchedulerType = parameters.TaskSchedulerType;
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
WriteDebug(string.Format("Input params - Name:{0}, " +
"WorkloadType: {1}, BackupManagementType:{2}, " +
"ParameterSetName: {3}",
Name == null ? "NULL" : Name,
WorkloadType.HasValue ? WorkloadType.ToString() : "NULL",
BackupManagementType.HasValue ?
BackupManagementType.ToString() : "NULL",
this.ParameterSetName));
if (this.ParameterSetName == PolicyNameParamSet)
{
// validate policyName
PolicyCmdletHelpers.ValidateProtectionPolicyName(Name);
// query service
ServiceClientModel.ProtectionPolicyResponse policy =
PolicyCmdletHelpers.GetProtectionPolicyByName(
Name,
ServiceClientAdapter);
if (policy == null)
{
throw new ArgumentException(string.Format(Resources.PolicyNotFoundException, Name));
}
WriteObject(ConversionHelpers.GetPolicyModel(policy.Item));
}
else
{
List <PolicyBase> policyList = new List <PolicyBase>();
string serviceClientProviderType = null;
switch (this.ParameterSetName)
{
case WorkloadParamSet:
if (WorkloadType == Models.WorkloadType.AzureVM)
{
serviceClientProviderType =
ServiceClientHelpers.GetServiceClientProviderType(Models.WorkloadType.AzureVM);
}
break;
case WorkloadBackupMangementTypeParamSet:
if (WorkloadType == Models.WorkloadType.AzureVM)
{
if (BackupManagementType != Models.BackupManagementType.AzureVM)
{
throw new ArgumentException(
Resources.AzureVMUnsupportedBackupManagementTypeException);
}
serviceClientProviderType = ServiceClientHelpers.
GetServiceClientProviderType(Models.WorkloadType.AzureVM);
}
else
{
throw new ArgumentException(string.Format(
Resources.UnsupportedWorkloadBackupManagementTypeException,
WorkloadType.ToString(),
BackupManagementType.ToString()));
}
break;
default:
break;
}
ServiceClientModel.ProtectionPolicyQueryParameters queryParams =
new ServiceClientModel.ProtectionPolicyQueryParameters()
{
BackupManagementType = serviceClientProviderType
};
WriteDebug("going to query service to get list of policies");
ServiceClientModel.ProtectionPolicyListResponse respList =
ServiceClientAdapter.ListProtectionPolicy(queryParams);
WriteDebug("Successfully got response from service");
policyList = ConversionHelpers.GetPolicyModelList(respList);
WriteObject(policyList, enumerateCollection: true);
}
});
}
public LocalServerResource(WorkloadType workloadType) : base(workloadType)
{
base.ResourceGuid = LocalServerResource.ResourceId;
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string vaultResourceGroupName = resourceIdentifier.ResourceGroupName;
string workloadType = ConversionUtils.GetServiceClientWorkloadType(WorkloadType.ToString());
string backupManagementType = Container.BackupManagementType.ToString();
ODataQuery <BMSContainersInquiryQueryObject> queryParams = new ODataQuery <BMSContainersInquiryQueryObject>(
q => q.WorkloadType == workloadType && q.BackupManagementType == backupManagementType);
string errorMessage = string.Empty;
var inquiryResponse = ServiceClientAdapter.InquireContainer(
Container.Name,
queryParams,
vaultName,
vaultResourceGroupName);
var operationStatus = TrackingHelpers.GetOperationResult(
inquiryResponse,
operationId =>
ServiceClientAdapter.GetRegisterContainerOperationResult(
operationId,
Container.Name,
vaultName: vaultName,
resourceGroupName: vaultResourceGroupName));
if (inquiryResponse.Response.StatusCode
== SystemNet.HttpStatusCode.OK)
{
Logger.Instance.WriteDebug(errorMessage);
}
//Now wait for the operation to Complete
if (inquiryResponse.Response.StatusCode
!= SystemNet.HttpStatusCode.NoContent)
{
errorMessage = string.Format(Resources.TriggerEnquiryFailureErrorCode,
inquiryResponse.Response.StatusCode);
Logger.Instance.WriteDebug(errorMessage);
}
if (PassThru.IsPresent)
{
WriteObject(Container);
}
}, ShouldProcess(Container.Name, VerbsLifecycle.Invoke));
}
public TaskInfo(TaskInfo parent, string TaskInfo_CancelWaitName, WorkloadType workType, string optionsString)
{
Children = new LinkedList <TaskInfo>();
Result = s_UNINITIALED_RESULT;
Option = s_DEFAULT_OPTION;
Name = TaskInfo_CancelWaitName;
WorkType = workType;
Parent = parent;
CancelChildren = false;
CancellationTokenSource = new CancellationTokenSource();
CancellationToken = CancellationTokenSource.Token;
if (string.IsNullOrEmpty(optionsString))
{
return;
}
//
// Parse Task CreationOptions, if RespectParentCancellation we would want to acknowledge that
// and passed the remaining options for creation
//
string[] options = optionsString.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
int index = -1;
for (int i = 0; i < options.Length; i++)
{
string o = options[i].Trim(); // remove any whitespace.
options[i] = o;
if (o.Equals("RespectParentCancellation", StringComparison.OrdinalIgnoreCase))
{
IsRespectParentCancellation = true;
index = i;
}
}
if (index != -1)
{
string[] temp = new string[options.Length - 1];
int excludeIndex = index + 1;
Array.Copy(options, 0, temp, 0, index);
int leftToCopy = options.Length - excludeIndex;
Array.Copy(options, excludeIndex, temp, index, leftToCopy);
options = temp;
}
if (options.Length > 0)
{
TaskCreationOptions parsedOptions;
string joinedOptions = string.Join(",", options);
bool parsed = Enum.TryParse <TaskCreationOptions>(joinedOptions, out parsedOptions);
if (!parsed)
{
throw new NotSupportedException("could not parse the options string: " + joinedOptions);
}
Option = parsedOptions;
}
}
public ResourceLoad GetResourceLoad(WorkloadType type, bool raw = false, object optionalData = null)
{
this.CheckExpired();
return(this.wrappedMonitor.GetResourceLoad(type, raw, optionalData));
}
