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