List of usage examples for com.amazonaws.services.ec2.model Volume getVolumeId
public String getVolumeId()
The ID of the volume.
From source file:EBS_S3.java
License:Open Source License
public static void main(String[] args) throws Exception { AWSCredentials credentials = new PropertiesCredentials( EBS_S3.class.getResourceAsStream("AwsCredentials.properties")); /********************************************* * #1 Create Amazon Client object// w ww .j a v a2s. c o m **********************************************/ ec2 = new AmazonEC2Client(credentials); // We assume that we've already created an instance. Use the id of the instance. String instanceId = "i-278afe40"; //put your own instance id to test this code. try { /********************************************* * #2.1 Create a volume *********************************************/ // release System.out.println(ec2.describeVolumes()); List<Volume> v_list = ec2.describeVolumes().getVolumes(); System.out.println("Volume size: " + v_list.size()); DeleteVolumeRequest rq; for (Volume v : v_list) { if (v.getVolumeId().compareTo("vol-343dd879") != 0) { rq = new DeleteVolumeRequest(v.getVolumeId()); ec2.deleteVolume(rq); } } System.out.println(ec2.describeVolumes()); System.out.println("Volume size: " + v_list.size()); //create a volume System.out.println("2.1 Create a volume"); CreateVolumeRequest cvr = new CreateVolumeRequest(); cvr.setAvailabilityZone("us-east-1b"); cvr.setSize(10); //size = 10 gigabytes CreateVolumeResult volumeResult = ec2.createVolume(cvr); String createdVolumeId = volumeResult.getVolume().getVolumeId(); System.out.println("Created Volume ID: " + createdVolumeId); /********************************************* * #2.2 Attach the volume to the instance *********************************************/ System.out.println("2.2 Attach the volume to the instance"); Thread.sleep(30000); AttachVolumeRequest avr = new AttachVolumeRequest(); avr.setVolumeId(createdVolumeId); avr.setInstanceId(instanceId); avr.setDevice("/dev/sdf"); ec2.attachVolume(avr); /********************************************* * #2.3 Detach the volume from the instance *********************************************/ System.out.println("2.3 Detach the volume from the instance"); DetachVolumeRequest dvr = new DetachVolumeRequest(); dvr.setVolumeId(createdVolumeId); dvr.setInstanceId(instanceId); ec2.detachVolume(dvr); /************************************************ * #3 S3 bucket and object ***************************************************/ System.out.println("3 S3 bucket and object"); s3 = new AmazonS3Client(credentials); //create bucket String bucketName = "cloud-xiangyao-bucket"; s3.createBucket(bucketName); //set key String key = "object-name.txt"; //set value File file = File.createTempFile("temp", ".txt"); file.deleteOnExit(); Writer writer = new OutputStreamWriter(new FileOutputStream(file)); writer.write("This is a sample sentence.\r\nYes!"); writer.close(); //put object - bucket, key, value(file) s3.putObject(new PutObjectRequest(bucketName, key, file)); //get object S3Object object = s3.getObject(new GetObjectRequest(bucketName, key)); BufferedReader reader = new BufferedReader(new InputStreamReader(object.getObjectContent())); String data = null; while ((data = reader.readLine()) != null) { System.out.println(data); } /********************************************* * #4 shutdown client object *********************************************/ System.out.println("4 shutdown client object"); ec2.shutdown(); s3.shutdown(); } catch (AmazonServiceException ase) { System.out.println("Caught Exception: " + ase.getMessage()); System.out.println("Reponse Status Code: " + ase.getStatusCode()); System.out.println("Error Code: " + ase.getErrorCode()); System.out.println("Request ID: " + ase.getRequestId()); } }
From source file:AwsSample.java
License:Open Source License
public static void main(String[] args) throws Exception { BasicAWSCredentials credentials = new BasicAWSCredentials("", ""); /********************************************* * /*from w w w. j av a2s . c o m*/ * #1 Create Amazon Client object * *********************************************/ System.out.println("#1 Create Amazon Client object"); ec2 = new AmazonEC2Client(credentials); try { /********************************************* * * #2 Describe Availability Zones. * *********************************************/ System.out.println("#2 Describe Availability Zones."); DescribeAvailabilityZonesResult availabilityZonesResult = ec2.describeAvailabilityZones(); System.out.println("You have access to " + availabilityZonesResult.getAvailabilityZones().size() + " Availability Zones."); /********************************************* * * #3 Describe Available Images * *********************************************/ System.out.println("#3 Describe Available Images"); DescribeImagesResult dir = ec2.describeImages(); List<Image> images = dir.getImages(); System.out.println("You have " + images.size() + " Amazon images"); /********************************************* * * #4 Describe Key Pair * *********************************************/ System.out.println("#9 Describe Key Pair"); DescribeKeyPairsResult dkr = ec2.describeKeyPairs(); System.out.println(dkr.toString()); /********************************************* * * #5 Describe Current Instances * *********************************************/ System.out.println("#4 Describe Current Instances"); DescribeInstancesResult describeInstancesRequest = ec2.describeInstances(); List<Reservation> reservations = describeInstancesRequest.getReservations(); Set<Instance> instances = new HashSet<Instance>(); // add all instances to a Set. for (Reservation reservation : reservations) { instances.addAll(reservation.getInstances()); } System.out.println("You have " + instances.size() + " Amazon EC2 instance(s)."); for (Instance ins : instances) { // instance id String instanceId = ins.getInstanceId(); // instance state InstanceState is = ins.getState(); System.out.println(instanceId + " " + is.getName()); } /////////////////////////////////////// String Temp_Group = "Testgroup1"; //name of the group CreateSecurityGroupRequest r1 = new CreateSecurityGroupRequest(Temp_Group, "temporal group"); ec2.createSecurityGroup(r1); AuthorizeSecurityGroupIngressRequest r2 = new AuthorizeSecurityGroupIngressRequest(); r2.setGroupName(Temp_Group); /*************the property of http*****************/ IpPermission permission = new IpPermission(); permission.setIpProtocol("tcp"); permission.setFromPort(80); permission.setToPort(80); List<String> ipRanges = new ArrayList<String>(); ipRanges.add("0.0.0.0/0"); permission.setIpRanges(ipRanges); /*************the property of SSH**********************/ IpPermission permission1 = new IpPermission(); permission1.setIpProtocol("tcp"); permission1.setFromPort(22); permission1.setToPort(22); List<String> ipRanges1 = new ArrayList<String>(); ipRanges1.add("0.0.0.0/22"); permission1.setIpRanges(ipRanges1); /*************the property of https**********************/ IpPermission permission2 = new IpPermission(); permission2.setIpProtocol("tcp"); permission2.setFromPort(443); permission2.setToPort(443); List<String> ipRanges2 = new ArrayList<String>(); ipRanges2.add("0.0.0.0/0"); permission2.setIpRanges(ipRanges2); /*************the property of tcp**********************/ IpPermission permission3 = new IpPermission(); permission3.setIpProtocol("tcp"); permission3.setFromPort(0); permission3.setToPort(65535); List<String> ipRanges3 = new ArrayList<String>(); ipRanges3.add("0.0.0.0/0"); permission3.setIpRanges(ipRanges3); /**********************add rules to the group*********************/ List<IpPermission> permissions = new ArrayList<IpPermission>(); permissions.add(permission); permissions.add(permission1); permissions.add(permission2); permissions.add(permission3); r2.setIpPermissions(permissions); ec2.authorizeSecurityGroupIngress(r2); List<String> groupName = new ArrayList<String>(); groupName.add(Temp_Group);//wait to out our instance into this group /********************************************* * * #6.2 Create a New Key Pair * *********************************************/ CreateKeyPairRequest newKeyRequest = new CreateKeyPairRequest(); newKeyRequest.setKeyName("Test_Key2"); CreateKeyPairResult keyresult = ec2.createKeyPair(newKeyRequest); /************************print the properties of this key*****************/ KeyPair kp = new KeyPair(); kp = keyresult.getKeyPair(); System.out.println("The key we created is = " + kp.getKeyName() + "\nIts fingerprint is=" + kp.getKeyFingerprint() + "\nIts material is= \n" + kp.getKeyMaterial()); String fileName = "C:/Users/Akhil/workspace/Test_Key2.pem"; File distFile = new File(fileName); BufferedReader bufferedReader = new BufferedReader(new StringReader(kp.getKeyMaterial())); BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(distFile)); char buf[] = new char[1024]; int len; while ((len = bufferedReader.read(buf)) != -1) { bufferedWriter.write(buf, 0, len); } bufferedWriter.flush(); bufferedReader.close(); bufferedWriter.close(); //String myinstance; /********************************************* * * #6 Create an Instance * *********************************************/ System.out.println("#5 Create an Instance"); String imageId = "ami-76f0061f"; //Basic 32-bit Amazon Linux AMI int minInstanceCount = 1; // create 1 instance int maxInstanceCount = 1; RunInstancesRequest rir = new RunInstancesRequest(imageId, minInstanceCount, maxInstanceCount); rir.setKeyName("Test_Key2"); rir.withSecurityGroups("Testgroup1"); RunInstancesResult result = ec2.runInstances(rir); //get instanceId from the result List<Instance> resultInstance = result.getReservation().getInstances(); String createdInstanceId = null; String myAvailabilityZone = null; for (Instance ins : resultInstance) { createdInstanceId = ins.getInstanceId(); System.out.println("New instance has been created: " + ins.getInstanceId()); //myinstance = ins.getInstanceId(); } Thread.currentThread().sleep(60000); /********************************************* * * * Create a New Volume and attach it * ***********************************************/ List<Instance> resultInstance2 = result.getReservation().getInstances(); createdInstanceId = null; for (Instance ins : resultInstance2) { createdInstanceId = ins.getInstanceId(); System.out.println("New instance has been created: " + ins.getInstanceId());//print the instance ID /********************************************* * * #6.4 Create an Instance * *********************************************/ CreateVolumeRequest newVol = new CreateVolumeRequest(1, "us-east-1a"); CreateVolumeResult volresult = ec2.createVolume(newVol); Volume vol1 = volresult.getVolume(); String volId = vol1.getVolumeId(); Thread.currentThread().sleep(30000); AttachVolumeRequest attachRequest = new AttachVolumeRequest().withInstanceId(createdInstanceId) .withVolumeId(volId); attachRequest.withDevice("/dev/sda5"); ec2.attachVolume(attachRequest); System.out.println("EBS volume has been attached and the volume ID is: " + volId); } /********************************************* * * #7 Create a 'tag' for the new instance. * *********************************************/ System.out.println("#6 Create a 'tag' for the new instance."); List<String> resources = new LinkedList<String>(); List<Tag> tags = new LinkedList<Tag>(); Tag nameTag = new Tag("Akhil", "MyFirstInstance"); resources.add(createdInstanceId); tags.add(nameTag); CreateTagsRequest ctr = new CreateTagsRequest(resources, tags); ec2.createTags(ctr); /********************************************* * * #8 Stop/Start an Instance * *********************************************/ System.out.println("#7 Stop the Instance"); List<String> instanceIds = new LinkedList<String>(); instanceIds.add(createdInstanceId); //stop StopInstancesRequest stopIR = new StopInstancesRequest(instanceIds); ec2.stopInstances(stopIR); //start StartInstancesRequest startIR = new StartInstancesRequest(instanceIds); ec2.startInstances(startIR); System.out.println("#8 Getting DNS, IP."); DescribeInstancesRequest request = new DescribeInstancesRequest(); request.setInstanceIds(instanceIds); DescribeInstancesResult result1 = ec2.describeInstances(request); List<Reservation> reservations1 = result1.getReservations(); List<Instance> instances1; for (Reservation res : reservations1) { instances1 = res.getInstances(); for (Instance ins1 : instances1) { System.out .println("The public DNS is: " + ins1.getPublicDnsName() + "\n" + ins1.getRamdiskId()); System.out.println("The private IP is: " + ins1.getPrivateIpAddress()); System.out.println("The public IP is: " + ins1.getPublicIpAddress()); } /********************************************* * #10 Terminate an Instance * *********************************************/ System.out.println("#8 Terminate the Instance"); TerminateInstancesRequest tir = new TerminateInstancesRequest(instanceIds); //ec2.terminateInstances(tir); /********************************************* * * #11 shutdown client object * *********************************************/ ec2.shutdown(); } } catch (AmazonServiceException ase) { System.out.println("Caught Exception: " + ase.getMessage()); System.out.println("Reponse Status Code: " + ase.getStatusCode()); System.out.println("Error Code: " + ase.getErrorCode()); System.out.println("Request ID: " + ase.getRequestId()); } }
From source file:virtualIT.java
License:Open Source License
private void defaultVolumeRequest(int userId) { String instanceId = null;//from w w w. jav a 2 s . c o m String volumeId; DescribeVolumesResult describeVolumeResult = ec2.describeVolumes(); List<Volume> volumeData = describeVolumeResult.getVolumes(); for (Volume item : volumeData) { volumeId = item.getVolumeId(); List<VolumeAttachment> volumeAttachment = item.getAttachments(); for (VolumeAttachment data : volumeAttachment) { instanceId = data.getInstanceId(); } //instanceIdList.add(instanceId); rootvolumeIdList.add(volumeId); mapUserRootVol.put(userId, volumeId); } }
From source file:EbsAttach.java
License:Open Source License
public static void main(String[] args) throws Exception { init();/* w ww . j a v a 2 s . c o m*/ try { DescribeAvailabilityZonesResult availabilityZonesResult = ec2.describeAvailabilityZones(); System.out.println("You have access to " + availabilityZonesResult.getAvailabilityZones().size() + " Availability Zones."); DescribeInstancesResult describeInstancesRequest = ec2.describeInstances(); List<Reservation> reservations = describeInstancesRequest.getReservations(); Set<Instance> instances = new HashSet<Instance>(); for (Reservation reservation : reservations) { instances.addAll(reservation.getInstances()); } System.out.println("You have " + instances.size() + " Amazon EC2 instance(s) running."); for (Instance ins : instances) { // instance id String instanceId = ins.getInstanceId(); // instance state InstanceState is = ins.getState(); System.out.println(instanceId + " " + is.getName()); } System.out.println("Attached Instance id: " + attachedInsId); /********************************************* * * #1 Create New Volume * *********************************************/ System.out.println("==========================================="); System.out.println("#1 Volume State before Creating"); System.out.println("==========================================="); DescribeVolumesResult describeVolumesResult = ec2.describeVolumes(); List<Volume> volumes = describeVolumesResult.getVolumes(); for (Volume volume : volumes) { String volumeId = volume.getVolumeId(); String volumeAvbZone = volume.getAvailabilityZone(); String volumeSize = String.valueOf(volume.getSize()); String volumeState = volume.getState(); System.out.println(volumeId + "\t" + volumeSize + "\t" + volumeAvbZone + "\t" + volumeState); } CreateVolumeRequest createVolumeRequest = new CreateVolumeRequest().withSize(4).withVolumeType("gp2") .withAvailabilityZone("us-east-1a"); CreateVolumeResult createVolumeResult = ec2.createVolume(createVolumeRequest); String createdVolumeId = createVolumeResult.getVolume().getVolumeId(); System.out.println("# Created a volume # ID: " + createdVolumeId); /********************************************* * * #2 Attach the created new Volume * *********************************************/ System.out.println("==========================================="); System.out.println("#2 Volume State after Creating"); System.out.println("==========================================="); describeVolumesResult = ec2.describeVolumes(); volumes = describeVolumesResult.getVolumes(); for (Volume volume : volumes) { String volumeId = volume.getVolumeId(); String volumeAvbZone = volume.getAvailabilityZone(); String volumeSize = String.valueOf(volume.getSize()); String volumeState = volume.getState(); System.out.println(volumeId + "\t" + volumeSize + "\t" + volumeAvbZone + "\t" + volumeState); } //wait new volume is available System.out.println("# Waiting new Volume is available"); boolean avail = false; while (true) { Thread.sleep(1000); describeVolumesResult = ec2.describeVolumes(); volumes = describeVolumesResult.getVolumes(); for (Volume volume : volumes) { if (volume.getVolumeId().equals(createdVolumeId) && volume.getState().equals("available")) { avail = true; break; } } if (avail) break; } System.out.println("New Volume is available now."); AttachVolumeRequest attachVolumeRequest = new AttachVolumeRequest().withVolumeId(createdVolumeId) .withInstanceId(attachedInsId).withDevice("/dev/sdn"); AttachVolumeResult attachVolumeResult = ec2.attachVolume(attachVolumeRequest); VolumeAttachment volumeAttachment = attachVolumeResult.getAttachment(); System.out.println( volumeAttachment.getVolumeId() + " is attached on " + volumeAttachment.getAttachTime()); /********************************************* * * #3 SSh to instance and run command * *********************************************/ System.out.println("==========================================="); System.out.println("#2 Ssh and mount disk"); System.out.println("==========================================="); Session session = null; Channel openChannel = null; String keyDir = KEYDIR; String user = "ec2-user"; String host = publicDNSName; String command = "df -h;" + "sudo mkfs -t ext3 /dev/xvdn;" + "sudo mkdir /minihw3;" + "sudo mount /dev/xvdn /minihw3;" + "df -h"; boolean isConnect = false; while (!isConnect) { JSch jsch = new JSch(); System.out.println("Waiting 5 seconds for SSH being available."); Thread.sleep(5 * 1000); try { jsch.addIdentity(keyDir); } catch (JSchException e) { System.out.println(e.getMessage()); } try { session = jsch.getSession(user, host, 22); Properties config = new Properties(); config.put("StrictHostKeyChecking", "no"); session.setConfig(config); session.connect(); System.out.println("SSH Connection Established."); isConnect = true; openChannel = session.openChannel("exec"); ((ChannelExec) openChannel).setPty(true); ((ChannelExec) openChannel).setCommand(command); openChannel.setInputStream(null); ((ChannelExec) openChannel).setErrStream(System.err); int exitStatus = openChannel.getExitStatus(); System.out.println("exit-status: " + exitStatus); InputStream in = openChannel.getInputStream(); System.out.println("Exxcute remote cammand :" + command); openChannel.connect(); byte[] tmp = new byte[1024]; while (true) { while (in.available() > 0) { int i = in.read(tmp, 0, 1024); if (i < 0) break; System.out.print(new String(tmp, 0, i)); } if (openChannel.isClosed()) { if (in.available() > 0) continue; System.out.println("exit-status: " + openChannel.getExitStatus()); break; } try { Thread.sleep(1000); } catch (Exception ee) { } } } catch (JSchException | IOException e) { System.out.println(e.getMessage()); } finally { if (openChannel != null && !openChannel.isClosed()) { openChannel.disconnect(); System.out.println("Channel Disconnected"); } if (session != null && session.isConnected()) { session.disconnect(); System.out.println("Session Disconnected"); } } } } catch (AmazonServiceException ase) { System.out.println("Caught Exception: " + ase.getMessage()); System.out.println("Reponse Status Code: " + ase.getStatusCode()); System.out.println("Error Code: " + ase.getErrorCode()); System.out.println("Request ID: " + ase.getRequestId()); } }
From source file:com.cloudera.director.aws.ec2.ebs.EBSAllocator.java
License:Apache License
/** * Waits for the volumes in a list of {@code InstanceEbsVolumes} to reach an available state. * Returns an updated list of {@code InstanceEbsVolumes} with the volumes that became * available marked as AVAILABLE and volumes that failed or timed out marked as FAILED. * * @param createdInstanceVolumes list of instances with their created ebs volumes * @return updated list of instances EBS volumes *///from w w w. j ava 2 s.com public List<InstanceEbsVolumes> waitUntilVolumesAvailable(List<InstanceEbsVolumes> createdInstanceVolumes) throws InterruptedException { Set<String> volumesToCheck = getAllVolumeIdsWithStatus(createdInstanceVolumes, InstanceEbsVolumes.Status.CREATED); int numRequestedVolumes = volumesToCheck.size(); Set<String> volumesAvailable = Sets.newHashSetWithExpectedSize(numRequestedVolumes); if (numRequestedVolumes > 0) { LOG.info("Waiting for a maximum of {} seconds for volumes to become available", availableTimeoutSeconds); Stopwatch watch = Stopwatch.createStarted(); while (watch.elapsed(TimeUnit.SECONDS) < availableTimeoutSeconds) { DescribeVolumesRequest volumeRequest = new DescribeVolumesRequest().withVolumeIds(volumesToCheck); try { List<Volume> volumes = client.describeVolumes(volumeRequest).getVolumes(); for (Volume volume : volumes) { String id = volume.getVolumeId(); VolumeState state = VolumeState.fromValue(volume.getState()); switch (state) { case Creating: break; case Available: volumesToCheck.remove(id); volumesAvailable.add(id); break; case Error: // TODO log why the volume failed which may need a separate api call volumesToCheck.remove(id); break; default: String err = String .format("A requested volume went into an unexpected state %s while waiting " + "for volume to become available", state); throw new IllegalStateException(String.format(err, state)); } } if (volumesToCheck.isEmpty()) { break; } } catch (AmazonServiceException ex) { // ignore exception when volume isn't found, newly created volumes may not be found right away if (ex.getErrorCode().equals("InvalidVolume.NotFound")) { LOG.info("Requested volume(s) not yet found"); } else { throw AWSExceptions.propagate(ex); } } LOG.info("Waiting on {} out of {} volumes to reach a final state, next check in {} seconds", volumesToCheck.size(), numRequestedVolumes, WAIT_UNTIL_AVAILABLE_INTERVAL_SECONDS); TimeUnit.SECONDS.sleep(WAIT_UNTIL_AVAILABLE_INTERVAL_SECONDS); } if (volumesToCheck.size() > 0) { LOG.error( "Timed out while waiting for volumes to be created, {} out of {} volumes became available", volumesAvailable.size(), numRequestedVolumes); } } else { LOG.info("Skipping wait for availability because no EBS volumes were created"); } // Update the status of each volume to AVAILABLE or FAILED based on the result List<InstanceEbsVolumes> updated = Lists.newArrayList(); for (InstanceEbsVolumes instanceEbsVolumes : createdInstanceVolumes) { Map<String, InstanceEbsVolumes.Status> updatedVolumes = Maps.newHashMap(); for (String volumeId : instanceEbsVolumes.getVolumeStatuses().keySet()) { InstanceEbsVolumes.Status updatedStatus = volumesAvailable.contains(volumeId) ? InstanceEbsVolumes.Status.AVAILABLE : InstanceEbsVolumes.Status.FAILED; updatedVolumes.put(volumeId, updatedStatus); } updated.add(new InstanceEbsVolumes(instanceEbsVolumes.getVirtualInstanceId(), instanceEbsVolumes.getEc2InstanceId(), updatedVolumes)); } return updated; }
From source file:com.cloudera.director.aws.ec2.ebs.EBSAllocator.java
License:Apache License
/** * Wait for the specified list of volumes to be attached within a timeout. * * @param volumeIds collection of volume ids to wait for * @return collection of volumes that were successfully attached * @throws InterruptedException if the operation is interrupted *//*from w w w . j a v a 2s . com*/ private Collection<String> waitUntilVolumesAttached(Collection<String> volumeIds) throws InterruptedException { checkNotNull(volumeIds); if (volumeIds.isEmpty()) { LOG.info("No volumes are being attached, skipping wait"); return Collections.emptySet(); } Set<String> unattachedVolumes = Sets.newHashSet(volumeIds); Set<String> attachedVolumes = Sets.newHashSet(); LOG.info("Waiting for a maximum of {} seconds for volumes to be attached", attachTimeoutSeconds); Stopwatch watch = Stopwatch.createStarted(); while (watch.elapsed(TimeUnit.SECONDS) < attachTimeoutSeconds) { DescribeVolumesRequest volumeRequest = new DescribeVolumesRequest().withVolumeIds(unattachedVolumes); List<Volume> volumes = client.describeVolumes(volumeRequest).getVolumes(); for (Volume volume : volumes) { VolumeAttachment attachment = Iterables.getOnlyElement(volume.getAttachments()); VolumeAttachmentState state = VolumeAttachmentState.fromValue(attachment.getState()); if (state == VolumeAttachmentState.Attached) { unattachedVolumes.remove(volume.getVolumeId()); attachedVolumes.add(volume.getVolumeId()); } } if (unattachedVolumes.isEmpty()) { return attachedVolumes; } LOG.info("Waiting on {} out of {} volumes to be attached, next check in {} seconds", unattachedVolumes.size(), volumeIds.size(), WAIT_UNTIL_ATTACHED_INTERVAL_SECONDS); TimeUnit.SECONDS.sleep(WAIT_UNTIL_ATTACHED_INTERVAL_SECONDS); } LOG.error("Timed out while waiting for all volumes to be attached, {} out of {} volumes were attached", attachedVolumes.size(), volumeIds.size()); return attachedVolumes; }
From source file:com.eucalyptus.tests.awssdk.CloudCleaner.java
License:Open Source License
@Test public void clean() throws Exception { testInfo(this.getClass().getSimpleName()); getCloudInfo();/* w w w .j av a 2 s . c o m*/ //Terminate All instances List<String> instancesToTerminate = new ArrayList<String>(); DescribeInstancesResult result = ec2.describeInstances(); List<Reservation> reservations = result.getReservations(); if (reservations.size() > 0) { print("Found instances to terminate"); for (Reservation reservation : reservations) { List<Instance> instances = reservation.getInstances(); for (Instance instance : instances) { print("Terminating: " + instance.getInstanceId()); instancesToTerminate.add(instance.getInstanceId()); } } TerminateInstancesRequest term = new TerminateInstancesRequest(); term.setInstanceIds(instancesToTerminate); ec2.terminateInstances(term); } else { print("No instances found"); } // delete all keypairs if (getKeyPairCount() > 0) { print("Found Keypairs to delete"); DescribeKeyPairsResult describeKeyPairsResult = ec2.describeKeyPairs(); for (KeyPairInfo keypair : describeKeyPairsResult.getKeyPairs()) { deleteKeyPair(keypair.getKeyName()); } } else { print("No keypairs found"); } // delete all groups except default group List<SecurityGroup> groups = describeSecurityGroups(); if (groups.size() > 1) { print("Found security groups to delete"); for (SecurityGroup group : groups) { if (!group.getGroupName().equals("default")) { deleteSecurityGroup(group.getGroupName()); } } } else { print("No Security Groups found (other than default)"); } // delete all policies List<ScalingPolicy> policies = describePolicies(); if (policies.size() > 0) { print("Found Policies to delete"); for (ScalingPolicy policy : policies) { deletePolicy(policy.getPolicyName()); } } else { print("No auto scaling policies found"); } // delete launch configs List<LaunchConfiguration> lcs = describeLaunchConfigs(); if (lcs.size() > 0) { print("Found Launch Configs to delete"); for (LaunchConfiguration lc : lcs) { deleteLaunchConfig(lc.getLaunchConfigurationName()); } } else { print("No launch configs found"); } // delete autoscaling groups List<AutoScalingGroup> asGroups = describeAutoScalingGroups(); if (asGroups.size() > 0) { print("Found Auto Scaling Groups to delete"); for (AutoScalingGroup asg : asGroups) { deleteAutoScalingGroup(asg.getAutoScalingGroupName(), true); } } else { print("No auto scaling groups found"); } // delete volumes List<Volume> volumes = ec2.describeVolumes().getVolumes(); if (volumes.size() > 0) { print("Found volumes to delete"); for (Volume vol : volumes) { deleteVolume(vol.getVolumeId()); } } else { print("No volumes found"); } //delete snapshots List<Snapshot> snapshots = ec2.describeSnapshots().getSnapshots(); if (snapshots.size() > 0) { print("Found snapshots to delete"); for (Snapshot snap : snapshots) { deleteSnapshot(snap.getSnapshotId()); } } else { print("No volumes found"); } }
From source file:com.liferay.amazontools.AMICleaner.java
License:Open Source License
protected void deleteAvailableVolumes() { DescribeVolumesRequest describeVolumesRequest = new DescribeVolumesRequest(); Filter filter = new Filter(); filter.setName("status"); filter.withValues("available"); describeVolumesRequest.withFilters(filter); DescribeVolumesResult describeVolumesResult = amazonEC2Client.describeVolumes(describeVolumesRequest); List<Volume> volumes = describeVolumesResult.getVolumes(); for (int i = 0; i < volumes.size(); i++) { DeleteVolumeRequest deleteVolumeRequest = new DeleteVolumeRequest(); Volume volume = volumes.get(i); deleteVolumeRequest.setVolumeId(volume.getVolumeId()); amazonEC2Client.deleteVolume(deleteVolumeRequest); }/* ww w . j av a2 s . co m*/ }
From source file:com.netflix.edda.EddaEc2Client.java
License:Apache License
public DescribeVolumesResult describeVolumes(DescribeVolumesRequest request) { validateEmpty("Filter", request.getFilters()); TypeReference<List<Volume>> ref = new TypeReference<List<Volume>>() { };/* w w w .j a v a 2 s. co m*/ String url = config.url() + "/api/v2/aws/volumes;_expand"; try { List<Volume> volumes = parse(ref, doGet(url)); List<String> ids = request.getVolumeIds(); if (shouldFilter(ids)) { List<Volume> vs = new ArrayList<Volume>(); for (Volume v : volumes) { if (matches(ids, v.getVolumeId())) vs.add(v); } volumes = vs; } return new DescribeVolumesResult().withVolumes(volumes); } catch (IOException e) { throw new AmazonClientException("Faled to parse " + url, e); } }
From source file:com.netflix.simianarmy.aws.janitor.crawler.EBSVolumeJanitorCrawler.java
License:Apache License
private List<Resource> getVolumeResources(String... volumeIds) { List<Resource> resources = new LinkedList<Resource>(); AWSClient awsClient = getAWSClient(); for (Volume volume : awsClient.describeVolumes(volumeIds)) { Resource volumeResource = new AWSResource().withId(volume.getVolumeId()) .withRegion(getAWSClient().region()).withResourceType(AWSResourceType.EBS_VOLUME) .withLaunchTime(volume.getCreateTime()); for (Tag tag : volume.getTags()) { LOGGER.info(String.format("Adding tag %s = %s to resource %s", tag.getKey(), tag.getValue(), volumeResource.getId())); volumeResource.setTag(tag.getKey(), tag.getValue()); }/*from ww w . j a v a 2 s . c o m*/ volumeResource.setOwnerEmail(getOwnerEmailForResource(volumeResource)); volumeResource.setDescription(getVolumeDescription(volume)); ((AWSResource) volumeResource).setAWSResourceState(volume.getState()); resources.add(volumeResource); } return resources; }