com.amazonaws.services.ec2.model.CreateVolumeResult Java Examples

/**
 * Creates volume for EBS.
 * @return volume ID of newly created volume
 */
private String createVolume(String storageId, String snapshotId, int size) {
	String volumeType = Ec2IaasHandler.findStorageProperty(this.targetProperties, storageId, VOLUME_TYPE_PREFIX);
	if(volumeType == null) volumeType = "standard";

	CreateVolumeRequest createVolumeRequest = new CreateVolumeRequest()
			.withAvailabilityZone( this.availabilityZone )
			.withVolumeType( volumeType )
			.withSize( size ); // The size of the volume, in gigabytes.

	// EC2 snapshot IDs start with "snap-"...
	if(! Utils.isEmptyOrWhitespaces(snapshotId) && snapshotId.startsWith("snap-"))
		createVolumeRequest.withSnapshotId(snapshotId);

	CreateVolumeResult createVolumeResult = this.ec2Api.createVolume(createVolumeRequest);
	return createVolumeResult.getVolume().getVolumeId();
}
 

/**
 * Create Volume.
 *
 * @param availabilityZone the availability zone
 * @param iops the iops
 * @param size the size
 * @param snapshotId the snapshot id
 * @param volumeType the volume type
 * @return Volume
 */
protected final Volume createVolume(final String availabilityZone, final Integer iops, final Integer size, final String snapshotId, final String volumeType) {
    Volume volume = null;

    CreateVolumeRequest req = new CreateVolumeRequest();
    req.setAvailabilityZone(availabilityZone);
    req.setIops(iops);
    req.setSize(size);
    req.setSnapshotId(snapshotId);
    req.setVolumeType(volumeType);
    
    CreateVolumeResult result = amazonEC2Client.createVolume(req);
    if (result != null) {
        volume = result.getVolume();
    }

    return volume;
}
 

private Optional<String> prepareSnapshotForEncryptionBecauseThatDoesNotExist(AuthenticatedContext ac, CloudStack cloudStack, AwsInstanceView instanceView,
        AmazonEC2Client client, PersistenceNotifier resourceNotifier) {
    LOGGER.debug("Create an encrypted EBS volume for group: '{}'", instanceView.getGroupName());
    CreateVolumeResult volumeResult = client.createVolume(prepareCreateVolumeRequest(ac, instanceView, client, cloudStack));
    String volumeId = volumeResult.getVolume().getVolumeId();
    checkEbsVolumeStatus(ac, client, volumeId);
    saveEncryptedResource(ac, resourceNotifier, ResourceType.AWS_ENCRYPTED_VOLUME, volumeId, instanceView.getGroupName());
    LOGGER.debug("Encrypted EBS volume has been created with id: '{}', for group: '{}'", volumeId, instanceView.getGroupName());

    LOGGER.debug("Create an encrypted snapshot of EBS volume for group: '{}'", instanceView.getGroupName());
    CreateSnapshotResult snapshotResult = client.createSnapshot(prepareCreateSnapshotRequest(volumeResult));
    checkSnapshotReadiness(ac, client, snapshotResult);
    LOGGER.debug("Encrypted snapshot of EBS volume has been created with id: '{}', for group: '{}'", snapshotResult.getSnapshot().getSnapshotId(),
            instanceView.getGroupName());
    client.createTags(prepareCreateTagsRequest(ac, cloudStack, instanceView, snapshotResult));
    return Optional.of(snapshotResult.getSnapshot().getSnapshotId());
}
 

@Override
public Image createVolume(CreateVolumeRequest request,
        ResultCapture<CreateVolumeResult> extractor) {

    ActionResult result = service.performAction("CreateVolume", request,
            extractor);

    if (result == null) return null;
    return new ImageImpl(result.getResource());
}
 

