public ICustomActivityResult Execute()
{
var creds = new ZapiCredentials()
{
ip = IP,
username = Username,
password = Password
};
var request = new CreateVolumeRequest
{
volumeName = Volume,
vserver = Vserver,
sizeMb = long.Parse(SizeMb),
volumeType = VolumeType,
aggregate = Aggregate,
exportPolicy = ExportPolicy
};
var c = new ConcreteCmodeClient();
var ret = c.createVolume(creds, request);
return(this.GenerateActivityResult("Success"));
}
/// <summary>
/// Create a volume
/// </summary>
/// <param name="createVolumeRequest">Parameters for create</param>
/// <param name="userId">User id</param>
/// <exception cref="VolumeException">If cannot create a volume</exception>
/// <returns>gRPC reply with volume id</returns>
public async Task <VolumeReply> Create(CreateVolumeRequest createVolumeRequest, string userId)
{
logger.LogInformation("Requested for creaton of a volume"); // english
string volumeId = IdentityFabric.GenVolumeId();
VolumeModel volume = VolumeAdapter.Volume(volumeId, createVolumeRequest);
logger.LogInformation($"Created the VolumeModel with Id {volumeId}");
using IConnectionMultiplexer redis = redisService.Connect();
IDatabase db = redis.GetDatabase();
logger.LogInformation($"Connected to the Redis servier");
ITransaction transaction = db.CreateTransaction();
logger.LogInformation($"Bigin transaction");
string redisKey = GetVolumeKey(userId, volumeId);
foreach (PropertyInfo propInfo in volume.GetType().GetProperties())
{
_ = transaction.HashSetAsync(redisKey, propInfo.Name, propInfo.GetValue(volume).ToString());
}
if (await transaction.ExecuteAsync() == false)
{
logger.LogError("Cannot create a volume. Transaction failed");
throw new VolumeException("Cannot create a volume");
}
logger.LogInformation($"Creansaction completed successfully");
return(VolumeAdapter.Volume(volume));
}
public static VolumeModel Volume(string id, CreateVolumeRequest createVolumeRequest)
{
return(new VolumeModel(
id,
createVolumeRequest.SizeGb,
string.Join(SEPARATOR, createVolumeRequest.MountPints),
createVolumeRequest.Name
));
}
/// <summary>
/// 创建云硬盘
/// </summary>
public CreateVolumeResponse CreateVolume(CreateVolumeRequest createVolumeRequest)
{
Dictionary <string, string> urlParam = new Dictionary <string, string>();
string urlPath = HttpUtils.AddUrlPath("/v2.1/{project_id}/cloudvolumes", urlParam);
SdkRequest request = HttpUtils.InitSdkRequest(urlPath, "application/json;charset=UTF-8", createVolumeRequest);
HttpResponseMessage response = DoHttpRequestSync("POST", request);
return(JsonUtils.DeSerialize <CreateVolumeResponse>(response));
}
public override async Task <CreateVolumeResponse> CreateVolume(
CreateVolumeRequest request,
ServerCallContext context)
{
CreateVolumeResponse response = new CreateVolumeResponse();
if (string.IsNullOrEmpty(request.Name))
{
logger.LogDebug("Validation fail");
throw new RpcException(new Status(StatusCode.InvalidArgument, "Name cannot be empty"));
}
using (var _s = logger.StepInformation("{0}, name: {1}", nameof(CreateVolume), request.Name))
{
try
{
var ctx = new DataProviderContext <ManagedDiskConfig>();
await contextConfig.Provide(ctx);
var actx = new AzureAuthConfigProviderContext {
Secrets = request.ControllerCreateSecrets
};
var provisionService = provisionServiceFactory.Create(
provider.Provide(actx),
ctx.Result.SubscriptionId);
var sizeGiB = byteUnitConverter.ToGibibyte(
request.CapacityRange == null
? 1
: request.CapacityRange.RequiredBytes);
var md = await provisionService.CreateAsync(
ctx.Result.SubscriptionId,
ctx.Result.ResourceGroupName,
request.Name,
ctx.Result.Location,
sizeGiB);
response.Volume = new Volume
{
Id = md.Id.Id,
CapacityBytes = byteUnitConverter.FromGigibyte(md.Size),
};
}
catch (Exception ex)
{
logger.LogError(ex, "Exception in CreateAsync");
throw new RpcException(new Status(StatusCode.Internal, ex.Message));
}
_s.Commit();
}
return(response);
}
/// <summary>
/// Creates a new volume
/// </summary>
/// <param name="avilabilityZone">The Availability zone to create the volume in</param>
/// <param name="size"></param>
/// <returns>Returns the VolumeId of the newly created volume</returns>
public string CreateNewVolume(string availabilityZone, string size)
{
var request = new CreateVolumeRequest {
AvailabilityZone = availabilityZone, Size = size
};
CreateVolumeResponse response = Client.CreateVolume(request);
return(response.CreateVolumeResult.Volume.VolumeId);
}
/// <summary>
/// Create a volume from a snapshot
/// </summary>
/// <param name="avilabilityZone">The Availability zone to create the volume in</param>
/// <param name="snapshotId">The SnapShot to create the volume from</param>
/// <returns>Returns the VolumeId of the newly created volume</returns>
public string CreateVolumeFromSnapshot(string avilabilityZone, string snapshotId)
{
CreateVolumeRequest request = new CreateVolumeRequest();
request.AvailabilityZone = avilabilityZone;
request.SnapshotId = snapshotId;
CreateVolumeResponse response = Client.CreateVolume(request);
return(response.CreateVolumeResult.Volume.VolumeId);
}
public async Task Attach()
{
var channel = TestHelper.CreateChannel();
var controller = new Controller.ControllerClient(channel);
var request = new CreateVolumeRequest
{
Name = namingProvider.VolumeName(),
};
populateSecretsFromEnv(request.ControllerCreateSecrets);
var response = await controller.CreateVolumeAsync(request, null);
Assert.NotNull(response.Volume);
Assert.NotNull(response.Volume.Id);
var volId = response.Volume.Id;
var node = new Node.NodeClient(TestHelper.CreateChannel());
var tmppath = Path.Combine(Path.GetTempPath(), namingProvider.DirName());
try
{
var npr = new NodePublishVolumeRequest
{
VolumeId = volId,
TargetPath = tmppath,
};
populateSecretsFromEnv(npr.NodePublishSecrets);
await node.NodePublishVolumeAsync(npr, null);
var tmpfile = Path.Combine(tmppath, namingProvider.FileName());
var content = DateTimeOffset.UtcNow.ToString();
await File.AppendAllTextAsync(tmpfile, content);
// TODO valid content through storage API, and enable DeleteVolumeAsync
}
finally
{
await node.NodeUnpublishVolumeAsync(new NodeUnpublishVolumeRequest
{
VolumeId = volId,
TargetPath = tmppath,
}, null);
/*
* await controller.DeleteVolumeAsync(new DeleteVolumeRequest
* {
* VolumeId = volId,
* });
*/
}
}
public async Task TestCreateVolumeWhenTransactionFailed()
{
Mock <ITransaction> transactionMock = new Mock <ITransaction>();
transactionMock.Setup(d => d.ExecuteAsync(CommandFlags.None)).Returns(Task.FromResult(false));
databaseMock.Setup(d => d.CreateTransaction(null)).Returns(transactionMock.Object);
CreateVolumeRequest createVolumeRequest = new CreateVolumeRequest()
{
Name = "TestVolumeName",
OsType = "Windows",
SizeGb = 3
};
createVolumeRequest.MountPints.Add("c:");
var voluem = await volumeDataSource.Create(createVolumeRequest, "userId");
Assert.IsFalse(true, "This method must throw an exception, when a transaction fails");
}
/// <summary>
/// Create a volume from the bind model
/// </summary>
/// <param name="bindModel">Bind volume with volume's properties</param>
/// <returns></returns>
public async Task <VolumeReply> CreateVolume(VolumeConfigurationBindModel bindModel)
{
return(await grpcCallerService.CallService(urls.Volumes, async channel =>
{
var client = new Volume.VolumeClient(channel);
logger.LogDebug("grpc client created, request = {@id}", "");
CreateVolumeRequest volumeRequest = new CreateVolumeRequest()
{
Name = bindModel.Name,
SizeGb = bindModel.SizeGb,
OsType = bindModel.OsType
};
volumeRequest.MountPints.AddRange(bindModel.MountPoints);
var response = await client.CreateAsync(volumeRequest);
logger.LogDebug("grpc response {@response}", response);
return response;
}));
}
protected override void ProcessRecord()
{
base.ProcessRecord();
CreateVolumeRequest request;
try
{
request = new CreateVolumeRequest
{
CreateVolumeDetails = CreateVolumeDetails,
OpcRetryToken = OpcRetryToken
};
response = client.CreateVolume(request).GetAwaiter().GetResult();
WriteOutput(response, response.Volume);
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
private static void CreateVolume(EvsClient client)
{
CreateVolumeRequest req = new CreateVolumeRequest()
{
Body = new CreateVolumeRequestBody
{
Volume = new CreateVolumeOption()
{
AvailabilityZone = "br-iaas-odin1a",
Count = 1,
Size = 40,
VolumeType = "SATA",
Description = "csharp",
Name = "test"
}
}
};
try
{
CreateVolumeResponse resp = client.CreateVolume(req);
Console.WriteLine(resp.JobId);
Console.WriteLine(resp.HttpStatusCode);
}
catch (RequestTimeoutException requestTimeoutException)
{
Console.WriteLine(requestTimeoutException.ErrorMessage);
}
catch (ServiceResponseException clientRequestException)
{
Console.WriteLine(clientRequestException.HttpStatusCode);
Console.WriteLine(clientRequestException.ErrorCode);
Console.WriteLine(clientRequestException.ErrorMsg);
}
catch (ConnectionException connectionException)
{
Console.WriteLine(connectionException.ErrorMessage);
}
}
public override async Task <CreateVolumeResponse> CreateVolume(
CreateVolumeRequest request,
ServerCallContext context)
{
CreateVolumeResponse response = new CreateVolumeResponse();
if (string.IsNullOrEmpty(request.Name))
{
logger.LogDebug("Validation fail");
throw new RpcException(new Status(StatusCode.InvalidArgument, "Name cannot be empty"));
}
using (var _s = logger.StepInformation("{0}, name: {1}", nameof(CreateVolume), request.Name))
{
try
{
response.Volume = await azureFileCsiService.CreateVolumeAsync(
request.Name,
request.ControllerCreateSecrets,
request.CapacityRange);
}
catch (StorageException ex)
{
logger.LogWarning(ex, "Error from storage service");
_s.Commit();
throw new RpcException(new Status(StatusCode.InvalidArgument, ex.Message));
}
catch (Exception ex)
{
logger.LogError(ex, "Exception in CreateVolume");
throw new RpcException(new Status(StatusCode.Internal, ex.Message));
}
_s.Commit();
}
return(response);
}
public async Task TestCreateVolume()
{
Mock <ITransaction> transactionMock = new Mock <ITransaction>();
transactionMock.Setup(d => d.ExecuteAsync(CommandFlags.None)).Returns(Task.FromResult(true));
databaseMock.Setup(d => d.CreateTransaction(null)).Returns(transactionMock.Object);
CreateVolumeRequest createVolumeRequest = new CreateVolumeRequest()
{
Name = "TestVolumeName",
OsType = "Windows",
SizeGb = 3
};
createVolumeRequest.MountPints.Add("c:");
var voluem = await volumeDataSource.Create(createVolumeRequest, "userId");
Assert.IsTrue(voluem.Id.Contains("vol"));
Assert.IsTrue(voluem.SizeGb == createVolumeRequest.SizeGb);
Assert.IsTrue(voluem.Name == createVolumeRequest.Name);
}
internal void TriggerBadApiCallException()
{
try
{
_logWriter("Test API call with wrong parameters");
CreateVolumeRequest request = new CreateVolumeRequest()
{
Size = 16,
Name = "test",
};
request.Parameters[nameof(request.DiskOfferingId)] = "diskOfferingFoo";
request.Parameters[nameof(request.ZoneId)] = "zonefoo";
_client.CreateVolume(request);
System.Diagnostics.Debug.Fail("Test should have triggered CloudStackException");
}
catch (CloudStackException cex)
{
_logWriter(cex.Message);
_logWriter("Test PASSED");
}
}
internal void TriggerBadApiCallException()
{
try
{
_logWriter("Test API call with wrong parameters");
CreateVolumeRequest request = new CreateVolumeRequest()
{
Size = 16,
Name = "test",
};
request.Parameters[nameof(request.DiskOfferingId)] = "diskOfferingFoo";
request.Parameters[nameof(request.ZoneId)] = "zonefoo";
_client.CreateVolume(request);
System.Diagnostics.Debug.Fail("Test should have triggered CloudStackException");
}
catch (CloudStackException cex)
{
_logWriter(cex.Message);
_logWriter("Test PASSED");
}
}
internal Guid CreateVolume()
{
Guid jobid = Guid.Empty;
try
{
ListDiskOfferingsRequest request = new ListDiskOfferingsRequest();
var doffers = _client.ListDiskOfferings(request);
DiskOfferingResponse customOffering = null;
foreach (var offer in doffers.Results)
{
if (offer.Iscustomized)
{
customOffering = offer;
break;
}
}
System.Diagnostics.Debug.Assert(customOffering != null, "There should be at least one custom disk offering defined");
CreateVolumeRequest req = new CreateVolumeRequest()
{
DiskOfferingId = Guid.Parse(customOffering.Id),
Size = 16,
Name = "testVolume",
ZoneId = Guid.Parse(_zoneId)
};
var response = _client.CreateVolume(req);
jobid = response.jobid;
_logWriter(response.ToString());
}
catch (System.Exception ex)
{
System.Diagnostics.Debug.Fail("Not supposed to throw during create volume");
this._logWriter(ex.Message);
}
return(jobid);
}
public override async Task <CreateVolumeResponse> CreateVolume(CreateVolumeRequest request, ServerCallContext context)
{
var name = request.Name;
var storage = string.Empty;
var sizeBytes = 10 * 1024 * 1024UL; //10GB
var shared = false; //todo VHDSet's
if (request.CapacityRange != null)
{
var requestSize = request.CapacityRange.RequiredBytes;
if (requestSize == 0)
{
requestSize = request.CapacityRange.LimitBytes;
}
if (requestSize > 0)
{
sizeBytes = (ulong)requestSize;
}
//maybe test existed volume for limit
}
foreach (var entry in request.Parameters)
{
switch (entry.Key.ToUpper())
{
case "STORAGE":
storage = entry.Value;
break;
default:
//unknown parameter
break;
}
}
foreach (var entry in request.Secrets)
{
switch (entry.Key)
{
default:
//unknown secret
break;
}
}
foreach (var entry in request.VolumeCapabilities)
{
switch (entry.AccessMode.Mode)
{
case VolumneAccessMode.SingleNodeWriter:
shared = false;
break;
default:
throw new RpcException(new Status(StatusCode.InvalidArgument, string.Empty),
"not supported volume access mode");
}
switch (entry.AccessTypeCase)
{
case VolumeCapability.AccessTypeOneofCase.Mount:
//throw new RpcException(new Status(StatusCode.InvalidArgument, string.Empty),
// "not supported volume access type");
//maybe SMB3 FileServer support
//entry.Mount.MountFlags;
//entry.Mount.FsType;
break;
case VolumeCapability.AccessTypeOneofCase.Block:
break;
//case VolumeCapability.AccessTypeOneofCase.None:
default:
throw new RpcException(new Status(StatusCode.InvalidArgument, string.Empty),
"unknown volume access type");
}
}
//todo request.AccessibilityRequirements
//todo request.VolumeContentSource
var foundVolumes = await _service.GetVolumesAsync(new HypervVolumeFilter { Name = name }).ToListAsync(context.CancellationToken);
if (foundVolumes.Count > 1)
{
throw new RpcException(new Status(StatusCode.AlreadyExists, string.Empty), "volume name ambiguous");
}
HypervVolumeDetail volume;
if (foundVolumes.Count == 1)
{
var foundVolume = foundVolumes[0];
if (!string.IsNullOrEmpty(storage) && !StringComparer.OrdinalIgnoreCase.Equals(storage, foundVolume.Storage))
{
throw new RpcException(new Status(StatusCode.AlreadyExists, string.Empty), "volume storage mismatch");
}
if (shared != foundVolume.Shared)
{
throw new RpcException(new Status(StatusCode.AlreadyExists, string.Empty), "volume share mode mismatch");
}
volume = await _service.GetVolumeAsync(foundVolume.Path, context.CancellationToken);
}
else
{
volume = await _service.CreateVolumeAsync(new HypervCreateVolumeRequest
{
Name = name,
Storage = storage,
SizeBytes = sizeBytes,
Shared = shared
},
context.CancellationToken);
}
if (request.CapacityRange != null)
{
if (request.CapacityRange.RequiredBytes > 0 && volume.SizeBytes < (ulong)request.CapacityRange.RequiredBytes)
{
throw new RpcException(new Status(StatusCode.AlreadyExists, string.Empty), "volume too small");
}
if (request.CapacityRange.LimitBytes > 0 && (ulong)request.CapacityRange.LimitBytes < volume.SizeBytes)
{
throw new RpcException(new Status(StatusCode.AlreadyExists, string.Empty), "volume too large");
}
}
var rsp = new CreateVolumeResponse
{
Volume = new Volume
{
VolumeId = volume.Name,
CapacityBytes = (long)volume.SizeBytes
}
};
rsp.Volume.VolumeContext.Add("Id", volume.Id.ToString());
rsp.Volume.VolumeContext.Add("Storage", volume.Storage);
rsp.Volume.VolumeContext.Add("Path", volume.Path);
//maybe add path
//todo rsp.Volume.AccessibleTopology
//todo rsp.Volume.ContentSource
return(rsp);
}
/// <summary>
/// Create Volume
/// </summary>
/// <param name="request">Create Volume request</param>
/// <returns>Create Volume Response from the service</returns>
/// <remarks>
/// Initializes an empty volume of a given size
///
/// </remarks>
public CreateVolumeResponse CreateVolume(CreateVolumeRequest request)
{
return(Invoke <CreateVolumeResponse>("CreateVolumeResponse.xml"));
}
/// <param name="snapshotId">If null, create from scratch</param>
private async Task <string> CreateVolumeAsync(string snapshotId = null, int?size = null, CancellationToken?cancellationToken = null)
{
CancellationToken token = cancellationToken.HasValue ? cancellationToken.Value : new CancellationToken();
if (string.IsNullOrEmpty(snapshotId))
{
this.Logger.Log("Starting device mount process, with a new volume");
}
else
{
this.Logger.Log("Starting device mount process. Snapshot ID: {0}", snapshotId);
}
var request = new CreateVolumeRequest()
{
SnapshotId = string.IsNullOrEmpty(snapshotId) ? null : snapshotId, // Null is the default value here
VolumeType = "standard",
AvailabilityZone = this.Instance.Specification.AvailabilityZone,
};
if (size != null)
{
request.Size = size.Value;
}
var createVolumeResponse = await this.Client.CreateVolumeAsync(request);
var volumeId = createVolumeResponse.Volume.VolumeId;
this.Logger.Log("Volume ID {0} created", volumeId);
this.Logger.Log("Tagging volume, so we know we can remove it later");
var name = this.Name == null ? "Unnamed" : this.Instance.Name + " - " + this.Name;
var tags = new List <Tag>()
{
new Tag()
{
Key = "CreatedByEc2Manager", Value = "true"
},
new Tag()
{
Key = "Name", Value = name
},
new Tag()
{
Key = "VolumeName", Value = this.Name
},
};
await this.Client.CreateTagsAsync(new CreateTagsRequest()
{
Resources = new List <string>()
{
volumeId
},
Tags = tags,
});
this.Logger.Log("Waiting for volume to reach the 'available' state");
await this.UntilVolumeStateAsync(volumeId, "available", token);
return(volumeId);
}
internal Guid CreateVolume()
{
Guid jobid = Guid.Empty;
try
{
ListDiskOfferingsRequest request = new ListDiskOfferingsRequest();
var doffers = _client.ListDiskOfferings(request);
DiskOfferingResponse customOffering = null;
foreach (var offer in doffers.Results)
{
if (offer.Iscustomized)
{
customOffering = offer;
break;
}
}
System.Diagnostics.Debug.Assert(customOffering != null, "There should be at least one custom disk offering defined");
CreateVolumeRequest req = new CreateVolumeRequest()
{
DiskOfferingId = Guid.Parse(customOffering.Id),
Size = 16,
Name = "testVolume",
ZoneId = Guid.Parse(_zoneId)
};
var response = _client.CreateVolume(req);
jobid = response.jobid;
_logWriter(response.ToString());
}
catch (System.Exception ex)
{
System.Diagnostics.Debug.Fail("Not supposed to throw during create volume");
this._logWriter(ex.Message);
}
return jobid;
}
internal string CreateVolume()
{
var session = new Client(serviceUri, apiKey, secretKey);
string volId = string.Empty;
try
{
ListDiskOfferingsRequest request = new ListDiskOfferingsRequest();
ListDiskOfferingsResponse doffers = session.ListDiskOfferings(request);
DiskOffering customOffering = null;
foreach (var offer in doffers.DiskOffering)
{
if (offer.IsCustomized)
{
customOffering = offer;
break;
}
}
System.Diagnostics.Debug.Assert(customOffering != null, "There should be at least one custom disk offering defined");
CreateVolumeRequest req = new CreateVolumeRequest()
{
DiskOfferingId = customOffering.Id,
Size = 16,
Name = "testVolume",
ZoneId = zoneId
};
volId = session.CreateVolume(req);
logWriter("Created volume id is " + volId);
}
catch (System.Exception ex)
{
System.Diagnostics.Debug.Fail("Not supposed to throw during create volume");
this.logWriter(ex.Message);
}
return volId;
}
/// <summary>
/// Creates a volume
/// </summary>
/// <param name="request">Volume request</param>
/// <param name="context">Context</param>
/// <returns></returns>
public override async Task <VolumeReply> Create(CreateVolumeRequest request, ServerCallContext context)
{
string userId = identityService.GetUserIdentity();
return(await volumeDataSource.Create(request, userId));
}
internal void TriggerBadApiCallException()
{
try
{
logWriter("Test API call with wrong parameters");
Client session = new CloudStack.SDK.Client(this.serviceUri, this.apiKey, this.secretKey);
CreateVolumeRequest request = new CreateVolumeRequest()
{
DiskOfferingId = "diskOfferingFoo",
Size = 16,
Name = "test",
ZoneId = "zonefoo"
};
session.CreateVolume(request);
System.Diagnostics.Debug.Fail("Test should have triggered CloudStackException");
}
catch (CloudStackException cex)
{
logWriter(cex.Message);
logWriter("Test PASSED");
}
}
