use of com.amazonaws.services.ec2.model.CreateVolumeRequest in project GNS by MobilityFirst.
the class AWSEC2 method createAndAttachVolume.
/**
* Creates a volume and attaches and mounts it on the instance at the specified mount point.
*
* @param ec2
* @param instanceId
* @param mountPoint
* @return the id of the volume
*/
public static String createAndAttachVolume(AmazonEC2 ec2, String instanceId, String mountPoint) {
// ATTACH A VOLUME
Instance instance = findInstance(ec2, instanceId);
String zone = instance.getPlacement().getAvailabilityZone();
CreateVolumeRequest newVolumeRequest = new CreateVolumeRequest();
//1.0GB
newVolumeRequest.setSize(1);
// set its available zone, it may change.
newVolumeRequest.setAvailabilityZone(zone);
CreateVolumeResult volumeResult = ec2.createVolume(newVolumeRequest);
Volume v1 = volumeResult.getVolume();
String volumeID = v1.getVolumeId();
//begin to attach the volume to instance
AttachVolumeRequest avr = new AttachVolumeRequest();
avr.withInstanceId(instanceId);
avr.withVolumeId(volumeID);
//mount it
avr.withDevice(mountPoint);
ec2.attachVolume(avr);
System.out.println("EBS volume has been attached and the volume ID is: " + volumeID);
return (volumeID);
}
use of com.amazonaws.services.ec2.model.CreateVolumeRequest in project photon-model by vmware.
the class TestAWSEnumerationTask method testEnumeration.
// Runs the enumeration task on the AWS endpoint to list all the instances on the endpoint.
@Test
public void testEnumeration() throws Throwable {
this.host.log("Running test: " + this.currentTestName.getMethodName());
ComputeState vmState = createAWSVMResource(this.host, this.computeHost, this.endpointState, TestAWSSetupUtils.class, zoneId, regionId, null, this.singleNicSpec, this.awsTestContext);
if (this.isMock) {
// Just make a call to the enumeration service and make sure that the adapter patches
// the parent with completion.
enumerateResources(this.host, this.computeHost, this.endpointState, this.isMock, TEST_CASE_MOCK_MODE);
return;
}
// Overriding the page size to test the pagination logic with limited instances on AWS.
// This is a functional test
// so the latency numbers maybe higher from this test due to low page size.
setQueryPageSize(DEFAULT_TEST_PAGE_SIZE);
setQueryResultLimit(DEFAULT_TEST_PAGE_SIZE);
// Provision a single VM . Check initial state.
vmState = provisionMachine(this.host, vmState, this.isMock, this.instancesToCleanUp);
queryComputeInstances(this.host, count2);
queryDocumentsAndAssertExpectedCount(this.host, count2, ComputeDescriptionService.FACTORY_LINK, false);
if (ENABLE_LOAD_BALANCER_ENUMERATION) {
this.lbToCleanUp = provisionAWSLoadBalancerWithEC2Client(this.host, this.lbClient, null, this.subnetId, this.securityGroupId, Collections.singletonList(vmState.id));
}
// CREATION directly on AWS
List<String> instanceIdsToDeleteFirstTime = provisionAWSVMWithEC2Client(this.client, this.host, count4, T2_MICRO_INSTANCE_TYPE, this.subnetId, this.securityGroupId);
List<String> instanceIds = provisionAWSVMWithEC2Client(this.client, this.host, count1, instanceType, this.subnetId, this.securityGroupId);
instanceIdsToDeleteFirstTime.addAll(instanceIds);
this.instancesToCleanUp.addAll(instanceIdsToDeleteFirstTime);
waitForProvisioningToComplete(instanceIdsToDeleteFirstTime, this.host, this.client, ZERO);
// Xenon does not know about the new instances.
ProvisioningUtils.queryComputeInstances(this.host, count2);
// Create S3 bucket on amazon
Map<String, String> tags = new HashMap<>();
tags.put(S3_TAG_KEY_1, S3_TAG_VALUE_1);
tags.put(S3_TAG_KEY_2, S3_TAG_VALUE_2);
createS3BucketAndTags(tags);
this.bucketToBeDeleted = TEST_BUCKET_NAME;
enumerateResources(this.host, this.computeHost, this.endpointState, this.isMock, TEST_CASE_INITIAL);
// Get a count of how many EBS disks are attached to a VM initially.
ComputeState csForDiskLinkValidation = getComputeStateFromId(this.instancesToCleanUp.get(0));
this.initialEbsDiskLinkCount = csForDiskLinkValidation.diskLinks.size();
// Create a volume to be attached to the VM later.
CreateVolumeRequest createVolumeRequest = new CreateVolumeRequest().withAvailabilityZone(csForDiskLinkValidation.zoneId).withVolumeType(VolumeType.Gp2).withSize(10);
CreateVolumeResult createVolumeResult = this.client.createVolume(createVolumeRequest);
this.testEbsId = createVolumeResult.getVolume().getVolumeId();
// Validate if the S3 bucket is enumerated.
validateS3Enumeration(count1, count3);
// Validate S3 tag state count.
validateS3TagStatesCreated();
if (ENABLE_LOAD_BALANCER_ENUMERATION) {
// Validate Load Balancer State
validateLoadBalancerState(this.lbToCleanUp, vmState.documentSelfLink);
}
// Remove a tag from test S3 bucket.
tags.clear();
tags.put(S3_TAG_KEY_1, S3_TAG_VALUE_1);
createS3BucketAndTags(tags);
// 5 new resources should be discovered. Mapping to 2 new compute description and 5 new
// compute states.
// Even though the "t2.micro" is common to the VM provisioned from Xenon
// service and the one directly provisioned on EC2, there is no Compute description
// linking of discovered resources to user defined compute descriptions. So a new system
// generated compute description will be created for "t2.micro"
queryDocumentsAndAssertExpectedCount(this.host, count4, ComputeDescriptionService.FACTORY_LINK, false);
queryDocumentsAndAssertExpectedCount(this.host, count7, ComputeService.FACTORY_LINK, false);
queryDocumentsAndAssertExpectedCount(this.host, count7, DiskService.FACTORY_LINK, false);
// Validate at least 4 availability zones were enumerated
ProvisioningUtils.queryComputeInstancesByType(this.host, count4, ComputeType.ZONE.toString(), false);
// Update Scenario : Check that the tag information is present for the VM tagged above.
String vpCId = validateTagAndNetworkAndComputeDescriptionInformation(vmState);
validateVPCInformation(vpCId);
// Count should be 1 NICs per discovered VM.
int totalNetworkInterfaceStateCount = count6 * this.singleNicSpec.numberOfNics();
validateNetworkInterfaceCount(totalNetworkInterfaceStateCount);
// One VPC should be discovered in the test.
queryDocumentsAndAssertExpectedCount(this.host, count1, NetworkService.FACTORY_LINK, false);
// Verify that the SecurityGroups of the newly created VM has been enumerated and exists
// locally
validateSecurityGroupsInformation(vmState.groupLinks);
// Verify stop flow
// The first instance of instanceIdsToDeleteFirstTime will be stopped.
String instanceIdsToStop = instanceIdsToDeleteFirstTime.get(0);
tagResourcesWithName(this.client, VM_STOPPED_NAME, instanceIdsToStop);
// Stop one instance
stopVMsUsingEC2Client(this.client, this.host, new ArrayList<>(Arrays.asList(instanceIdsToStop)));
// Create stale resources, that later should be deleted by the enumeration
String staleSubnetDocumentSelfLink = markFirstResourceStateAsStale(host, SubnetState.class, SubnetService.FACTORY_LINK);
String staleNetworkDocumentSelfLink = markFirstResourceStateAsStale(host, NetworkState.class, NetworkService.FACTORY_LINK);
// During the enumeration, if one instance is stopped, its public ip address
// will disappear, then the corresponding link of local ComputeState's public
// network interface and its document will be removed.
enumerateResources(this.host, this.computeHost, this.endpointState, this.isMock, TEST_CASE_STOP_VM);
// Validate that test VM still has same number of diskLinks.
csForDiskLinkValidation = getComputeStateFromId(this.instancesToCleanUp.get(0));
assertEquals(csForDiskLinkValidation.diskLinks.size(), this.initialEbsDiskLinkCount);
// Attach volume to test VM.
AttachVolumeRequest attachVolumeRequest = new AttachVolumeRequest().withVolumeId(createVolumeResult.getVolume().getVolumeId()).withInstanceId(csForDiskLinkValidation.id).withDevice("/dev/sdh");
this.client.attachVolume(attachVolumeRequest);
// Validate stale resources have been deleted
validateStaleResourceStateDeletion(staleSubnetDocumentSelfLink, staleNetworkDocumentSelfLink);
// After two enumeration cycles, validate that we did not create duplicate documents for existing
// S3 bucket and validate that we did not add duplicate tagLink in diskState and removed the tagLink
// for tag deleted from AWS.
validateS3Enumeration(count1, count2);
// Remove region from S3 bucket DiskState.
removeS3BucketRegionFromDiskState();
// Validate that deleted S3 tag's local state is deleted.
validateS3TagStatesCreated();
enumerateResources(this.host, this.computeHost, this.endpointState, this.isMock, TEST_CASE_ADDITIONAL_VM);
// Check that newly attached volume got enumerated and the instance now has 1 more diskLink than before.
csForDiskLinkValidation = getComputeStateFromId(this.instancesToCleanUp.get(0));
assertEquals(csForDiskLinkValidation.diskLinks.size(), this.initialEbsDiskLinkCount + 1);
// Validate that diskState of S3 bucket with null region got deleted
validateBucketStateDeletionForNullRegion();
// Delete the S3 bucket created in the test
this.s3Client.deleteBucket(TEST_BUCKET_NAME);
this.bucketToBeDeleted = null;
// Because one public NIC and its document are removed,
// the totalNetworkInterfaceStateCount should go down by 1
validateRemovalOfPublicNetworkInterface(instanceIdsToStop, totalNetworkInterfaceStateCount - 1);
// Provision an additional VM with a different instance type. It should re-use the
// existing compute description created by the enumeration task above.
List<String> instanceIdsToDeleteSecondTime = provisionAWSVMWithEC2Client(this.client, this.host, count1, TestAWSSetupUtils.instanceType, this.subnetId, this.securityGroupId);
this.instancesToCleanUp.addAll(instanceIdsToDeleteSecondTime);
waitForProvisioningToComplete(instanceIdsToDeleteSecondTime, this.host, this.client, ZERO);
enumerateResources(this.host, this.computeHost, this.endpointState, this.isMock, TEST_CASE_ADDITIONAL_VM);
// Validate that we do not add duplicate diskLinks after multiple enumerations.
csForDiskLinkValidation = getComputeStateFromId(this.instancesToCleanUp.get(0));
assertEquals(csForDiskLinkValidation.diskLinks.size(), this.initialEbsDiskLinkCount + 1);
// Detach and delete test EBS volume.
DetachVolumeRequest detachVolumeRequest = new DetachVolumeRequest().withVolumeId(this.testEbsId);
this.client.detachVolume(detachVolumeRequest);
// One additional compute state and no additional compute description should be
// created. 1) compute host CD 2) t2.nano-system generated 3) t2.micro-system generated
// 4) t2.micro-created from test code.
queryDocumentsAndAssertExpectedCount(this.host, count4, ComputeDescriptionService.FACTORY_LINK, false);
ServiceDocumentQueryResult computesResult1 = queryDocumentsAndAssertExpectedCount(this.host, count8, ComputeService.FACTORY_LINK, false);
// validate the internal tag tor type=ec2_instance is set
// query for the existing internal tag state for type=ec2_instance.
// There should be only one internal tag.
validateTagInEntity(computesResult1, ComputeState.class, ec2_instance.toString());
ServiceDocumentQueryResult networkInterfaceResult = queryDocumentsAndAssertExpectedCount(this.host, totalNetworkInterfaceStateCount - 1, NetworkInterfaceService.FACTORY_LINK, false);
validateTagInEntity(networkInterfaceResult, NetworkInterfaceState.class, ec2_net_interface.toString());
ServiceDocumentQueryResult networkStateResult = queryDocumentsAndAssertExpectedCount(this.host, count1, NetworkService.FACTORY_LINK, false);
validateTagInEntity(networkStateResult, NetworkState.class, ec2_vpc.toString());
ServiceDocumentQueryResult subnetStateResult = queryDocumentsAndAssertExpectedCount(this.host, count1, SubnetService.FACTORY_LINK, false);
// TODO Remove. This is to help debug an intermittent test failure.
host.log(Level.INFO, "The subnet result state that I am working with is " + Utils.toJsonHtml(subnetStateResult));
validateTagInEntity(subnetStateResult, SubnetState.class, ec2_subnet.toString());
queryDocumentsAndAssertExpectedCount(this.host, count8, DiskService.FACTORY_LINK, false);
// Verify Deletion flow
// Delete 5 VMs spawned above of type T2_NANO
deleteVMsUsingEC2Client(this.client, this.host, instanceIdsToDeleteFirstTime);
enumerateResources(this.host, this.computeHost, this.endpointState, this.isMock, TEST_CASE_DELETE_VMS);
// Counts should go down. 5 compute states and 5 disk states.
ServiceDocumentQueryResult computesResult2 = queryDocumentsAndAssertExpectedCount(this.host, count3, ComputeService.FACTORY_LINK, false);
queryDocumentsAndAssertExpectedCount(this.host, count3, DiskService.FACTORY_LINK, false);
// Validate that detached test EBS is removed from diskLinks of test instance.
csForDiskLinkValidation = getComputeStateFromId(this.instancesToCleanUp.get(0));
assertEquals(csForDiskLinkValidation.diskLinks.size(), this.initialEbsDiskLinkCount);
// validate the internal tag tor type=ec2_instance is set
// query for the existing internal tag state for type=ec2_instance.
// There should be only one internal tag.
validateTagInEntity(computesResult2, ComputeState.class, ec2_instance.toString());
// Delete 1 VMs spawned above of type T2_Micro
deleteVMsUsingEC2Client(this.client, this.host, instanceIdsToDeleteSecondTime);
enumerateResources(this.host, this.computeHost, this.endpointState, this.isMock, TEST_CASE_DELETE_VM);
// Compute state and disk state count should go down by 1
ServiceDocumentQueryResult computesResult3 = queryDocumentsAndAssertExpectedCount(this.host, count2, ComputeService.FACTORY_LINK, false);
queryDocumentsAndAssertExpectedCount(this.host, count2, DiskService.FACTORY_LINK, false);
// validate the internal tag tor type=ec2_instance is set
// query for the existing internal tag state for type=ec2_instance.
// There should be only one internal tag.
validateTagInEntity(computesResult3, ComputeState.class, ec2_instance.toString());
// Validate that the document for the deleted S3 bucket is deleted after enumeration.
validateS3Enumeration(ZERO, ZERO);
// Delete test EBS volume.
DeleteVolumeRequest deleteVolumeRequest = new DeleteVolumeRequest().withVolumeId(this.testEbsId);
this.client.deleteVolume(deleteVolumeRequest);
this.testEbsId = null;
}
use of com.amazonaws.services.ec2.model.CreateVolumeRequest in project photon-model by vmware.
the class TestAWSSetupUtils method createVolume.
/**
* Creates a volume and return the volume id.
*/
public static String createVolume(VerificationHost host, AmazonEC2Client client) {
CreateVolumeRequest req = new CreateVolumeRequest().withAvailabilityZone(zoneId + avalabilityZoneIdentifier).withSize(1);
CreateVolumeResult res = client.createVolume(req);
String volumeId = res.getVolume().getVolumeId();
Filter filter = new Filter().withName(VOLUME_ID_ATTRIBUTE).withValues(volumeId);
DescribeVolumesRequest volumesRequest = new DescribeVolumesRequest().withVolumeIds(volumeId).withFilters(filter);
host.waitFor("Timeout waiting for creating volume", () -> {
DescribeVolumesResult volumesResult = client.describeVolumes(volumesRequest);
String state = volumesResult.getVolumes().get(0).getState();
if (state.equalsIgnoreCase(VOLUME_STATUS_AVAILABLE)) {
return true;
}
return false;
});
tagResources(client, Arrays.asList(volumeId), TAG_KEY_FOR_TEST_RESOURCES, TAG_VALUE_FOR_TEST_RESOURCES + TAG_VOLUME);
return volumeId;
}
use of com.amazonaws.services.ec2.model.CreateVolumeRequest in project photon-model by vmware.
the class AWSDiskService method createDisk.
/**
* Create a volume on aws that represents the requested disk.
*/
private void createDisk(AWSDiskContext context) {
if (context.diskRequest.isMockRequest) {
Volume vol = getMockVolume();
updateDiskState(vol, context, AwsDiskStage.FINISHED);
return;
}
DiskState diskState = context.disk;
// add endpointLinks
AdapterUtils.addToEndpointLinks(diskState, context.disk.endpointLink);
if (diskState.capacityMBytes <= 0) {
String message = "Disk size has to be positive";
this.logWarning(() -> "[AWSDiskService] " + message);
throw new IllegalArgumentException(message);
}
if (diskState.customProperties != null && diskState.customProperties.get(DEVICE_TYPE) != null && diskState.customProperties.get(DEVICE_TYPE).equals(AWSConstants.AWSStorageType.INSTANCE_STORE.getName())) {
String message = "Independent Instance Store disk cannot be created.";
this.logWarning(() -> "[AWSDiskService] " + message);
throw new IllegalArgumentException(message);
}
CreateVolumeRequest req = new CreateVolumeRequest();
String zoneId = diskState.zoneId;
if (zoneId == null) {
List<AvailabilityZone> availabilityZoneList = context.client.getAvailabilityZones();
if (availabilityZoneList.isEmpty()) {
String message = String.format("No zones are available in the region %s:", diskState.regionId);
this.logSevere(() -> "[AWSDiskService] " + message);
throw new IllegalArgumentException(message);
}
zoneId = availabilityZoneList.get(0).getZoneName();
}
// set availability zone
req.withAvailabilityZone(zoneId);
// set volume size
int diskSize = (int) diskState.capacityMBytes / 1024;
req.withSize(diskSize);
// set encrypted field
Boolean encrypted = diskState.encrypted == null ? false : diskState.encrypted;
req.withEncrypted(encrypted);
AWSUtils.setEbsDefaultsIfNotSet(diskState, Boolean.TRUE);
validateSizeSupportedByVolumeType(diskSize, diskState.customProperties.get(VOLUME_TYPE));
// set volume type
if (diskState.customProperties.containsKey(VOLUME_TYPE)) {
req.withVolumeType(diskState.customProperties.get(VOLUME_TYPE));
}
// set iops
String diskIops = diskState.customProperties.get(DISK_IOPS);
if (diskIops != null && !diskIops.isEmpty()) {
int iops = Integer.parseInt(diskIops);
if (iops > diskSize * MAX_IOPS_PER_GiB) {
String info = String.format("[AWSDiskService] Requested IOPS (%s) exceeds" + " the maximum value supported by %sGiB disk. Continues " + "provisioning the disk with %s iops", iops, diskSize, diskSize * MAX_IOPS_PER_GiB);
this.logInfo(() -> info);
iops = diskSize * MAX_IOPS_PER_GiB;
}
req.withIops(iops);
}
AsyncHandler<CreateVolumeRequest, CreateVolumeResult> creationHandler = new AWSDiskCreationHandler(this, context);
context.client.createVolume(req, creationHandler);
}
use of com.amazonaws.services.ec2.model.CreateVolumeRequest in project cloudbreak by hortonworks.
the class EncryptedSnapshotPreparator method prepareCreateVolumeRequest.
private CreateVolumeRequest prepareCreateVolumeRequest(AuthenticatedContext ac, AwsInstanceView awsInstanceView, AmazonEC2 client) {
String availabilityZone = prepareDescribeAvailabilityZonesResult(ac, client);
CreateVolumeRequest createVolumeRequest = new CreateVolumeRequest().withSize(VOLUME_SIZE).withAvailabilityZone(availabilityZone).withEncrypted(true);
if (awsInstanceView.isKmsEnabled()) {
createVolumeRequest.withKmsKeyId(awsInstanceView.getKmsKey());
}
return createVolumeRequest;
}
Aggregations