/// <summary>
/// The Begin Creating Storage Account operation creates a new storage
/// account in Azure.
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.StorSimple.IServiceConfigurationOperations.
/// </param>
/// <param name='serviceConfiguration'>
/// Required. Parameters supplied to the Begin Creating Storage Account
/// operation.
/// </param>
/// <param name='customRequestHeaders'>
/// Required. The Custom Request Headers which client must use.
/// </param>
/// <returns>
/// This is the Task Response for all Async Calls
/// </returns>
public static TaskResponse BeginCreating(this IServiceConfigurationOperations operations, ServiceConfiguration serviceConfiguration, CustomRequestHeaders customRequestHeaders)
{
return Task.Factory.StartNew((object s) =>
{
return ((IServiceConfigurationOperations)s).BeginCreatingAsync(serviceConfiguration, customRequestHeaders);
}
, operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
}
/// <summary>
/// Begin a backup operation for the policyId and backupRequest
/// specified.
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.StorSimple.IBackupOperations.
/// </param>
/// <param name='deviceId'>
/// Required. The device id for which the call will be made.
/// </param>
/// <param name='policyId'>
/// Required. The policy id for which the call will be made.
/// </param>
/// <param name='backupRequest'>
/// Required. Parameters supplied to the Begin Backup operation.
/// </param>
/// <param name='customRequestHeaders'>
/// Required. The Custom Request Headers which client must use.
/// </param>
/// <returns>
/// This is the Task Response for all Async Calls
/// </returns>
public static TaskResponse BeginCreatingBackup(this IBackupOperations operations, string deviceId, string policyId, BackupNowRequest backupRequest, CustomRequestHeaders customRequestHeaders)
{
return Task.Factory.StartNew((object s) =>
{
return ((IBackupOperations)s).BeginCreatingBackupAsync(deviceId, policyId, backupRequest, customRequestHeaders);
}
, operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
}
/// <summary>
/// Begin async task to update a device job.
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.StorSimple.IDeviceJobOperations.
/// </param>
/// <param name='deviceId'>
/// Required. id of device
/// </param>
/// <param name='jobId'>
/// Required. id of job to update
/// </param>
/// <param name='updateRequest'>
/// Required. Request data, contains the action to be taken
/// </param>
/// <param name='customRequestHeaders'>
/// Required. The Custom Request Headers which client must use.
/// </param>
/// <returns>
/// This is the Task Response for all Async Calls
/// </returns>
public static GuidTaskResponse BeginUpdateDeviceJob(this IDeviceJobOperations operations, string deviceId, string jobId, UpdateDeviceJobRequest updateRequest, CustomRequestHeaders customRequestHeaders)
{
return Task.Factory.StartNew((object s) =>
{
return ((IDeviceJobOperations)s).BeginUpdateDeviceJobAsync(deviceId, jobId, updateRequest, customRequestHeaders);
}
, operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
}
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.StorSimple.IDeviceFailoverOperations.
/// </param>
/// <param name='deviceId'>
/// Optional.
/// </param>
/// <param name='customRequestHeaders'>
/// Optional.
/// </param>
/// <returns>
/// Represents the response model for DataContainerGroups Get call
/// </returns>
public static DataContainerGroupsGetResponse ListDCGroups(this IDeviceFailoverOperations operations, string deviceId, CustomRequestHeaders customRequestHeaders)
{
return Task.Factory.StartNew((object s) =>
{
return ((IDeviceFailoverOperations)s).ListDCGroupsAsync(deviceId, customRequestHeaders);
}
, operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
}
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.StorSimple.IIscsiConnectionDetailsOperations.
/// </param>
/// <param name='deviceId'>
/// Required. The device id for which the call will be made.
/// </param>
/// <param name='customRequestHeaders'>
/// Required. The Custom Request Headers which client can use.
/// </param>
/// <returns>
/// The response model for the list of iscsi connection details.
/// </returns>
public static IscsiConnectionResponse Get(this IIscsiConnectionDetailsOperations operations, string deviceId, CustomRequestHeaders customRequestHeaders)
{
return Task.Factory.StartNew((object s) =>
{
return ((IIscsiConnectionDetailsOperations)s).GetAsync(deviceId, customRequestHeaders);
}
, operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
}
/// <summary>
/// Begin task for updating device details as specified by
/// deviceDetails. The task can then be tracked for completion using
/// returned task information
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.StorSimple.IDeviceDetailsOperations.
/// </param>
/// <param name='deviceDetails'>
/// Required. Updated DeviceDetails. Contains the corresponding DeviceId
/// </param>
/// <param name='customRequestHeaders'>
/// Required. The Custom Request Headers which client must use.
/// </param>
/// <returns>
/// This is the Task Response for all Async Calls
/// </returns>
public static GuidTaskResponse BeginUpdateDeviceDetails(this IDeviceDetailsOperations operations, DeviceDetailsRequest deviceDetails, CustomRequestHeaders customRequestHeaders)
{
return Task.Factory.StartNew((object s) =>
{
return ((IDeviceDetailsOperations)s).BeginUpdateDeviceDetailsAsync(deviceDetails, customRequestHeaders);
}
, operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
}
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.StorSimple.IResourceEncryptionKeyOperations.
/// </param>
/// <param name='customRequestHeaders'>
/// Required. The Custom Request Headers which client must use.
/// </param>
/// <returns>
/// The response model for Resource Encryption Key.
/// </returns>
public static GetResourceEncryptionKeyResponse Get(this IResourceEncryptionKeyOperations operations, CustomRequestHeaders customRequestHeaders)
{
return Task.Factory.StartNew((object s) =>
{
return ((IResourceEncryptionKeyOperations)s).GetAsync(customRequestHeaders);
}
, operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
}
/// <summary>
/// The Create Virtual Device
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.StorSimple.IVirtualDeviceOperations.
/// </param>
/// <param name='virtualDeviceProvisioningInfo'>
/// Required. The Virtual device provisioning info.
/// </param>
/// <param name='customRequestHeaders'>
/// Required. The Custom Request Headers which client must use.
/// </param>
/// <returns>
/// This is the Job Response for all Device Job Related Calls
/// </returns>
public static JobResponse Create(this IVirtualDeviceOperations operations, VirtualDeviceProvisioningInfo virtualDeviceProvisioningInfo, CustomRequestHeaders customRequestHeaders)
{
return Task.Factory.StartNew((object s) =>
{
return ((IVirtualDeviceOperations)s).CreateAsync(virtualDeviceProvisioningInfo, customRequestHeaders);
}
, operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
}
/// <summary>
/// Clone a backup element.
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.StorSimple.ICloneVolumeOperations.
/// </param>
/// <param name='sourceDeviceId'>
/// Required. The identifier of the source device from which clone is
/// to be triggered
/// </param>
/// <param name='triggerCloneRequest'>
/// Required. The parameters required for clone operation
/// </param>
/// <param name='customRequestHeaders'>
/// Required. The Custom Request Headers which client must use
/// </param>
/// <returns>
/// This is the Job Response for all Device Job Related Calls
/// </returns>
public static JobResponse Trigger(this ICloneVolumeOperations operations, string sourceDeviceId, TriggerCloneRequest triggerCloneRequest, CustomRequestHeaders customRequestHeaders)
{
return Task.Factory.StartNew((object s) =>
{
return ((ICloneVolumeOperations)s).TriggerAsync(sourceDeviceId, triggerCloneRequest, customRequestHeaders);
}
, operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
}
/// <summary>
/// The Begin Creating Volume operation creates a new volume.
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.StorSimple.IVirtualDiskOperations.
/// </param>
/// <param name='deviceId'>
/// Required. device id
/// </param>
/// <param name='diskDetails'>
/// Required. Parameters supplied to the Create virtual disk operation.
/// </param>
/// <param name='customRequestHeaders'>
/// Required. The Custom Request Headers which client must use.
/// </param>
/// <returns>
/// This is the Task Response for all Async Calls
/// </returns>
public static GuidTaskResponse BeginCreating(this IVirtualDiskOperations operations, string deviceId, VirtualDiskRequest diskDetails, CustomRequestHeaders customRequestHeaders)
{
return Task.Factory.StartNew((object s) =>
{
return ((IVirtualDiskOperations)s).BeginCreatingAsync(deviceId, diskDetails, customRequestHeaders);
}
, operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
}
/// <summary>
/// Hydra spec for update data container statusThe rest api updates the
/// status of volume container migration from target device to service
/// for all volume container in the specified config
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.StorSimple.IMigrationOperations.
/// </param>
/// <param name='configId'>
/// Required. Unique identifier for config specified while importing
/// the config to service
/// </param>
/// <param name='customRequestHeaders'>
/// Required. The Custom Request Headers which client must use.
/// </param>
/// <returns>
/// This is the Task Response for all Async Calls
/// </returns>
public static TaskResponse BeginUpdateDataContainerMigrationStatus(this IMigrationOperations operations, string configId, CustomRequestHeaders customRequestHeaders)
{
return Task.Factory.StartNew((object s) =>
{
return ((IMigrationOperations)s).BeginUpdateDataContainerMigrationStatusAsync(configId, customRequestHeaders);
}
, operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
}
public void CanAddACRTest()
{
using (var context = UndoContext.Current)
{
context.Start();
var client = GetServiceClient<StorSimpleManagementClient>();
var serviceConfig = new ServiceConfiguration()
{
AcrChangeList = new AcrChangeList()
{
Added = new []
{
new AccessControlRecord()
{
GlobalId = null,
InitiatorName = TestUtilities.GenerateName("InitiatorName"),
InstanceId = null,
Name = TestUtilities.GenerateName("AcrName"),
VolumeCount = 0
},
},
Deleted = new List<string>(),
Updated = new List<AccessControlRecord>()
},
CredentialChangeList = new SacChangeList(),
};
CustomRequestHeaders hdrs = new CustomRequestHeaders();
hdrs.ClientRequestId = Guid.NewGuid().ToString();
hdrs.Language = "en-us";
var taskStatus = client.ServiceConfig.Create(serviceConfig, hdrs);
Assert.NotNull(taskStatus);
Assert.True(taskStatus.Status == AsyncTaskStatus.Completed);
Assert.True(taskStatus.Result == AsyncTaskResult.Succeeded);
}
}
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.StorSimple.IVirtualDiskOperations.
/// </param>
/// <param name='deviceId'>
/// Required. device id
/// </param>
/// <param name='diskId'>
/// Required. disk id
/// </param>
/// <param name='diskDetails'>
/// Required. Parameters supplied to the update virtual disk operation.
/// </param>
/// <param name='customRequestHeaders'>
/// Required. The Custom Request Headers which client must use.
/// </param>
/// <returns>
/// Info about the async task
/// </returns>
public static Task<TaskStatusInfo> UpdateAsync(this IVirtualDiskOperations operations, string deviceId, string diskId, VirtualDisk diskDetails, CustomRequestHeaders customRequestHeaders)
{
return operations.UpdateAsync(deviceId, diskId, diskDetails, customRequestHeaders, CancellationToken.None);
}
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.StorSimple.IVirtualDiskOperations.
/// </param>
/// <param name='deviceId'>
/// Optional.
/// </param>
/// <param name='dataContainerId'>
/// Optional.
/// </param>
/// <param name='customRequestHeaders'>
/// Optional.
/// </param>
/// <returns>
/// The response model for the list of virtual disks for a given data
/// container.
/// </returns>
public static Task<VirtualDiskListResponse> ListAsync(this IVirtualDiskOperations operations, string deviceId, string dataContainerId, CustomRequestHeaders customRequestHeaders)
{
return operations.ListAsync(deviceId, dataContainerId, customRequestHeaders, CancellationToken.None);
}
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.StorSimple.IVirtualDiskOperations.
/// </param>
/// <param name='deviceId'>
/// Optional.
/// </param>
/// <param name='dataContainerId'>
/// Optional.
/// </param>
/// <param name='customRequestHeaders'>
/// Optional.
/// </param>
/// <returns>
/// The response model for the list of virtual disks for a given data
/// container.
/// </returns>
public static VirtualDiskListResponse List(this IVirtualDiskOperations operations, string deviceId, string dataContainerId, CustomRequestHeaders customRequestHeaders)
{
return Task.Factory.StartNew((object s) =>
{
return ((IVirtualDiskOperations)s).ListAsync(deviceId, dataContainerId, customRequestHeaders);
}
, operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
}
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.StorSimple.IVirtualDiskOperations.
/// </param>
/// <param name='deviceId'>
/// Optional.
/// </param>
/// <param name='diskName'>
/// Optional.
/// </param>
/// <param name='customRequestHeaders'>
/// Optional.
/// </param>
/// <returns>
/// The response model for the get of virtual disk.
/// </returns>
public static Task<VirtualDiskGetResponse> GetByNameAsync(this IVirtualDiskOperations operations, string deviceId, string diskName, CustomRequestHeaders customRequestHeaders)
{
return operations.GetByNameAsync(deviceId, diskName, customRequestHeaders, CancellationToken.None);
}
public void VirtualDiskScenarioTest()
{
using (var context = UndoContext.Current)
{
context.Start();
var client = GetServiceClient<StorSimpleManagementClient>();
// Listing all Devices
var devices = client.Devices.List(GetCustomRequestHeaders());
// Asserting that atleast One Device is returned.
Assert.True(devices != null);
Assert.True(devices.Any());
var actualdeviceId = devices.FirstOrDefault().DeviceId;
actualdeviceId = actualdeviceId.Trim();
CustomRequestHeaders hdrs = new CustomRequestHeaders();
hdrs.ClientRequestId = Guid.NewGuid().ToString();
hdrs.Language = "en-us";
//Get service configuration
var serviceConfigList = client.ServiceConfig.Get(GetCustomRequestHeaders());
Assert.True(serviceConfigList != null);
var existingSac = serviceConfigList.CredentialChangeList.Updated.FirstOrDefault();
Assert.True(existingSac != null);
var dataContainerName = TestUtilities.GenerateName("DCName");
// new Data container request object
var dc = new DataContainerRequest();
dc.IsDefault = false;
dc.Name = dataContainerName;
dc.BandwidthRate = 256;
dc.VolumeCount = 0;
dc.IsEncryptionEnabled = false;
dc.PrimaryStorageAccountCredential = existingSac;
//Create DataContainer call
var taskStatus = client.DataContainer.Create(actualdeviceId, dc, hdrs);
//Assert the job status
Assert.NotNull(taskStatus);
Assert.True(taskStatus.Status == AsyncTaskStatus.Completed);
Assert.True(taskStatus.Result == AsyncTaskResult.Succeeded);
//Get Data Container call
var Createddatacontainer = client.DataContainer.Get(actualdeviceId, dataContainerName, hdrs);
//Assert the returned data container object
Assert.True(Createddatacontainer != null);
Assert.True(Createddatacontainer.DataContainerInfo.Name.Equals(dataContainerName));
//ACR list for Virtual disk creation
List<AccessControlRecord> acrList = new List<AccessControlRecord>();
for (var i = 0; i < 1; i++)
{
AccessControlRecord acr = new AccessControlRecord()
{
Name = TestUtilities.GenerateName("VDnewTestAcr"),
InitiatorName = TestUtilities.GenerateName("VDinitiator") + i
};
acrList.Add(acr);
}
//Virtual disk create request object
var virtualDiskToCreate = new VirtualDiskRequest()
{
Name = TestUtilities.GenerateName("VDName"),
AccessType = AccessType.ReadWrite,
AcrList = acrList,
AppType = AppType.ArchiveVolume,
IsDefaultBackupEnabled = true,
SizeInBytes = 10737418240,
DataContainer = Createddatacontainer.DataContainerInfo,
Online = true
};
//Virtual disk create call
taskStatus = client.VirtualDisk.Create(actualdeviceId, virtualDiskToCreate, hdrs);
//Asserting the job status
Assert.NotNull(taskStatus);
Assert.True(taskStatus.Status == AsyncTaskStatus.Completed);
Assert.True(taskStatus.Result == AsyncTaskResult.Succeeded);
//virtual disk list call
var vdlist = client.VirtualDisk.List(actualdeviceId, Createddatacontainer.DataContainerInfo.InstanceId, hdrs);
Assert.True(vdlist != null);
Assert.True(vdlist.Any());
var vdbbyname = client.VirtualDisk.GetByName(actualdeviceId, vdlist.ListofVirtualDisks[0].Name, hdrs);
Assert.True(vdbbyname != null);
var virtualDiskToUpdate = vdbbyname.VirtualDiskInfo;
virtualDiskToUpdate.SizeInBytes = 21474836480;
virtualDiskToUpdate.Online = false;
taskStatus = client.VirtualDisk.Update(actualdeviceId, virtualDiskToUpdate.InstanceId,
virtualDiskToUpdate, hdrs);
//Asserting the job status
Assert.NotNull(taskStatus);
Assert.True(taskStatus.Status == AsyncTaskStatus.Completed);
Assert.True(taskStatus.Result == AsyncTaskResult.Succeeded);
taskStatus = client.VirtualDisk.Delete(actualdeviceId, virtualDiskToUpdate.InstanceId, hdrs);
//Asserting the job status
Assert.NotNull(taskStatus);
Assert.True(taskStatus.Status == AsyncTaskStatus.Completed);
Assert.True(taskStatus.Result == AsyncTaskResult.Succeeded);
}
}
private CustomRequestHeaders GetCustomRequestHeaders()
{
var hdrs = new CustomRequestHeaders()
{
// ClientRequestId is a unique ID for every request to StorSimple .
// It is useful when diagnosing failures in API calls.
ClientRequestId = this.ClientRequestId,
Language = "en-US"
};
return hdrs;
}
public void BackupScenarioTest()
{
using (var context = UndoContext.Current)
{
context.Start();
var client = GetServiceClient<StorSimpleManagementClient>();
// Listing all Devices
var devices = client.Devices.List(GetCustomRequestHeaders());
// Asserting that atleast One Device is returned.
Assert.True(devices != null);
Assert.True(devices.Any());
var actualdeviceId = devices.FirstOrDefault().DeviceId;
actualdeviceId = actualdeviceId.Trim();
CustomRequestHeaders hdrs = new CustomRequestHeaders();
hdrs.ClientRequestId = Guid.NewGuid().ToString();
hdrs.Language = "en-us";
//Get service configuration
var serviceConfigList = client.ServiceConfig.Get(GetCustomRequestHeaders());
Assert.True(serviceConfigList != null);
var existingSac = serviceConfigList.CredentialChangeList.Updated.FirstOrDefault();
Assert.True(existingSac != null);
var dataContainerName = TestUtilities.GenerateName("DCName");
// new Data container request object
var dc = new DataContainerRequest();
dc.IsDefault = false;
dc.Name = dataContainerName;
dc.BandwidthRate = 256;
dc.VolumeCount = 0;
dc.IsEncryptionEnabled = false;
dc.PrimaryStorageAccountCredential = existingSac;
//Create DataContainer call
var taskStatus = client.DataContainer.Create(actualdeviceId, dc, hdrs);
//Assert the job status
Assert.NotNull(taskStatus);
Assert.True(taskStatus.Status == AsyncTaskStatus.Completed);
Assert.True(taskStatus.Result == AsyncTaskResult.Succeeded);
//Get Data Container call
var Createddatacontainer = client.DataContainer.Get(actualdeviceId, dataContainerName, hdrs);
//Assert the returned data container object
Assert.True(Createddatacontainer != null);
Assert.True(Createddatacontainer.DataContainerInfo.Name.Equals(dataContainerName));
//ACR list for Virtual disk creation
List<AccessControlRecord> acrList = new List<AccessControlRecord>();
for (var i = 0; i < 1; i++)
{
AccessControlRecord acr = new AccessControlRecord()
{
Name = TestUtilities.GenerateName("VDnewTestAcr"),
InitiatorName = TestUtilities.GenerateName("VDinitiator") + i
};
acrList.Add(acr);
}
//Virtual disk create request object
var virtualDiskToCreate = new VirtualDiskRequest()
{
Name = TestUtilities.GenerateName("VD1Name"),
AccessType = AccessType.ReadWrite,
AcrList = acrList,
AppType = AppType.PrimaryVolume,
IsDefaultBackupEnabled = true,
SizeInBytes = 10737418240,
DataContainer = Createddatacontainer.DataContainerInfo,
Online = true
};
//Virtual disk create call
taskStatus = client.VirtualDisk.Create(actualdeviceId, virtualDiskToCreate, hdrs);
//Asserting the job status
Assert.NotNull(taskStatus);
Assert.True(taskStatus.Status == AsyncTaskStatus.Completed);
Assert.True(taskStatus.Result == AsyncTaskResult.Succeeded);
//Virtual disk get call
var createdVirtualDisk = client.VirtualDisk.GetByName(actualdeviceId, virtualDiskToCreate.Name, hdrs);
Assert.True(createdVirtualDisk != null);
Assert.True(createdVirtualDisk.VirtualDiskInfo.Name.Equals(virtualDiskToCreate.Name));
var volumeIds = new List<string>();
volumeIds.Add(createdVirtualDisk.VirtualDiskInfo.InstanceId);
var dailySchedule = new BackupScheduleBase();
dailySchedule.BackupType = BackupType.CloudSnapshot;
dailySchedule.Status = ScheduleStatus.Enabled;
dailySchedule.RetentionCount = 5;
dailySchedule.StartTime = DateTime.Now.ToString("yyyy-MM-ddTHH:mm:sszzz");
dailySchedule.Recurrence = new ScheduleRecurrence();
dailySchedule.Recurrence.RecurrenceType = RecurrenceType.Daily;
dailySchedule.Recurrence.RecurrenceValue = 5;
var backupPolicyToCreate = new NewBackupPolicyConfig();
backupPolicyToCreate.Name = TestUtilities.GenerateName("PolicyName");
backupPolicyToCreate.VolumeIds = volumeIds;
backupPolicyToCreate.BackupSchedules = new List<BackupScheduleBase>();
backupPolicyToCreate.BackupSchedules.Add(dailySchedule);
//BackupPolicy create call
taskStatus = client.BackupPolicy.Create(actualdeviceId, backupPolicyToCreate, hdrs);
//Asserting the job status
Assert.NotNull(taskStatus);
Assert.True(taskStatus.Status == AsyncTaskStatus.Completed);
Assert.True(taskStatus.Result == AsyncTaskResult.Succeeded);
//BackupPolicy list call
var allBackupPolicies = client.BackupPolicy.List(actualdeviceId, hdrs);
//Assert the returned BackupPolicy object
Assert.True(allBackupPolicies != null);
Assert.True(allBackupPolicies.Any());
//BackupPolicy get by name call
var createdBackupPolicy = client.BackupPolicy.GetBackupPolicyDetailsByName(actualdeviceId, backupPolicyToCreate.Name, hdrs);
//Assert the returned BackupPolicy object
Assert.True(createdBackupPolicy != null);
Assert.True(createdBackupPolicy.BackupPolicyDetails.Name.Equals(backupPolicyToCreate.Name));
BackupNowRequest backupNowRequest = new BackupNowRequest();
backupNowRequest.Type = BackupType.CloudSnapshot;
//BackupSets Create call
taskStatus = client.Backup.Create(actualdeviceId, createdBackupPolicy.BackupPolicyDetails.InstanceId, backupNowRequest, hdrs);
//Asserting the job status
Assert.NotNull(taskStatus);
Assert.True(taskStatus.Status == AsyncTaskStatus.Completed);
Assert.True(taskStatus.Result == AsyncTaskResult.Succeeded);
BackupScheduleBase hourlySchedule = new BackupScheduleBase();
hourlySchedule.BackupType = BackupType.LocalSnapshot;
hourlySchedule.Status = ScheduleStatus.Enabled;
hourlySchedule.RetentionCount = 10;
hourlySchedule.StartTime = DateTime.Now.ToString("yyyy-MM-ddTHH:mm:sszzz");
hourlySchedule.Recurrence = new ScheduleRecurrence();
hourlySchedule.Recurrence.RecurrenceType = RecurrenceType.Hourly;
hourlySchedule.Recurrence.RecurrenceValue = 12;
List<BackupScheduleBase> backupSchedulesToBeAdded = new List<BackupScheduleBase>();
backupSchedulesToBeAdded.Add(hourlySchedule);
var updatePolicyRequest = new UpdateBackupPolicyConfig();
updatePolicyRequest.InstanceId = createdBackupPolicy.BackupPolicyDetails.InstanceId;
updatePolicyRequest.Name = createdBackupPolicy.BackupPolicyDetails.Name;
updatePolicyRequest.BackupSchedulesToBeAdded = backupSchedulesToBeAdded;
updatePolicyRequest.BackupSchedulesToBeUpdated = new List<BackupScheduleUpdateRequest>();
updatePolicyRequest.BackupSchedulesToBeDeleted = new List<string>();
updatePolicyRequest.VolumeIds = volumeIds;
//Backup policy update call
taskStatus = client.BackupPolicy.Update(actualdeviceId, createdBackupPolicy.BackupPolicyDetails.InstanceId, updatePolicyRequest, hdrs);
//Asserting the job status
Assert.NotNull(taskStatus);
Assert.True(taskStatus.Status == AsyncTaskStatus.Completed);
Assert.True(taskStatus.Result == AsyncTaskResult.Succeeded);
GetBackupResponse backupSetResult;
do
{
//BackupSets Get call
backupSetResult = client.Backup.Get(actualdeviceId, "BackupPolicy", Boolean.TrueString, null, null, null, null, null, hdrs);
Assert.True(backupSetResult != null);
Assert.True(backupSetResult.BackupSetsList != null);
TestUtilities.Wait(1000);
} while (!backupSetResult.BackupSetsList.Any());
var backupSetId = backupSetResult.BackupSetsList.First().InstanceId;
var restoreBackupRequest = new RestoreBackupRequest()
{
BackupSetId = backupSetId,
SnapshotId = null
};
//Restore call
taskStatus = client.Backup.Restore(actualdeviceId, restoreBackupRequest, hdrs);
//Asserting the job status
Assert.NotNull(taskStatus);
Assert.True(taskStatus.Status == AsyncTaskStatus.Completed);
Assert.True(taskStatus.Result == AsyncTaskResult.Succeeded);
//BackupSets Delete call
taskStatus = client.Backup.Delete(actualdeviceId, backupSetId, hdrs);
//Asserting the job status
Assert.NotNull(taskStatus);
Assert.True(taskStatus.Status == AsyncTaskStatus.Completed);
Assert.True(taskStatus.Result == AsyncTaskResult.Succeeded);
TestUtilities.Wait(60*1000); //wait for 1min for the backup to be deleted
//Backup Policy delete call
taskStatus = client.BackupPolicy.Delete(actualdeviceId, createdBackupPolicy.BackupPolicyDetails.InstanceId, hdrs);
//Asserting the job status
Assert.NotNull(taskStatus);
Assert.True(taskStatus.Status == AsyncTaskStatus.Completed);
Assert.True(taskStatus.Result == AsyncTaskResult.Succeeded);
}
}
public void CanCreateDataContainerTest()
{
using (var context = UndoContext.Current)
{
context.Start();
var client = GetServiceClient<StorSimpleManagementClient>();
// Listing all Devices
var devices = client.Devices.List(GetCustomRequestHeaders());
// Asserting that atleast One Device is returned.
Assert.True(devices != null);
Assert.True(devices.Any());
var actualdeviceId = devices.FirstOrDefault().DeviceId;
actualdeviceId = actualdeviceId.Trim();
CustomRequestHeaders hdrs = new CustomRequestHeaders();
hdrs.ClientRequestId = Guid.NewGuid().ToString();
hdrs.Language = "en-us";
//Get service configuration
var serviceConfigList = client.ServiceConfig.Get(GetCustomRequestHeaders());
Assert.True(serviceConfigList != null);
var existingSac = serviceConfigList.CredentialChangeList.Updated.FirstOrDefault();
Assert.True(existingSac != null);
var dataContainerName = TestUtilities.GenerateName("DCName");
// new Data container request object
var dc = new DataContainerRequest();
dc.IsDefault = false;
dc.Name = dataContainerName;
dc.BandwidthRate = 256;
dc.VolumeCount = 0;
dc.IsEncryptionEnabled = false;
dc.PrimaryStorageAccountCredential = existingSac;
//Create DataContainer call
var taskStatus = client.DataContainer.Create(actualdeviceId, dc, hdrs);
//Assert the job status
Assert.NotNull(taskStatus);
Assert.True(taskStatus.Status == AsyncTaskStatus.Completed);
Assert.True(taskStatus.Result == AsyncTaskResult.Succeeded);
//Get Data Container call
var Createddatacontainer = client.DataContainer.Get(actualdeviceId, dataContainerName, hdrs);
//Assert the returned data container object
Assert.True(Createddatacontainer != null);
Assert.True(Createddatacontainer.DataContainerInfo.Name.Equals(dataContainerName));
//var dataContainerToUpdate = new DataContainerRequest();
//var sacToBeUsedForUpdate = Createddatacontainer.DataContainerInfo.PrimaryStorageAccountCredential;
//sacToBeUsedForUpdate.PasswordEncryptionCertThumbprint = "7DE2C6A43E7B6B35997EC1180CEE43EA2333CE93";
//dataContainerToUpdate.IsDefault = Createddatacontainer.DataContainerInfo.IsDefault;
//dataContainerToUpdate.InstanceId = Createddatacontainer.DataContainerInfo.InstanceId;
//dataContainerToUpdate.Name = Createddatacontainer.DataContainerInfo.Name;
//dataContainerToUpdate.BandwidthRate = Createddatacontainer.DataContainerInfo.BandwidthRate;
//dataContainerToUpdate.VolumeCount = Createddatacontainer.DataContainerInfo.VolumeCount;
//dataContainerToUpdate.IsEncryptionEnabled = Createddatacontainer.DataContainerInfo.IsEncryptionEnabled;
////dataContainerToUpdate.EncryptionKey = Createddatacontainer.DataContainerInfo.EncryptionKey;
//dataContainerToUpdate.PrimaryStorageAccountCredential = Createddatacontainer.DataContainerInfo.PrimaryStorageAccountCredential;
//dataContainerToUpdate.SecretsEncryptionThumbprint = "7DE2C6A43E7B6B35997EC1180CEE43EA2333CE93";
//dataContainerToUpdate.BandwidthRate = 512;
//jobStatus = client.DataContainer.Update(actualdeviceId, dataContainerToUpdate.InstanceId,
// dataContainerToUpdate, hdrs);
////Assert the job status
//Assert.NotNull(taskStatus);
//Assert.True(taskStatus.Status == AsyncTaskStatus.Completed);
//Assert.True(taskStatus.Result == AsyncTaskResult.Succeeded);
taskStatus = client.DataContainer.Delete(actualdeviceId, Createddatacontainer.DataContainerInfo.InstanceId, hdrs);
//Assert the job status
Assert.NotNull(taskStatus);
Assert.True(taskStatus.Status == AsyncTaskStatus.Completed);
Assert.True(taskStatus.Result == AsyncTaskResult.Succeeded);
}
}
/// <summary>
/// Clone a backup element.
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.StorSimple.ICloneVolumeOperations.
/// </param>
/// <param name='sourceDeviceId'>
/// Required. The identifier of the source device from which clone is
/// to be triggered
/// </param>
/// <param name='triggerCloneRequest'>
/// Required. The parameters required for clone operation
/// </param>
/// <param name='customRequestHeaders'>
/// Required. The Custom Request Headers which client must use
/// </param>
/// <returns>
/// This is the Job Response for all Device Job Related Calls
/// </returns>
public static Task<JobResponse> TriggerAsync(this ICloneVolumeOperations operations, string sourceDeviceId, TriggerCloneRequest triggerCloneRequest, CustomRequestHeaders customRequestHeaders)
{
return operations.TriggerAsync(sourceDeviceId, triggerCloneRequest, customRequestHeaders, CancellationToken.None);
}
public void CloneScenarioMultipleDeviceTest()
{
using (var context = UndoContext.Current)
{
context.Start();
var client = GetServiceClient<StorSimpleManagementClient>();
// Listing all Devices
var devices = client.Devices.List(GetCustomRequestHeaders());
// Asserting that atleast One Device is returned.
Assert.True(devices != null);
Assert.True(devices.Any());
var actualdeviceId = devices.FirstOrDefault().DeviceId;
actualdeviceId = actualdeviceId.Trim();
CustomRequestHeaders hdrs = new CustomRequestHeaders();
hdrs.ClientRequestId = Guid.NewGuid().ToString();
hdrs.Language = "en-us";
//Get service configuration
var serviceConfigList = client.ServiceConfig.Get(GetCustomRequestHeaders());
Assert.True(serviceConfigList != null);
var existingSac = serviceConfigList.CredentialChangeList.Updated.FirstOrDefault();
Assert.True(existingSac != null);
var dataContainerName = TestUtilities.GenerateName("DCName");
// new Data container request object
var dc = new DataContainerRequest();
dc.IsDefault = false;
dc.Name = dataContainerName;
dc.BandwidthRate = 256;
dc.VolumeCount = 0;
dc.IsEncryptionEnabled = false;
dc.PrimaryStorageAccountCredential = existingSac;
//Create DataContainer call
var taskStatus = client.DataContainer.Create(actualdeviceId, dc, hdrs);
//Assert the job status
Assert.NotNull(taskStatus);
Assert.True(taskStatus.Status == AsyncTaskStatus.Completed);
Assert.True(taskStatus.Result == AsyncTaskResult.Succeeded);
//Get Data Container call
var Createddatacontainer = client.DataContainer.Get(actualdeviceId, dataContainerName, hdrs);
//Assert the returned data container object
Assert.True(Createddatacontainer != null);
Assert.True(Createddatacontainer.DataContainerInfo.Name.Equals(dataContainerName));
//ACR list for Virtual disk creation
List<AccessControlRecord> acrList = new List<AccessControlRecord>();
for (var i = 0; i < 1; i++)
{
AccessControlRecord acr = new AccessControlRecord()
{
Name = TestUtilities.GenerateName("VDnewTestAcr"),
InitiatorName = TestUtilities.GenerateName("VDinitiator") + i
};
acrList.Add(acr);
}
//Virtual disk create request object
var virtualDiskToCreate = new VirtualDiskRequest()
{
Name = TestUtilities.GenerateName("VD1Name"),
AccessType = AccessType.ReadWrite,
AcrList = acrList,
AppType = AppType.PrimaryVolume,
IsDefaultBackupEnabled = true,
SizeInBytes = 10737418240,
DataContainer = Createddatacontainer.DataContainerInfo,
Online = true
};
//Virtual disk create call
taskStatus = client.VirtualDisk.Create(actualdeviceId, virtualDiskToCreate, hdrs);
//Asserting the job status
Assert.NotNull(taskStatus);
Assert.True(taskStatus.Status == AsyncTaskStatus.Completed);
Assert.True(taskStatus.Result == AsyncTaskResult.Succeeded);
//Virtual disk get call
var createdVirtualDisk = client.VirtualDisk.GetByName(actualdeviceId, virtualDiskToCreate.Name, hdrs);
Assert.True(createdVirtualDisk != null);
Assert.True(createdVirtualDisk.VirtualDiskInfo.Name.Equals(virtualDiskToCreate.Name));
var volumeIds = new List<string>();
volumeIds.Add(createdVirtualDisk.VirtualDiskInfo.InstanceId);
var dailySchedule = new BackupScheduleBase();
dailySchedule.BackupType = BackupType.CloudSnapshot;
dailySchedule.Status = ScheduleStatus.Enabled;
dailySchedule.RetentionCount = 5;
dailySchedule.StartTime = DateTime.Now.ToString("yyyy-MM-ddTHH:mm:sszzz");
dailySchedule.Recurrence = new ScheduleRecurrence();
dailySchedule.Recurrence.RecurrenceType = RecurrenceType.Daily;
dailySchedule.Recurrence.RecurrenceValue = 5;
var backupPolicyToCreate = new NewBackupPolicyConfig();
backupPolicyToCreate.Name = TestUtilities.GenerateName("PolicyName");
backupPolicyToCreate.VolumeIds = volumeIds;
backupPolicyToCreate.BackupSchedules = new List<BackupScheduleBase>();
backupPolicyToCreate.BackupSchedules.Add(dailySchedule);
//BackupPolicy create call
taskStatus = client.BackupPolicy.Create(actualdeviceId, backupPolicyToCreate, hdrs);
//Asserting the job status
Assert.NotNull(taskStatus);
Assert.True(taskStatus.Status == AsyncTaskStatus.Completed);
Assert.True(taskStatus.Result == AsyncTaskResult.Succeeded);
//BackupPolicy list call
var allBackupPolicies = client.BackupPolicy.List(actualdeviceId, hdrs);
//Assert the returned BackupPolicy object
Assert.True(allBackupPolicies != null);
Assert.True(allBackupPolicies.Any());
//BackupPolicy get by name call
var createdBackupPolicy = client.BackupPolicy.GetBackupPolicyDetailsByName(actualdeviceId, backupPolicyToCreate.Name, hdrs);
//Assert the returned BackupPolicy object
Assert.True(createdBackupPolicy != null);
Assert.True(createdBackupPolicy.BackupPolicyDetails.Name.Equals(backupPolicyToCreate.Name));
BackupNowRequest backupNowRequest = new BackupNowRequest();
backupNowRequest.Type = BackupType.CloudSnapshot;
//BackupSets Create call
taskStatus = client.Backup.Create(actualdeviceId, createdBackupPolicy.BackupPolicyDetails.InstanceId, backupNowRequest, hdrs);
//Asserting the job status
Assert.NotNull(taskStatus);
Assert.True(taskStatus.Status == AsyncTaskStatus.Completed);
Assert.True(taskStatus.Result == AsyncTaskResult.Succeeded);
GetBackupResponse backupSetResult;
do
{
//BackupSets Get call
backupSetResult = client.Backup.Get(actualdeviceId, "BackupPolicy", Boolean.TrueString, null, null, null, null, null, hdrs);
Assert.True(backupSetResult != null);
Assert.True(backupSetResult.BackupSetsList != null);
TestUtilities.Wait(1000);
} while (!backupSetResult.BackupSetsList.Any());
var backupSet = backupSetResult.BackupSetsList.First();
var clonedVolName = createdVirtualDisk.VirtualDiskInfo.Name + "_Cloned";
var secondDeviceId = devices.Devices[1].DeviceId;
var triggerCloneRequest = new TriggerCloneRequest()
{
BackupSetId = backupSet.InstanceId,
SourceSnapshot = backupSet.Snapshots.First(),
TargetVolName = clonedVolName,
TargetDeviceId = secondDeviceId,
ReturnWorkflowId = true,
TargetACRList = createdVirtualDisk.VirtualDiskInfo.AcrList
};
var jobResponse = client.CloneVolume.Trigger(actualdeviceId, triggerCloneRequest, hdrs);
//Asserting the job id.
Assert.NotNull(jobResponse);
Assert.True(jobResponse.JobId != Guid.Empty.ToString());
GetDeviceJobResponse deviceJobResponse;
do
{
//DeviceJob Get call
deviceJobResponse = client.DeviceJob.Get(secondDeviceId, null, null, jobResponse.JobId, null, null, 0, 10, hdrs);
TestUtilities.Wait(1000);
Assert.True(deviceJobResponse.DeviceJobList != null);
Assert.True(deviceJobResponse.DeviceJobList.Count == 1);
} while (deviceJobResponse.DeviceJobList.First().Status == "Running");
Assert.True(deviceJobResponse.DeviceJobList != null);
Assert.True(deviceJobResponse.DeviceJobList.First().Status.Equals("Completed", StringComparison.InvariantCultureIgnoreCase));
VirtualDiskGetResponse virtualDiskGetResponse = client.VirtualDisk.GetByName(secondDeviceId, clonedVolName, GetCustomRequestHeaders());
Assert.True(virtualDiskGetResponse != null);
Assert.True(virtualDiskGetResponse.VirtualDiskInfo != null);
Assert.True(virtualDiskGetResponse.VirtualDiskInfo.Name.Equals(clonedVolName, StringComparison.InvariantCultureIgnoreCase));
}
}
/// <summary>
/// The Begin Creating Volume operation creates a new volume.
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.StorSimple.IVirtualDiskOperations.
/// </param>
/// <param name='deviceId'>
/// Required. device id
/// </param>
/// <param name='diskDetails'>
/// Required. Parameters supplied to the Create virtual disk operation.
/// </param>
/// <param name='customRequestHeaders'>
/// Required. The Custom Request Headers which client must use.
/// </param>
/// <returns>
/// This is the Task Response for all Async Calls
/// </returns>
public static Task<GuidTaskResponse> BeginCreatingAsync(this IVirtualDiskOperations operations, string deviceId, VirtualDiskRequest diskDetails, CustomRequestHeaders customRequestHeaders)
{
return operations.BeginCreatingAsync(deviceId, diskDetails, customRequestHeaders, CancellationToken.None);
}
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.StorSimple.IDevicePublicKeyOperations.
/// </param>
/// <param name='deviceId'>
/// Required. The Device Id for which we need to Fetch the Device
/// Public Key
/// </param>
/// <param name='customRequestHeaders'>
/// Required. The Custom Request Headers which client must use.
/// </param>
/// <returns>
/// The response model for Device PublicKey.
/// </returns>
public static Task<GetDevicePublicKeyResponse> GetAsync(this IDevicePublicKeyOperations operations, string deviceId, CustomRequestHeaders customRequestHeaders)
{
return operations.GetAsync(deviceId, customRequestHeaders, CancellationToken.None);
}
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.StorSimple.IResourceEncryptionKeyOperations.
/// </param>
/// <param name='customRequestHeaders'>
/// Required. The Custom Request Headers which client must use.
/// </param>
/// <returns>
/// The response model for Resource Encryption Key.
/// </returns>
public static Task<GetResourceEncryptionKeyResponse> GetAsync(this IResourceEncryptionKeyOperations operations, CustomRequestHeaders customRequestHeaders)
{
return operations.GetAsync(customRequestHeaders, CancellationToken.None);
}
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.StorSimple.IVirtualDiskOperations.
/// </param>
/// <param name='deviceId'>
/// Required. device id
/// </param>
/// <param name='diskId'>
/// Required. disk id
/// </param>
/// <param name='customRequestHeaders'>
/// Required. The Custom Request Headers which client must use.
/// </param>
/// <returns>
/// Info about the async task
/// </returns>
public static TaskStatusInfo Delete(this IVirtualDiskOperations operations, string deviceId, string diskId, CustomRequestHeaders customRequestHeaders)
{
return Task.Factory.StartNew((object s) =>
{
return ((IVirtualDiskOperations)s).DeleteAsync(deviceId, diskId, customRequestHeaders);
}
, operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult();
}
/// <summary>
/// The Create Virtual Device
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.StorSimple.IVirtualDeviceOperations.
/// </param>
/// <param name='virtualDeviceProvisioningInfo'>
/// Required. The Virtual device provisioning info.
/// </param>
/// <param name='customRequestHeaders'>
/// Required. The Custom Request Headers which client must use.
/// </param>
/// <returns>
/// This is the Job Response for all Device Job Related Calls
/// </returns>
public static Task<JobResponse> CreateAsync(this IVirtualDeviceOperations operations, VirtualDeviceProvisioningInfo virtualDeviceProvisioningInfo, CustomRequestHeaders customRequestHeaders)
{
return operations.CreateAsync(virtualDeviceProvisioningInfo, customRequestHeaders, CancellationToken.None);
}
/// <summary>
/// In order to stop a job we need to first schedule a job that is going to run long
/// enough for it to be stopped.
/// </summary>
/// <param name="deviceInfo">Device details.</param>
private void CreateSupportingVolumeAndBackupPolicy(DeviceInfo deviceInfo)
{
var client = GetServiceClient<StorSimpleManagementClient>();
var actualdeviceId = deviceInfo.DeviceId;
actualdeviceId = actualdeviceId.Trim();
CustomRequestHeaders hdrs = new CustomRequestHeaders();
hdrs.ClientRequestId = Guid.NewGuid().ToString();
hdrs.Language = "en-us";
//Get service configuration
var serviceConfigList = client.ServiceConfig.Get(GetCustomRequestHeaders());
Assert.True(serviceConfigList != null);
var existingSac = serviceConfigList.CredentialChangeList.Updated.FirstOrDefault();
Assert.True(existingSac != null);
var dataContainerName = TestUtilities.GenerateName("DCName");
// new Data container request object
var dc = new DataContainerRequest();
dc.IsDefault = false;
dc.Name = dataContainerName;
dc.BandwidthRate = 256;
dc.VolumeCount = 0;
dc.IsEncryptionEnabled = false;
dc.PrimaryStorageAccountCredential = existingSac;
//Create DataContainer call
var taskStatus = client.DataContainer.Create(actualdeviceId, dc, hdrs);
//Assert the job status
Assert.NotNull(taskStatus);
Assert.True(taskStatus.Status == AsyncTaskStatus.Completed);
Assert.True(taskStatus.Result == AsyncTaskResult.Succeeded);
//Get Data Container call
var Createddatacontainer = client.DataContainer.Get(actualdeviceId, dataContainerName, hdrs);
//Assert the returned data container object
Assert.True(Createddatacontainer != null);
Assert.True(Createddatacontainer.DataContainerInfo.Name.Equals(dataContainerName));
//ACR list for Virtual disk creation
List<AccessControlRecord> acrList = new List<AccessControlRecord>();
for (var i = 0; i < 1; i++)
{
AccessControlRecord acr = new AccessControlRecord()
{
Name = TestUtilities.GenerateName("VDnewTestAcr"),
InitiatorName = TestUtilities.GenerateName("VDinitiator") + i
};
acrList.Add(acr);
}
//Virtual disk create request object
var virtualDiskToCreate = new VirtualDiskRequest()
{
Name = TestUtilities.GenerateName("VD1Name"),
AccessType = AccessType.ReadWrite,
AcrList = acrList,
AppType = AppType.PrimaryVolume,
IsDefaultBackupEnabled = true,
SizeInBytes = 107374182400,
DataContainer = Createddatacontainer.DataContainerInfo,
Online = true
};
//Virtual disk create call
taskStatus = client.VirtualDisk.Create(actualdeviceId, virtualDiskToCreate, hdrs);
//Asserting the job status
Assert.NotNull(taskStatus);
Assert.True(taskStatus.Status == AsyncTaskStatus.Completed);
Assert.True(taskStatus.Result == AsyncTaskResult.Succeeded);
//Virtual disk get call
var createdVirtualDisk = client.VirtualDisk.GetByName(actualdeviceId, virtualDiskToCreate.Name, hdrs);
Assert.True(createdVirtualDisk != null);
Assert.True(createdVirtualDisk.VirtualDiskInfo.Name.Equals(virtualDiskToCreate.Name));
var volumeIds = new List<string>();
volumeIds.Add(createdVirtualDisk.VirtualDiskInfo.InstanceId);
var dailySchedule = new BackupScheduleBase();
dailySchedule.BackupType = BackupType.CloudSnapshot;
dailySchedule.Status = ScheduleStatus.Enabled;
dailySchedule.RetentionCount = 5;
dailySchedule.StartTime = DateTime.Now.ToString("yyyy-MM-ddTHH:mm:sszzz");
dailySchedule.Recurrence = new ScheduleRecurrence();
dailySchedule.Recurrence.RecurrenceType = RecurrenceType.Daily;
dailySchedule.Recurrence.RecurrenceValue = 5;
var backupPolicyToCreate = new NewBackupPolicyConfig();
backupPolicyToCreate.Name = TestUtilities.GenerateName("PolicyName");
backupPolicyToCreate.VolumeIds = volumeIds;
backupPolicyToCreate.BackupSchedules = new List<BackupScheduleBase>();
backupPolicyToCreate.BackupSchedules.Add(dailySchedule);
//BackupPolicy create call
taskStatus = client.BackupPolicy.Create(actualdeviceId, backupPolicyToCreate, hdrs);
//Asserting the job status
Assert.NotNull(taskStatus);
Assert.True(taskStatus.Status == AsyncTaskStatus.Completed);
Assert.True(taskStatus.Result == AsyncTaskResult.Succeeded);
//BackupPolicy list call
var allBackupPolicies = client.BackupPolicy.List(actualdeviceId, hdrs);
//Assert the returned BackupPolicy object
Assert.True(allBackupPolicies != null);
Assert.True(allBackupPolicies.Any());
}
public void DeviceRestoreScenarioTest()
{
using (var context = UndoContext.Current)
{
context.Start();
var client = GetServiceClient<StorSimpleManagementClient>();
// Listing all Devices
var devices = client.Devices.List(GetCustomRequestHeaders());
var onlineDeviceIds = from deviceInfo in devices.Devices
where deviceInfo.Status == DeviceStatus.Online
select deviceInfo.DeviceId;
Assert.True(onlineDeviceIds.Count() >= 2);
var sourceDeviceId = onlineDeviceIds.ElementAt(0);
var targetDeviceId = onlineDeviceIds.ElementAt(1);
CustomRequestHeaders hdrs = new CustomRequestHeaders();
hdrs.ClientRequestId = Guid.NewGuid().ToString();
hdrs.Language = "en-us";
//Get service configuration
var serviceConfigList = client.ServiceConfig.Get(GetCustomRequestHeaders());
Assert.True(serviceConfigList != null);
var existingSac = serviceConfigList.CredentialChangeList.Updated.FirstOrDefault();
Assert.True(existingSac != null);
var dataContainerName = TestUtilities.GenerateName("DCName");
// new Data container request object
var dc = new DataContainerRequest();
dc.IsDefault = false;
dc.Name = dataContainerName;
dc.BandwidthRate = 256;
dc.VolumeCount = 0;
dc.IsEncryptionEnabled = false;
dc.PrimaryStorageAccountCredential = existingSac;
//Create DataContainer call
var taskStatus = client.DataContainer.Create(sourceDeviceId, dc, hdrs);
//Assert the task status
Assert.NotNull(taskStatus);
Assert.True(taskStatus.Status == AsyncTaskStatus.Completed);
Assert.True(taskStatus.Result == AsyncTaskResult.Succeeded);
//Get Data Container call
var Createddatacontainer = client.DataContainer.Get(sourceDeviceId, dataContainerName, hdrs);
//Assert the returned data container object
Assert.True(Createddatacontainer != null);
Assert.True(Createddatacontainer.DataContainerInfo.Name.Equals(dataContainerName));
//ACR list for Virtual disk creation
List<AccessControlRecord> acrList = new List<AccessControlRecord>();
for (var i = 0; i < 1; i++)
{
AccessControlRecord acr = new AccessControlRecord()
{
Name = TestUtilities.GenerateName("VDnewTestAcr"),
InitiatorName = TestUtilities.GenerateName("VDinitiator") + i
};
acrList.Add(acr);
}
//Virtual disk create request object
var virtualDiskToCreate = new VirtualDiskRequest()
{
Name = TestUtilities.GenerateName("VD1Name"),
AccessType = AccessType.ReadWrite,
AcrList = acrList,
AppType = AppType.PrimaryVolume,
IsDefaultBackupEnabled = true,
SizeInBytes = 10737418240,
DataContainer = Createddatacontainer.DataContainerInfo,
Online = true
};
//Virtual disk create call
taskStatus = client.VirtualDisk.Create(sourceDeviceId, virtualDiskToCreate, hdrs);
//Asserting the task status
Assert.NotNull(taskStatus);
Assert.True(taskStatus.Status == AsyncTaskStatus.Completed);
Assert.True(taskStatus.Result == AsyncTaskResult.Succeeded);
//Virtual disk get call
var createdVirtualDisk = client.VirtualDisk.GetByName(sourceDeviceId, virtualDiskToCreate.Name, hdrs);
Assert.True(createdVirtualDisk != null);
Assert.True(createdVirtualDisk.VirtualDiskInfo.Name.Equals(virtualDiskToCreate.Name));
var volumeIds = new List<string>();
volumeIds.Add(createdVirtualDisk.VirtualDiskInfo.InstanceId);
var dailySchedule = new BackupScheduleBase();
dailySchedule.BackupType = BackupType.CloudSnapshot;
dailySchedule.Status = ScheduleStatus.Enabled;
dailySchedule.RetentionCount = 5;
dailySchedule.StartTime = DateTime.Now.ToString("yyyy-MM-ddTHH:mm:sszzz");
dailySchedule.Recurrence = new ScheduleRecurrence();
dailySchedule.Recurrence.RecurrenceType = RecurrenceType.Daily;
dailySchedule.Recurrence.RecurrenceValue = 5;
var backupPolicyToCreate = new NewBackupPolicyConfig();
backupPolicyToCreate.Name = TestUtilities.GenerateName("PolicyName");
backupPolicyToCreate.VolumeIds = volumeIds;
backupPolicyToCreate.BackupSchedules = new List<BackupScheduleBase>();
backupPolicyToCreate.BackupSchedules.Add(dailySchedule);
//BackupPolicy create call
taskStatus = client.BackupPolicy.Create(sourceDeviceId, backupPolicyToCreate, hdrs);
//Asserting the task status
Assert.NotNull(taskStatus);
Assert.True(taskStatus.Status == AsyncTaskStatus.Completed);
Assert.True(taskStatus.Result == AsyncTaskResult.Succeeded);
//BackupPolicy get by name call
var createdBackupPolicy = client.BackupPolicy.GetBackupPolicyDetailsByName(sourceDeviceId, backupPolicyToCreate.Name, hdrs);
//Assert the returned BackupPolicy object
Assert.True(createdBackupPolicy != null);
Assert.True(createdBackupPolicy.BackupPolicyDetails.Name.Equals(backupPolicyToCreate.Name));
BackupNowRequest backupNowRequest = new BackupNowRequest();
backupNowRequest.Type = BackupType.CloudSnapshot;
//BackupSets Create call
taskStatus = client.Backup.Create(sourceDeviceId, createdBackupPolicy.BackupPolicyDetails.InstanceId, backupNowRequest, hdrs);
//Asserting the task status
Assert.NotNull(taskStatus);
Assert.True(taskStatus.Status == AsyncTaskStatus.Completed);
Assert.True(taskStatus.Result == AsyncTaskResult.Succeeded);
GetBackupResponse backupSetResult;
do
{
//BackupSets Get call
backupSetResult = client.Backup.Get(sourceDeviceId, "BackupPolicy", Boolean.FalseString, createdBackupPolicy.BackupPolicyDetails.InstanceId, null, null, null, null, hdrs);
TestUtilities.Wait(1000);
} while (!backupSetResult.BackupSetsList.Any());
var dcGroupsGetResponse = client.DeviceFailover.ListDCGroups(sourceDeviceId, hdrs);
var dcIdList = from drDc in dcGroupsGetResponse.DataContainerGroupResponse.DCGroups[0].DCGroup
select drDc.InstanceId;
var drRequest = new DeviceFailoverRequest();
drRequest.CleanupPrimary = false;
drRequest.DataContainerIds = dcIdList.ToList();
drRequest.ReturnWorkflowId = true;
drRequest.TargetDeviceId = targetDeviceId;
//trigger failover call
var jobResponse = client.DeviceFailover.Trigger(sourceDeviceId, drRequest, hdrs);
//Asserting the task status
Assert.NotNull(jobResponse);
//track device job for its completion
var deviceJobResponse = new GetDeviceJobResponse();
int retryLimit = 30;
int pollInterval = 60 * 1000;
int retryCount = 0;
bool found = false;
do
{
TestUtilities.Wait(pollInterval);
deviceJobResponse = client.DeviceJob.Get(null, null, null, jobResponse.JobId, null, null, 0, 1, hdrs);
if(deviceJobResponse != null)
{
found = true;
}
retryCount++;
} while ((!found || deviceJobResponse.DeviceJobList[0].Status == "Running") && (retryCount < retryLimit));
Assert.NotNull(deviceJobResponse);
Assert.Equal(deviceJobResponse.DeviceJobList[0].Status, "Completed");
}
}
/// <param name='operations'>
/// Reference to the
/// Microsoft.WindowsAzure.Management.StorSimple.IIscsiConnectionDetailsOperations.
/// </param>
/// <param name='deviceId'>
/// Required. The device id for which the call will be made.
/// </param>
/// <param name='customRequestHeaders'>
/// Required. The Custom Request Headers which client can use.
/// </param>
/// <returns>
/// The response model for the list of iscsi connection details.
/// </returns>
public static Task<IscsiConnectionResponse> GetAsync(this IIscsiConnectionDetailsOperations operations, string deviceId, CustomRequestHeaders customRequestHeaders)
{
return operations.GetAsync(deviceId, customRequestHeaders, CancellationToken.None);
}