@Override
public Image createVolume(String availabilityZone, Integer size,
        ResultCapture<CreateVolumeResult> extractor) {

    CreateVolumeRequest request = new CreateVolumeRequest()
        .withAvailabilityZone(availabilityZone)
        .withSize(size);
    return createVolume(request, extractor);
}
 

@Override
public Image createVolume(String snapshotId, String availabilityZone,
        ResultCapture<CreateVolumeResult> extractor) {

    CreateVolumeRequest request = new CreateVolumeRequest()
        .withSnapshotId(snapshotId)
        .withAvailabilityZone(availabilityZone);
    return createVolume(request, extractor);
}
 

private void setupCreateVolumeResponse() {
    when(amazonEC2Client.createVolume(any())).thenReturn(
            new CreateVolumeResult().withVolume(
                    new com.amazonaws.services.ec2.model.Volume().withVolumeId(VOLUME_ID + getNextVolumeId())
            )
    );
}
 

public void createVolume(AwsProcessClient awsProcessClient, Long instanceNo, Long volumeNo) {
    AwsVolume awsVolume = awsVolumeDao.read(volumeNo);
    AwsInstance awsInstance = awsInstanceDao.read(instanceNo);

    // ボリュームの作成
    CreateVolumeRequest request = new CreateVolumeRequest();
    request.withSize(awsVolume.getSize());
    request.withSnapshotId(awsVolume.getSnapshotId());
    request.withAvailabilityZone(awsInstance.getAvailabilityZone());

    String volumeType = Config.getProperty("aws.volumeType");
    if (StringUtils.isNotEmpty(volumeType)) {
        request.withVolumeType(volumeType);
    }

    CreateVolumeResult result = awsProcessClient.getEc2Client().createVolume(request);
    Volume volume = result.getVolume();

    String volumeId = volume.getVolumeId();

    // ログ出力
    if (log.isInfoEnabled()) {
        log.info(MessageUtils.getMessage("IPROCESS-100121", volumeId));
    }

    //イベントログ出力
    Component component = null;
    if (awsVolume.getComponentNo() != null) {
        component = componentDao.read(awsVolume.getComponentNo());
    }
    Instance instance = instanceDao.read(instanceNo);
    processLogger.debug(component, instance, "AwsEbsCreate",
            new Object[] { awsProcessClient.getPlatform().getPlatformName() });

    // データベース更新
    awsVolume.setVolumeId(volume.getVolumeId());
    awsVolume.setStatus(volume.getState());
    awsVolumeDao.update(awsVolume);
}
 

@Override
public Image createVolume(String availabilityZone, Integer size) {
    return createVolume(availabilityZone, size,
            (ResultCapture<CreateVolumeResult>)null);
}
 

@Override
public Image createVolume(String snapshotId, String availabilityZone) {
    return createVolume(snapshotId, availabilityZone,
            (ResultCapture<CreateVolumeResult>)null);
}
 

