public async Task <CreateImageResponse> CreateImage(CreateImageRequest request)
{
if (!Directory.Exists(Environment.WebRootPath + "\\uploads\\"))
{
Directory.CreateDirectory(Environment.WebRootPath + "\\uploads\\");
}
var extension = MimeTypes.MimeTypeMap.GetExtension(request.File.ContentType);
string fileName;
do
{
var fileId = Guid.NewGuid();
fileName = $"{fileId}{extension}";
} while (System.IO.File.Exists(fileName));
using (var fileStream =
System.IO.File.Create(Environment.WebRootPath + "\\uploads\\" + fileName))
{
request.File.CopyTo(fileStream);
fileStream.Flush();
return(new CreateImageResponse()
{
ImageId = fileName
});
}
}
//file create image
private static void CreateImageByFile(ImsClient imsV2Client)
{
CreateImageRequest createImsInfoRequest = new CreateImageRequest()
{
Body = new CreateImageRequestBody()
{
Name = "FileCreateImage",
ImageUrl = "obs-494b:test.qcow2",
Type = CreateImageRequestBody.TypeEnum.ECS,
OsVersion = "CentOS 7.6 64bit",
MinDisk = 40
}
};
try
{
var createIms = imsV2Client.CreateImage(createImsInfoRequest);
Console.WriteLine(createIms.JobId);
}
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);
}
}
//create image by instance
private static void CreateImageByInstance(ImsClient imsV2Client)
{
CreateImageRequest createImsInfoRequest = new CreateImageRequest()
{
Body = new CreateImageRequestBody()
{
Name = "instanceCreateImage",
InstanceId = "1681268e-d52c-4116-b114-1fb090904368"
}
};
try
{
var createIms = imsV2Client.CreateImage(createImsInfoRequest);
Console.WriteLine(createIms.JobId);
}
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 async Task <Image> EditImage(int imageId, CreateImageRequest request)
{
return(await SendRequest <Image>(
$"gallery/images/{imageId}",
HttpMethod.Post,
request));
}
public async Task <Image> CreateImage(CreateImageRequest request)
{
return(await SendRequest <Image>(
$"gallery/images",
HttpMethod.Post,
request));
}
public AwsImageCreateOptionsValues(string name)
{
_request = new CreateImageRequest
{
Name = name
};
}
/// <summary>
/// 制作镜像
/// </summary>
public CreateImageResponse CreateImage(CreateImageRequest createImageRequest)
{
Dictionary <string, string> urlParam = new Dictionary <string, string>();
string urlPath = HttpUtils.AddUrlPath("/v2/cloudimages/action", urlParam);
SdkRequest request = HttpUtils.InitSdkRequest(urlPath, "application/json;charset=UTF-8", createImageRequest);
HttpResponseMessage response = DoHttpRequestSync("POST", request);
return(JsonUtils.DeSerialize <CreateImageResponse>(response));
}
public async Task <IActionResult> Create([FromBody] CreateImageDto image, [FromHeader] string username = null, [FromHeader] string password = null)
{
var request = new CreateImageRequest(username, password, image);
var response = await _mediator.Send(request);
var envelope = new Envelope <string>(response);
return(CreatedAtAction(nameof(Retrieve), new { id = envelope.Data }, envelope));
}
public async Task <IActionResult> UploadImage([FromBody] CreateImageRequest request, int userId)
{
//data:image/png;base64,
request.Base64Img = request.Base64Img.Remove(0, 23);
var converted = Convert.FromBase64String(request.Base64Img);
await _userService.UploadImage(converted, userId);
return(Ok());
}
public object Any(CreateImageRequest request)
{
AutoMapper.Mapper.CreateMap<CreateImageRequest, CreateImageRequestModel>();
var data = AutoMapper.Mapper.Map<CreateImageRequestModel>(request);
var response = new PostRepository().CreateImage(data);
AutoMapper.Mapper.CreateMap<PostEditResponseModel, PostEditResponse>();
return AutoMapper.Mapper.Map<PostEditResponse>(response);
}
/// <summary>
/// Creates a waiter using the provided configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="config">Wait Configuration</param>
/// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <CreateImageRequest, CreateImageResponse> ForCreateImage(CreateImageRequest request, WaiterConfiguration config, params WorkrequestsService.Models.WorkRequest.StatusEnum[] targetStates)
{
return(new Waiter <CreateImageRequest, CreateImageResponse>(() =>
{
var response = client.CreateImage(request).Result;
var getWorkRequestRequest = new Oci.WorkrequestsService.Requests.GetWorkRequestRequest
{
WorkRequestId = response.OpcWorkRequestId
};
workRequestClient.Waiters.ForWorkRequest(getWorkRequestRequest, config, targetStates).Execute();
return response;
}));
}
/// <summary>
/// 创建图片，并添加对应图片的自定义信息。
/// </summary>
/// <param name="req"><see cref="CreateImageRequest"/></param>
/// <returns><see cref="CreateImageResponse"/></returns>
public CreateImageResponse CreateImageSync(CreateImageRequest req)
{
JsonResponseModel <CreateImageResponse> rsp = null;
try
{
var strResp = this.InternalRequestSync(req, "CreateImage");
rsp = JsonConvert.DeserializeObject <JsonResponseModel <CreateImageResponse> >(strResp);
}
catch (JsonSerializationException e)
{
throw new TencentCloudSDKException(e.Message);
}
return(rsp.Response);
}
public void EcsCreateImage()
{
var accessKey = Environment.GetEnvironmentVariable("ACCESS_KEY_ID") ?? "AccessKeyId";
var accessKeySecret = Environment.GetEnvironmentVariable("ACCESS_KEY_SECRET") ?? "AccessKeySecret";
var regionId = "cn-hangzhou";
var profile = DefaultProfile.GetProfile(regionId, accessKey, accessKeySecret);
var client = new DefaultAcsClient(profile);
var request = new CreateImageRequest();
var diskDeviceMappings = new List <CreateImageRequest.DiskDeviceMapping>();
var diskDeviceMappingItem = new CreateImageRequest.DiskDeviceMapping();
diskDeviceMappingItem.Device = "device";
diskDeviceMappingItem.DiskType = "diskType";
diskDeviceMappingItem.Size = 5;
diskDeviceMappingItem.SnapshotId = "snapShotId";
diskDeviceMappings.Add(diskDeviceMappingItem);
request.DiskDeviceMappings = diskDeviceMappings;
var creatImageTag = new List <CreateImageRequest.Tag>();
var createImageTagItem = new CreateImageRequest.Tag();
createImageTagItem.Key = "key";
createImageTagItem.Value = "value";
creatImageTag.Add(createImageTagItem);
request.Tags = creatImageTag;
try
{
var response = client.GetAcsResponse(request);
Console.WriteLine(System.Text.Encoding.Default.GetString(response.HttpResponse.Content));
}
catch (ServerException ex)
{
Console.WriteLine(ex.ToString());
}
catch (ClientException ex)
{
Console.WriteLine("ErrorCode" + ex.ErrorCode);
Console.WriteLine("ErrorMessage" + ex.ErrorMessage);
}
}
public async Task <Guid> CreateImage(CreateImageRequest request)
{
var image = new Image
{
ImageTransforms = request.TransformedUrls.Select(pair => new ImageTransform
{
TransformName = pair.Key,
Url = pair.Value
}).ToList(),
Url = request.OriginalUrl
};
DbContext.Images.Add(image);
await DbContext.SaveChangesAsync();
return(image.Id);
}
private void HandleOutput(CreateImageRequest request)
{
var waiterConfig = new WaiterConfiguration
{
MaxAttempts = MaxWaitAttempts,
GetNextDelayInSeconds = (_) => WaitIntervalSeconds
};
switch (ParameterSetName)
{
case StatusParamSet:
response = client.Waiters.ForCreateImage(request, waiterConfig, WaitForStatus).Execute();
break;
case Default:
response = client.CreateImage(request).GetAwaiter().GetResult();
break;
}
WriteOutput(response, response.Image);
}
protected override void ProcessRecord()
{
base.ProcessRecord();
CreateImageRequest request;
try
{
request = new CreateImageRequest
{
CreateImageDetails = CreateImageDetails,
OpcRetryToken = OpcRetryToken
};
HandleOutput(request);
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
///<summary>
//Adds a new image.
//</summary>
public ImagesResponse Create(CreateImageRequest image)
{
try
{
var request = new RestRequest("/images", Method.POST)
{
RequestFormat = DataFormat.Json,
JsonSerializer = new CustomSerializer()
};
request.AddBody(image);
var result = restclient.Execute <ImagesResponse>(request);
if (result.StatusCode != HttpStatusCode.Accepted)
{
throw new Exception(result.Content);
}
return(result.Data);
}
catch
{
throw;
}
}
public string CreateImage(IAmazonEC2 ec2, string instidstr)
//stop ec2 instance
{
CreateImageRequest ImgReq;
CreateImageResponse ImageResponse = null;
string DT;
DT = DateTime.Now.ToString("yyyy-MM-dd_hh.mm.ss");
//ec2.DescribeImages
// RebootInstancesRequest rebootreq;
// RebootInstancesResponse rebootInstancesResponse = null;
try
{
ImgReq = new CreateImageRequest();
ImgReq.InstanceId = instidstr;
ImgReq.Name = instidstr + "_" + DT;
ImgReq.NoReboot = true;
ImgReq.Description = "Created By AWSPowerManager";
ImageResponse = ec2.CreateImage(ImgReq);
return("Image ID was created " + ImageResponse.ImageId);
}
catch (Exception ex)
{
return(ex.Message + "\n" + ex.StackTrace);
}
}
public async Task <CreateImageResponseModel> UploadImage()
{
var contentStream = await Request.Content.ReadAsStreamAsync();
var uploadImageResponse = await _cloudinaryService.UploadImage(new UploadImageRequest
{
Stream = contentStream
});
var createImageRequest = new CreateImageRequest
{
OriginalUrl = uploadImageResponse.OriginalUrl,
TransformedUrls = uploadImageResponse.TransformedImages
};
var guid = await _imagesManagementService.CreateImage(createImageRequest);
return(new CreateImageResponseModel
{
ImageId = guid,
OriginalUrl = createImageRequest.OriginalUrl,
TransformedUrls = createImageRequest.TransformedUrls
});
}
/// <summary>
/// Creates a waiter using default wait configuration.
/// </summary>
/// <param name="request">Request to send.</param>
/// <param name="statuses">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param>
/// <returns>a new Oci.common.Waiter instance</returns>
public Waiter <CreateImageRequest, CreateImageResponse> ForCreateImage(CreateImageRequest request, params WorkrequestsService.Models.WorkRequest.StatusEnum[] targetStates)
{
return(this.ForCreateImage(request, WaiterConfiguration.DefaultWaiterConfiguration, targetStates));
}
public AwsImageCreateOptionsValues(string instanceId, string name)
{
_request = new CreateImageRequest(instanceId, name);
}
public async Task <Guid> CreateImage(CreateImageRequest request)
{
var guid = await ProcessRequest(request, _imagesRepository.CreateImage);
return(guid);
}