@Override
public List<CloudResource> build(AwsContext context, long privateId, AuthenticatedContext auth, Group group,
        List<CloudResource> buildableResource, CloudStack cloudStack) throws Exception {
    LOGGER.debug("Create volumes on provider");
    AmazonEc2RetryClient client = getAmazonEC2Client(auth);

    Map<String, List<Volume>> volumeSetMap = Collections.synchronizedMap(new HashMap<>());

    List<Future<?>> futures = new ArrayList<>();
    String snapshotId = getEbsSnapshotIdIfNeeded(auth, cloudStack, group);
    boolean encryptedVolumeUsingFastApproach = isEncryptedVolumeUsingFastApproachRequested(group);
    String volumeEncryptionKey = getVolumeEncryptionKey(group, encryptedVolumeUsingFastApproach);
    TagSpecification tagSpecification = new TagSpecification()
            .withResourceType(com.amazonaws.services.ec2.model.ResourceType.Volume)
            .withTags(awsTaggingService.prepareEc2Tags(auth, cloudStack.getTags()));

    List<CloudResource> requestedResources = buildableResource.stream()
            .filter(cloudResource -> CommonStatus.REQUESTED.equals(cloudResource.getStatus()))
            .collect(Collectors.toList());
    Long ephemeralCount = group.getReferenceInstanceConfiguration().getTemplate().getVolumes().stream()
            .filter(vol -> AwsDiskType.Ephemeral.value().equalsIgnoreCase(vol.getType())).collect(Collectors.counting());

    LOGGER.debug("Start creating data volumes for stack: '{}' group: '{}'", auth.getCloudContext().getName(), group.getName());

    for (CloudResource resource : requestedResources) {
        volumeSetMap.put(resource.getName(), Collections.synchronizedList(new ArrayList<>()));

        VolumeSetAttributes volumeSet = resource.getParameter(CloudResource.ATTRIBUTES, VolumeSetAttributes.class);
        DeviceNameGenerator generator = new DeviceNameGenerator(DEVICE_NAME_TEMPLATE, ephemeralCount.intValue());
        futures.addAll(volumeSet.getVolumes().stream()
                .map(createVolumeRequest(snapshotId, encryptedVolumeUsingFastApproach, volumeEncryptionKey, tagSpecification, volumeSet))
                .map(request -> intermediateBuilderExecutor.submit(() -> {
                    CreateVolumeResult result = client.createVolume(request);
                    String volumeId = result.getVolume().getVolumeId();
                    Volume volume = new Volume(volumeId, generator.next(), request.getSize(), request.getVolumeType());
                    volumeSetMap.get(resource.getName()).add(volume);
                }))
                .collect(Collectors.toList()));
    }

    for (Future<?> future : futures) {
        future.get();
    }

    return buildableResource.stream()
            .peek(resource -> {
                List<Volume> volumes = volumeSetMap.get(resource.getName());
                if (!CollectionUtils.isEmpty(volumes)) {
                    resource.getParameter(CloudResource.ATTRIBUTES, VolumeSetAttributes.class).setVolumes(volumes);
                }
            })
            .map(copyResourceWithNewStatus(CommonStatus.CREATED))
            .collect(Collectors.toList());
}
 

public CreateVolumeResult createVolume(CreateVolumeRequest request) {
    return retry.testWith2SecDelayMax15Times(() -> mapThrottlingError(() -> client.createVolume(request)));
}
 

private CreateSnapshotRequest prepareCreateSnapshotRequest(CreateVolumeResult volumeResult) {
    return new CreateSnapshotRequest().withVolumeId(volumeResult.getVolume().getVolumeId()).withDescription(ENCRYPTED_SNAPSHOT);
}
 

private CreateVolumeResult createCreateVolumeResult() {
    return new CreateVolumeResult().withVolume(new com.amazonaws.services.ec2.model.Volume().withVolumeId(VOLUME_ID));
}
 

/**
 * The convenient method form for the <code>CreateVolume</code> action.
 *
 * @see #createVolume(CreateVolumeRequest, ResultCapture)
 */
com.amazonaws.resources.ec2.Image createVolume(String availabilityZone,
        Integer size, ResultCapture<CreateVolumeResult> extractor);
 

/**
 * The convenient method form for the <code>CreateVolume</code> action.
 *
 * @see #createVolume(CreateVolumeRequest, ResultCapture)
 */
com.amazonaws.resources.ec2.Image createVolume(String snapshotId, String
        availabilityZone, ResultCapture<CreateVolumeResult> extractor);
 

/**
 * Performs the <code>CreateVolume</code> action and use a ResultCapture to
 * retrieve the low-level client response.
 *
 * <p>
 *
 * @return The <code>Image</code> resource object associated with the result
 *         of this action.
 * @see CreateVolumeRequest
 */
com.amazonaws.resources.ec2.Image createVolume(CreateVolumeRequest request,
        ResultCapture<CreateVolumeResult> extractor);