Java tutorial
// // typica - A client library for Amazon Web Services // Copyright (C) 2007 Xerox Corporation // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // package com.xerox.amazonws.ec2; import java.io.BufferedReader; import java.io.ByteArrayInputStream; import java.io.File; import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.StringWriter; import java.net.MalformedURLException; import java.net.URL; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import javax.xml.bind.JAXBException; import org.apache.commons.codec.binary.Base64; import org.apache.commons.httpclient.HttpException; import org.apache.commons.httpclient.methods.GetMethod; import org.apache.commons.httpclient.methods.PostMethod; import org.apache.commons.httpclient.methods.StringRequestEntity; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import com.xerox.amazonws.typica.jaxb.AllocateAddressResponse; import com.xerox.amazonws.typica.jaxb.AssociateAddressResponse; import com.xerox.amazonws.typica.jaxb.AvailabilityZoneItemType; import com.xerox.amazonws.typica.jaxb.AvailabilityZoneSetType; import com.xerox.amazonws.typica.jaxb.AuthorizeSecurityGroupIngressResponse; import com.xerox.amazonws.typica.jaxb.BlockDeviceMappingType; import com.xerox.amazonws.typica.jaxb.BlockDeviceMappingItemType; import com.xerox.amazonws.typica.jaxb.CreateKeyPairResponse; import com.xerox.amazonws.typica.jaxb.ConfirmProductInstanceResponse; import com.xerox.amazonws.typica.jaxb.CreateSecurityGroupResponse; import com.xerox.amazonws.typica.jaxb.DeleteKeyPairResponse; import com.xerox.amazonws.typica.jaxb.DeleteSecurityGroupResponse; import com.xerox.amazonws.typica.jaxb.DescribeAddressesResponse; import com.xerox.amazonws.typica.jaxb.DescribeAddressesResponseInfoType; import com.xerox.amazonws.typica.jaxb.DescribeAddressesResponseItemType; import com.xerox.amazonws.typica.jaxb.DescribeAvailabilityZonesResponse; import com.xerox.amazonws.typica.jaxb.DeregisterImageResponse; import com.xerox.amazonws.typica.jaxb.DescribeImageAttributeResponse; import com.xerox.amazonws.typica.jaxb.DescribeImagesResponse; import com.xerox.amazonws.typica.jaxb.DescribeImagesResponseInfoType; import com.xerox.amazonws.typica.jaxb.DescribeImagesResponseItemType; import com.xerox.amazonws.typica.jaxb.DescribeInstancesResponse; import com.xerox.amazonws.typica.jaxb.DescribeKeyPairsResponse; import com.xerox.amazonws.typica.jaxb.DescribeKeyPairsResponseInfoType; import com.xerox.amazonws.typica.jaxb.DescribeKeyPairsResponseItemType; import com.xerox.amazonws.typica.jaxb.DescribeSecurityGroupsResponse; import com.xerox.amazonws.typica.jaxb.DisassociateAddressResponse; import com.xerox.amazonws.typica.jaxb.GetConsoleOutputResponse; import com.xerox.amazonws.typica.jaxb.GroupItemType; import com.xerox.amazonws.typica.jaxb.GroupSetType; import com.xerox.amazonws.typica.jaxb.IpPermissionSetType; import com.xerox.amazonws.typica.jaxb.IpPermissionSetType; import com.xerox.amazonws.typica.jaxb.IpPermissionType; import com.xerox.amazonws.typica.jaxb.IpRangeItemType; import com.xerox.amazonws.typica.jaxb.IpRangeSetType; import com.xerox.amazonws.typica.jaxb.LaunchPermissionItemType; import com.xerox.amazonws.typica.jaxb.LaunchPermissionListType; import com.xerox.amazonws.typica.jaxb.ModifyImageAttributeResponse; import com.xerox.amazonws.typica.jaxb.NullableAttributeValueType; import com.xerox.amazonws.typica.jaxb.ObjectFactory; import com.xerox.amazonws.typica.jaxb.ProductCodeListType; import com.xerox.amazonws.typica.jaxb.ProductCodeItemType; import com.xerox.amazonws.typica.jaxb.ProductCodesSetType; import com.xerox.amazonws.typica.jaxb.ProductCodesSetItemType; import com.xerox.amazonws.typica.jaxb.RebootInstancesResponse; import com.xerox.amazonws.typica.jaxb.RegisterImageResponse; import com.xerox.amazonws.typica.jaxb.ReleaseAddressResponse; import com.xerox.amazonws.typica.jaxb.RevokeSecurityGroupIngressResponse; import com.xerox.amazonws.typica.jaxb.ReservationSetType; import com.xerox.amazonws.typica.jaxb.ResetImageAttributeResponse; import com.xerox.amazonws.typica.jaxb.RunningInstancesItemType; import com.xerox.amazonws.typica.jaxb.RunningInstancesSetType; import com.xerox.amazonws.typica.jaxb.RunInstancesResponse; import com.xerox.amazonws.typica.jaxb.SecurityGroupSetType; import com.xerox.amazonws.typica.jaxb.SecurityGroupItemType; import com.xerox.amazonws.typica.jaxb.TerminateInstancesResponse; import com.xerox.amazonws.typica.jaxb.TerminateInstancesResponseInfoType; import com.xerox.amazonws.typica.jaxb.TerminateInstancesResponseItemType; import com.xerox.amazonws.typica.jaxb.UserIdGroupPairType; import com.xerox.amazonws.typica.jaxb.UserIdGroupPairSetType; import com.xerox.amazonws.common.AWSQueryConnection; /** * A Java wrapper for the EC2 web services API */ public class Jec2 extends AWSQueryConnection { private static Log logger = LogFactory.getLog(Jec2.class); /** * Initializes the ec2 service with your AWS login information. * * @param awsAccessId The your user key into AWS * @param awsSecretKey The secret string used to generate signatures for authentication. */ public Jec2(String awsAccessId, String awsSecretKey) { this(awsAccessId, awsSecretKey, true); } /** * Initializes the ec2 service with your AWS login information. * * @param awsAccessId The your user key into AWS * @param awsSecretKey The secret string used to generate signatures for authentication. * @param isSecure True if the data should be encrypted on the wire on the way to or from EC2. */ public Jec2(String awsAccessId, String awsSecretKey, boolean isSecure) { this(awsAccessId, awsSecretKey, isSecure, "ec2.amazonaws.com"); } /** * Initializes the ec2 service with your AWS login information. * * @param awsAccessId The your user key into AWS * @param awsSecretKey The secret string used to generate signatures for authentication. * @param isSecure True if the data should be encrypted on the wire on the way to or from EC2. * @param server Which host to connect to. Usually, this will be ec2.amazonaws.com */ public Jec2(String awsAccessId, String awsSecretKey, boolean isSecure, String server) { this(awsAccessId, awsSecretKey, isSecure, server, isSecure ? 443 : 80); } /** * Initializes the ec2 service with your AWS login information. * * @param awsAccessId The your user key into AWS * @param awsSecretKey The secret string used to generate signatures for authentication. * @param isSecure True if the data should be encrypted on the wire on the way to or from EC2. * @param server Which host to connect to. Usually, this will be ec2.amazonaws.com * @param port Which port to use. */ public Jec2(String awsAccessId, String awsSecretKey, boolean isSecure, String server, int port) { super(awsAccessId, awsSecretKey, isSecure, server, port); ArrayList vals = new ArrayList(); vals.add("2008-02-01"); super.headers.put("Version", vals); } /** * Register the given AMI. * * @param imageLocation An AMI path within S3. * @return A unique AMI ID that can be used to create and manage instances of this AMI. * @throws EC2Exception wraps checked exceptions */ public String registerImage(String imageLocation) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); params.put("ImageLocation", imageLocation); GetMethod method = new GetMethod(); try { RegisterImageResponse response = makeRequest(method, "RegisterImage", params, RegisterImageResponse.class); return response.getImageId(); } catch (JAXBException ex) { throw new EC2Exception("Problem parsing returned message.", ex); } catch (MalformedURLException ex) { throw new EC2Exception(ex.getMessage(), ex); } catch (IOException ex) { throw new EC2Exception(ex.getMessage(), ex); } finally { method.releaseConnection(); } } /** * Deregister the given AMI. * * @param imageId An AMI ID as returned by {@link #registerImage(String)}. * @throws EC2Exception wraps checked exceptions */ public void deregisterImage(String imageId) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); params.put("ImageId", imageId); GetMethod method = new GetMethod(); try { DeregisterImageResponse response = makeRequest(method, "DeregisterImage", params, DeregisterImageResponse.class); if (!response.isReturn()) { throw new EC2Exception("Could not deregister image : " + imageId + ". No reason given."); } } catch (JAXBException ex) { throw new EC2Exception("Problem parsing returned message.", ex); } catch (MalformedURLException ex) { throw new EC2Exception(ex.getMessage(), ex); } catch (IOException ex) { throw new EC2Exception(ex.getMessage(), ex); } finally { method.releaseConnection(); } } /** * Describe the given AMIs. * * @param imageIds An array of AMI IDs as returned by {@link #registerImage(String)}. * @return A list of {@link ImageDescription} instances describing each AMI ID. * @throws EC2Exception wraps checked exceptions */ public List<ImageDescription> describeImages(String[] imageIds) throws EC2Exception { return describeImages(Arrays.asList(imageIds)); } /** * Describe the given AMIs. * * @param imageIds A list of AMI IDs as returned by {@link #registerImage(String)}. * @return A list of {@link ImageDescription} instances describing each AMI ID. * @throws EC2Exception wraps checked exceptions */ public List<ImageDescription> describeImages(List<String> imageIds) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); for (int i = 0; i < imageIds.size(); i++) { params.put("ImageId." + (i + 1), imageIds.get(i)); } return describeImages(params); } /** * Describe the AMIs belonging to the supplied owners. * * @param owners A list of owners. * @return A list of {@link ImageDescription} instances describing each AMI ID. * @throws EC2Exception wraps checked exceptions */ public List<ImageDescription> describeImagesByOwner(List<String> owners) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); for (int i = 0; i < owners.size(); i++) { params.put("Owner." + (i + 1), owners.get(i)); } return describeImages(params); } /** * Describe the AMIs executable by supplied users. * * @param users A list of users. * @return A list of {@link ImageDescription} instances describing each AMI ID. * @throws EC2Exception wraps checked exceptions */ public List<ImageDescription> describeImagesByExecutability(List<String> users) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); for (int i = 0; i < users.size(); i++) { params.put("ExecutableBy." + (i + 1), users.get(i)); } return describeImages(params); } /** * Describe the AMIs image type (machine, kernel, ramdisk). * * @param type An image type. * @return A list of {@link ImageDescription} instances describing each AMI ID. * @throws EC2Exception wraps checked exceptions */ public List<ImageDescription> describeImagesByImageType(ImageType type) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); params.put("ImageType", type.getTypeId()); return describeImages(params); } /** * Describe the AMIs that match the intersection of the criteria supplied * * @param imageIds A list of AMI IDs as returned by {@link #registerImage(String)}. * @param owners A list of owners. * @param users A list of users. * @param type An image type. * @return A list of {@link ImageDescription} instances describing each AMI ID. * @throws EC2Exception wraps checked exceptions */ public List<ImageDescription> describeImages(List<String> imageIds, List<String> owners, List<String> users, ImageType type) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); for (int i = 0; i < imageIds.size(); i++) { params.put("ImageId." + (i + 1), imageIds.get(i)); } for (int i = 0; i < owners.size(); i++) { params.put("Owner." + (i + 1), owners.get(i)); } for (int i = 0; i < users.size(); i++) { params.put("ExecutableBy." + (i + 1), users.get(i)); } if (type != null) { params.put("ImageType", type.getTypeId()); } return describeImages(params); } protected List<ImageDescription> describeImages(Map<String, String> params) throws EC2Exception { GetMethod method = new GetMethod(); try { DescribeImagesResponse response = makeRequest(method, "DescribeImages", params, DescribeImagesResponse.class); List<ImageDescription> result = new ArrayList<ImageDescription>(); DescribeImagesResponseInfoType set = response.getImagesSet(); Iterator set_iter = set.getItems().iterator(); while (set_iter.hasNext()) { DescribeImagesResponseItemType item = (DescribeImagesResponseItemType) set_iter.next(); ArrayList<String> codes = new ArrayList<String>(); ProductCodesSetType code_set = item.getProductCodes(); if (code_set != null) { for (ProductCodesSetItemType code : code_set.getItems()) { codes.add(code.getProductCode()); } } result.add(new ImageDescription(item.getImageId(), item.getImageLocation(), item.getImageOwnerId(), item.getImageState(), item.isIsPublic(), codes)); } return result; } catch (JAXBException ex) { throw new EC2Exception("Problem parsing returned message.", ex); } catch (MalformedURLException ex) { throw new EC2Exception(ex.getMessage(), ex); } catch (IOException ex) { throw new EC2Exception(ex.getMessage(), ex); } finally { method.releaseConnection(); } } /** * Requests reservation of a number of instances. * <p> * This will begin launching those instances for which a reservation was * successfully obtained. * <p> * If less than <code>minCount</code> instances are available no instances * will be reserved. * <p> * NOTE: this method defaults to the AWS desired "public" addressing type. * NOTE: this method defaults to the small(traditional) instance type. * * @param imageId An AMI ID as returned by {@link #registerImage(String)}. * @param minCount The minimum number of instances to attempt to reserve. * @param maxCount The maximum number of instances to attempt to reserve. * @param groupSet A (possibly empty) set of security group definitions. * @param userData User supplied data that will be made available to the instance(s) * @return A {@link com.xerox.amazonws.ec2.ReservationDescription} describing the instances that * have been reserved. * @throws EC2Exception wraps checked exceptions */ public ReservationDescription runInstances(String imageId, int minCount, int maxCount, List<String> groupSet, String userData, String keyName) throws EC2Exception { return runInstances(imageId, minCount, maxCount, groupSet, userData, keyName, true, InstanceType.DEFAULT); } /** * Requests reservation of a number of instances. * <p> * This will begin launching those instances for which a reservation was * successfully obtained. * <p> * If less than <code>minCount</code> instances are available no instances * will be reserved. * NOTE: this method defaults to the small(traditional) instance type. * * @param imageId An AMI ID as returned by {@link #registerImage(String)}. * @param minCount The minimum number of instances to attempt to reserve. * @param maxCount The maximum number of instances to attempt to reserve. * @param groupSet A (possibly empty) set of security group definitions. * @param userData User supplied data that will be made available to the instance(s) * @param publicAddr sets addressing mode to public * @return A {@link com.xerox.amazonws.ec2.ReservationDescription} describing the instances that * have been reserved. * @throws EC2Exception wraps checked exceptions */ public ReservationDescription runInstances(String imageId, int minCount, int maxCount, List<String> groupSet, String userData, String keyName, boolean publicAddr) throws EC2Exception { return runInstances(imageId, minCount, maxCount, groupSet, userData, keyName, publicAddr, InstanceType.DEFAULT); } /** * Requests reservation of a number of instances. * <p> * This will begin launching those instances for which a reservation was * successfully obtained. * <p> * If less than <code>minCount</code> instances are available no instances * will be reserved. * NOTE: this method defaults to the AWS desired "public" addressing type. * * @param imageId An AMI ID as returned by {@link #registerImage(String)}. * @param minCount The minimum number of instances to attempt to reserve. * @param maxCount The maximum number of instances to attempt to reserve. * @param groupSet A (possibly empty) set of security group definitions. * @param userData User supplied data that will be made available to the instance(s) * @param type instance type * @return A {@link com.xerox.amazonws.ec2.ReservationDescription} describing the instances that * have been reserved. * @throws EC2Exception wraps checked exceptions */ public ReservationDescription runInstances(String imageId, int minCount, int maxCount, List<String> groupSet, String userData, String keyName, InstanceType type) throws EC2Exception { return runInstances(imageId, minCount, maxCount, groupSet, userData, keyName, true, type); } /** * Requests reservation of a number of instances. * <p> * This will begin launching those instances for which a reservation was * successfully obtained. * <p> * If less than <code>minCount</code> instances are available no instances * will be reserved. * * @param imageId An AMI ID as returned by {@link #registerImage(String)}. * @param minCount The minimum number of instances to attempt to reserve. * @param maxCount The maximum number of instances to attempt to reserve. * @param groupSet A (possibly empty) set of security group definitions. * @param userData User supplied data that will be made available to the instance(s) * @param publicAddr sets addressing mode to public * @param type instance type * @return A {@link com.xerox.amazonws.ec2.ReservationDescription} describing the instances that * have been reserved. * @throws EC2Exception wraps checked exceptions */ public ReservationDescription runInstances(String imageId, int minCount, int maxCount, List<String> groupSet, String userData, String keyName, boolean publicAddr, InstanceType type) throws EC2Exception { return runInstances(imageId, minCount, maxCount, groupSet, userData, keyName, publicAddr, type, null, null, null, null); } /** * Requests reservation of a number of instances. * <p> * This will begin launching those instances for which a reservation was * successfully obtained. * <p> * If less than <code>minCount</code> instances are available no instances * will be reserved. * * @param imageId An AMI ID as returned by {@link #registerImage(String)}. * @param minCount The minimum number of instances to attempt to reserve. * @param maxCount The maximum number of instances to attempt to reserve. * @param groupSet A (possibly empty) set of security group definitions. * @param userData User supplied data that will be made available to the instance(s) * @param publicAddr sets addressing mode to public * @param type instance type * @param availabilityZone the zone in which to launch the instance(s) * @param kernelId id of the kernel with which to launch the instance(s) * @param ramdiskId id of the RAM disk with wich to launch the imstance(s) * @param blockDeviceMappings mappings of virtual to device names * @return A {@link com.xerox.amazonws.ec2.ReservationDescription} describing the instances that * have been reserved. * @throws EC2Exception wraps checked exceptions */ public ReservationDescription runInstances(String imageId, int minCount, int maxCount, List<String> groupSet, String userData, String keyName, boolean publicAddr, InstanceType type, String availabilityZone, String kernelId, String ramdiskId, List<BlockDeviceMapping> blockDeviceMappings) throws EC2Exception { LaunchConfiguration lc = new LaunchConfiguration(imageId); lc.setMinCount(minCount); lc.setMaxCount(maxCount); lc.setSecurityGroup(groupSet); if (userData != null) { lc.setUserData(userData.getBytes()); } lc.setKeyName(keyName); lc.setInstanceType(type); lc.setAvailabilityZone(availabilityZone); lc.setKernelId(kernelId); lc.setRamdiskId(ramdiskId); lc.setBlockDevicemappings(blockDeviceMappings); return runInstances(lc); } /** * Requests reservation of a number of instances. * <p> * This will begin launching those instances for which a reservation was * successfully obtained. * <p> * If less than <code>minCount</code> instances are available no instances * will be reserved. * * @param lc object containing launch configuration * @return A {@link com.xerox.amazonws.ec2.ReservationDescription} describing the instances that * have been reserved. * @throws EC2Exception wraps checked exceptions */ public ReservationDescription runInstances(LaunchConfiguration lc) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); params.put("ImageId", lc.getImageId()); params.put("MinCount", "" + lc.getMinCount()); params.put("MaxCount", "" + lc.getMaxCount()); byte[] userData = lc.getUserData(); if (userData != null && userData.length > 0) { params.put("UserData", new String(Base64.encodeBase64(userData))); } params.put("AddressingType", "public"); String keyName = lc.getKeyName(); if (keyName != null && !keyName.trim().equals("")) { params.put("KeyName", keyName); } if (lc.getSecurityGroup() != null) { for (int i = 0; i < lc.getSecurityGroup().size(); i++) { params.put("SecurityGroup." + (i + 1), lc.getSecurityGroup().get(i)); } } params.put("InstanceType", lc.getInstanceType().getTypeId()); if (lc.getAvailabilityZone() != null && !lc.getAvailabilityZone().trim().equals("")) { params.put("Placement.AvailabilityZone", lc.getAvailabilityZone()); } if (lc.getKernelId() != null && !lc.getKernelId().trim().equals("")) { params.put("KernelId", lc.getKernelId()); } if (lc.getRamdiskId() != null && !lc.getRamdiskId().trim().equals("")) { params.put("RamdiskId", lc.getRamdiskId()); } if (lc.getBlockDevicemappings() != null) { for (int i = 0; i < lc.getBlockDevicemappings().size(); i++) { BlockDeviceMapping bdm = lc.getBlockDevicemappings().get(i); params.put("BlockDeviceMapping." + (i + 1) + ".VirtualName", bdm.getVirtualName()); params.put("BlockDeviceMapping." + (i + 1) + ".DeviceName", bdm.getDeviceName()); } } GetMethod method = new GetMethod(); try { RunInstancesResponse response = makeRequest(method, "RunInstances", params, RunInstancesResponse.class); ReservationDescription res = new ReservationDescription(response.getOwnerId(), response.getReservationId()); GroupSetType grp_set = response.getGroupSet(); Iterator groups_iter = grp_set.getItems().iterator(); while (groups_iter.hasNext()) { GroupItemType rsp_item = (GroupItemType) groups_iter.next(); res.addGroup(rsp_item.getGroupId()); } RunningInstancesSetType set = response.getInstancesSet(); Iterator instances_iter = set.getItems().iterator(); while (instances_iter.hasNext()) { RunningInstancesItemType rsp_item = (RunningInstancesItemType) instances_iter.next(); res.addInstance(rsp_item.getImageId(), rsp_item.getInstanceId(), rsp_item.getPrivateDnsName(), rsp_item.getDnsName(), rsp_item.getInstanceState(), rsp_item.getReason(), rsp_item.getKeyName(), rsp_item.getLaunchTime().toGregorianCalendar(), InstanceType.getTypeFromString(rsp_item.getInstanceType()), rsp_item.getPlacement().getAvailabilityZone(), rsp_item.getKernelId(), rsp_item.getRamdiskId()); } return res; } catch (JAXBException ex) { throw new EC2Exception("Problem parsing returned message.", ex); } catch (MalformedURLException ex) { throw new EC2Exception(ex.getMessage(), ex); } catch (IOException ex) { throw new EC2Exception(ex.getMessage(), ex); } finally { method.releaseConnection(); } } /** * Terminates a selection of running instances. * * @param instanceIds An array of instances ({@link com.xerox.amazonws.ec2.ReservationDescription.Instance#instanceId}. * @return A list of {@link TerminatingInstanceDescription} instances. * @throws EC2Exception wraps checked exceptions */ public List<TerminatingInstanceDescription> terminateInstances(String[] instanceIds) throws EC2Exception { return this.terminateInstances(Arrays.asList(instanceIds)); } /** * Terminates a selection of running instances. * * @param instanceIds A list of instances ({@link com.xerox.amazonws.ec2.ReservationDescription.Instance#instanceId}. * @return A list of {@link TerminatingInstanceDescription} instances. * @throws EC2Exception wraps checked exceptions */ public List<TerminatingInstanceDescription> terminateInstances(List<String> instanceIds) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); for (int i = 0; i < instanceIds.size(); i++) { params.put("InstanceId." + (i + 1), instanceIds.get(i)); } GetMethod method = new GetMethod(); try { TerminateInstancesResponse response = makeRequest(method, "TerminateInstances", params, TerminateInstancesResponse.class); response.getInstancesSet(); List<TerminatingInstanceDescription> res = new ArrayList<TerminatingInstanceDescription>(); TerminateInstancesResponseInfoType set = response.getInstancesSet(); Iterator instances_iter = set.getItems().iterator(); while (instances_iter.hasNext()) { TerminateInstancesResponseItemType rsp_item = (TerminateInstancesResponseItemType) instances_iter .next(); res.add(new TerminatingInstanceDescription(rsp_item.getInstanceId(), rsp_item.getPreviousState().getName(), rsp_item.getPreviousState().getCode(), rsp_item.getShutdownState().getName(), rsp_item.getShutdownState().getCode())); } return res; } catch (JAXBException ex) { throw new EC2Exception("Problem parsing returned message.", ex); } catch (MalformedURLException ex) { throw new EC2Exception(ex.getMessage(), ex); } catch (IOException ex) { throw new EC2Exception(ex.getMessage(), ex); } finally { method.releaseConnection(); } } /** * Gets a list of running instances. * <p> * If the array of instance IDs is empty then a list of all instances owned * by the caller will be returned. Otherwise the list will contain * information for the requested instances only. * * @param instanceIds An array of instances ({@link com.xerox.amazonws.ec2.ReservationDescription.Instance#instanceId}. * @return A list of {@link com.xerox.amazonws.ec2.ReservationDescription} instances. * @throws EC2Exception wraps checked exceptions */ public List<ReservationDescription> describeInstances(String[] instanceIds) throws EC2Exception { return this.describeInstances(Arrays.asList(instanceIds)); } /** * Gets a list of running instances. * <p> * If the list of instance IDs is empty then a list of all instances owned * by the caller will be returned. Otherwise the list will contain * information for the requested instances only. * * @param instanceIds A list of instances ({@link com.xerox.amazonws.ec2.ReservationDescription.Instance#instanceId}. * @return A list of {@link com.xerox.amazonws.ec2.ReservationDescription} instances. * @throws EC2Exception wraps checked exceptions */ public List<ReservationDescription> describeInstances(List<String> instanceIds) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); for (int i = 0; i < instanceIds.size(); i++) { params.put("InstanceId." + (i + 1), instanceIds.get(i)); } GetMethod method = new GetMethod(); try { DescribeInstancesResponse response = makeRequest(method, "DescribeInstances", params, DescribeInstancesResponse.class); List<ReservationDescription> result = new ArrayList<ReservationDescription>(); ReservationSetType res_set = response.getReservationSet(); Iterator reservations_iter = res_set.getItems().iterator(); while (reservations_iter.hasNext()) { RunInstancesResponse item = (RunInstancesResponse) reservations_iter.next(); ReservationDescription res = new ReservationDescription(item.getOwnerId(), item.getReservationId()); GroupSetType grp_set = item.getGroupSet(); Iterator groups_iter = grp_set.getItems().iterator(); while (groups_iter.hasNext()) { GroupItemType rsp_item = (GroupItemType) groups_iter.next(); res.addGroup(rsp_item.getGroupId()); } RunningInstancesSetType set = item.getInstancesSet(); Iterator instances_iter = set.getItems().iterator(); while (instances_iter.hasNext()) { RunningInstancesItemType rsp_item = (RunningInstancesItemType) instances_iter.next(); res.addInstance(rsp_item.getImageId(), rsp_item.getInstanceId(), rsp_item.getPrivateDnsName(), rsp_item.getDnsName(), rsp_item.getInstanceState(), rsp_item.getReason(), rsp_item.getKeyName(), rsp_item.getLaunchTime().toGregorianCalendar(), InstanceType.getTypeFromString(rsp_item.getInstanceType()), rsp_item.getPlacement().getAvailabilityZone(), rsp_item.getKernelId(), rsp_item.getRamdiskId()); } result.add(res); } return result; } catch (JAXBException ex) { throw new EC2Exception("Problem parsing returned message.", ex); } catch (MalformedURLException ex) { throw new EC2Exception(ex.getMessage(), ex); } catch (IOException ex) { throw new EC2Exception(ex.getMessage(), ex); } finally { method.releaseConnection(); } } /** * Reboot a selection of running instances. * * @param instanceIds A list of instances ({@link com.xerox.amazonws.ec2.ReservationDescription.Instance#instanceId}. * @throws EC2Exception wraps checked exceptions */ public void rebootInstances(String[] instanceIds) throws EC2Exception { this.rebootInstances(Arrays.asList(instanceIds)); } /** * Reboot a selection of running instances. * * @param instanceIds A list of instances ({@link com.xerox.amazonws.ec2.ReservationDescription.Instance#instanceId}. * @throws EC2Exception wraps checked exceptions */ public void rebootInstances(List<String> instanceIds) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); for (int i = 0; i < instanceIds.size(); i++) { params.put("InstanceId." + (i + 1), instanceIds.get(i)); } GetMethod method = new GetMethod(); try { RebootInstancesResponse response = makeRequest(method, "RebootInstances", params, RebootInstancesResponse.class); if (!response.isReturn()) { throw new EC2Exception("Could not reboot instances. No reason given."); } } catch (JAXBException ex) { throw new EC2Exception("Problem parsing returned message.", ex); } catch (MalformedURLException ex) { throw new EC2Exception(ex.getMessage(), ex); } catch (IOException ex) { throw new EC2Exception(ex.getMessage(), ex); } finally { method.releaseConnection(); } } /** * Get an instance's console output. * * @param instanceId An instance's id ({@link com.xerox.amazonws.ec2.ReservationDescription.Instance#instanceId}. * @return ({@link ConsoleOutput}) * @throws EC2Exception wraps checked exceptions */ public ConsoleOutput getConsoleOutput(String instanceId) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); params.put("InstanceId", instanceId); GetMethod method = new GetMethod(); try { GetConsoleOutputResponse response = makeRequest(method, "GetConsoleOutput", params, GetConsoleOutputResponse.class); return new ConsoleOutput(response.getInstanceId(), response.getTimestamp().toGregorianCalendar(), new String(Base64.decodeBase64(response.getOutput().getBytes()))); } catch (JAXBException ex) { throw new EC2Exception("Problem parsing returned message.", ex); } catch (MalformedURLException ex) { throw new EC2Exception(ex.getMessage(), ex); } catch (IOException ex) { throw new EC2Exception(ex.getMessage(), ex); } finally { method.releaseConnection(); } } /** * Creates a security group. * * @param name The name of the security group. * @param desc The description of the security group. * @throws EC2Exception wraps checked exceptions */ public void createSecurityGroup(String name, String desc) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); params.put("GroupName", name); params.put("GroupDescription", desc); GetMethod method = new GetMethod(); try { CreateSecurityGroupResponse response = makeRequest(method, "CreateSecurityGroup", params, CreateSecurityGroupResponse.class); if (!response.isReturn()) { throw new EC2Exception("Could not create security group : " + name + ". No reason given."); } } catch (JAXBException ex) { throw new EC2Exception("Problem parsing returned message.", ex); } catch (MalformedURLException ex) { throw new EC2Exception(ex.getMessage(), ex); } catch (IOException ex) { throw new EC2Exception(ex.getMessage(), ex); } finally { method.releaseConnection(); } } /** * Deletes a security group. * * @param name The name of the security group. * @throws EC2Exception wraps checked exceptions */ public void deleteSecurityGroup(String name) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); params.put("GroupName", name); GetMethod method = new GetMethod(); try { DeleteSecurityGroupResponse response = makeRequest(method, "DeleteSecurityGroup", params, DeleteSecurityGroupResponse.class); if (!response.isReturn()) { throw new EC2Exception("Could not delete security group : " + name + ". No reason given."); } } catch (JAXBException ex) { throw new EC2Exception("Problem parsing returned message.", ex); } catch (MalformedURLException ex) { throw new EC2Exception(ex.getMessage(), ex); } catch (IOException ex) { throw new EC2Exception(ex.getMessage(), ex); } finally { method.releaseConnection(); } } /** * Gets a list of security groups and their associated permissions. * * @param groupNames An array of groups to describe. * @return A list of groups ({@link GroupDescription}. * @throws EC2Exception wraps checked exceptions */ public List<GroupDescription> describeSecurityGroups(String[] groupNames) throws EC2Exception { return describeSecurityGroups(Arrays.asList(groupNames)); } /** * Gets a list of security groups and their associated permissions. * * @param groupNames A list of groups to describe. * @return A list of groups ({@link GroupDescription}. * @throws EC2Exception wraps checked exceptions */ public List<GroupDescription> describeSecurityGroups(List<String> groupNames) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); for (int i = 0; i < groupNames.size(); i++) { params.put("GroupName." + (i + 1), groupNames.get(i)); } GetMethod method = new GetMethod(); try { DescribeSecurityGroupsResponse response = makeRequest(method, "DescribeSecurityGroups", params, DescribeSecurityGroupsResponse.class); List<GroupDescription> result = new ArrayList<GroupDescription>(); SecurityGroupSetType rsp_set = response.getSecurityGroupInfo(); Iterator set_iter = rsp_set.getItems().iterator(); while (set_iter.hasNext()) { SecurityGroupItemType item = (SecurityGroupItemType) set_iter.next(); GroupDescription group = new GroupDescription(item.getGroupName(), item.getGroupDescription(), item.getOwnerId()); IpPermissionSetType perms = item.getIpPermissions(); Iterator perm_iter = perms.getItems().iterator(); while (perm_iter.hasNext()) { IpPermissionType perm = (IpPermissionType) perm_iter.next(); GroupDescription.IpPermission group_perms = group.addPermission(perm.getIpProtocol(), perm.getFromPort(), perm.getToPort()); Iterator group_iter = perm.getGroups().getItems().iterator(); while (group_iter.hasNext()) { UserIdGroupPairType uid_group = (UserIdGroupPairType) group_iter.next(); group_perms.addUserGroupPair(uid_group.getUserId(), uid_group.getGroupName()); } Iterator iprange_iter = perm.getIpRanges().getItems().iterator(); while (iprange_iter.hasNext()) { IpRangeItemType range = (IpRangeItemType) iprange_iter.next(); group_perms.addIpRange(range.getCidrIp()); } } result.add(group); } return result; } catch (JAXBException ex) { throw new EC2Exception("Problem parsing returned message.", ex); } catch (MalformedURLException ex) { throw new EC2Exception(ex.getMessage(), ex); } catch (IOException ex) { throw new EC2Exception(ex.getMessage(), ex); } finally { method.releaseConnection(); } } /** * Adds incoming permissions to a security group. * * @param groupName name of group to modify * @param secGroupName name of security group to authorize access to * @param secGroupOwnerId owner of security group to authorize access to * @throws EC2Exception wraps checked exceptions */ public void authorizeSecurityGroupIngress(String groupName, String secGroupName, String secGroupOwnerId) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); params.put("GroupName", groupName); params.put("SourceSecurityGroupOwnerId", secGroupOwnerId); params.put("SourceSecurityGroupName", secGroupName); GetMethod method = new GetMethod(); try { AuthorizeSecurityGroupIngressResponse response = makeRequest(method, "AuthorizeSecurityGroupIngress", params, AuthorizeSecurityGroupIngressResponse.class); if (!response.isReturn()) { throw new EC2Exception( "Could not authorize security ingress : " + groupName + ". No reason given."); } } catch (JAXBException ex) { throw new EC2Exception("Problem parsing returned message.", ex); } catch (MalformedURLException ex) { throw new EC2Exception(ex.getMessage(), ex); } catch (IOException ex) { throw new EC2Exception(ex.getMessage(), ex); } finally { method.releaseConnection(); } } /** * Adds incoming permissions to a security group. * * @param groupName name of group to modify * @param ipProtocol protocol to authorize (tcp, udp, icmp) * @param fromPort bottom of port range to authorize * @param toPort top of port range to authorize * @param cidrIp CIDR IP range to authorize (i.e. 0.0.0.0/0) * @throws EC2Exception wraps checked exceptions */ public void authorizeSecurityGroupIngress(String groupName, String ipProtocol, int fromPort, int toPort, String cidrIp) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); params.put("GroupName", groupName); params.put("IpProtocol", ipProtocol); params.put("FromPort", "" + fromPort); params.put("ToPort", "" + toPort); params.put("CidrIp", cidrIp); GetMethod method = new GetMethod(); try { AuthorizeSecurityGroupIngressResponse response = makeRequest(method, "AuthorizeSecurityGroupIngress", params, AuthorizeSecurityGroupIngressResponse.class); if (!response.isReturn()) { throw new EC2Exception( "Could not authorize security ingress : " + groupName + ". No reason given."); } } catch (JAXBException ex) { throw new EC2Exception("Problem parsing returned message.", ex); } catch (MalformedURLException ex) { throw new EC2Exception(ex.getMessage(), ex); } catch (IOException ex) { throw new EC2Exception(ex.getMessage(), ex); } finally { method.releaseConnection(); } } /** * Revokes incoming permissions from a security group. * * @param groupName name of group to modify * @param secGroupName name of security group to revoke access from * @param secGroupOwnerId owner of security group to revoke access from * @throws EC2Exception wraps checked exceptions */ public void revokeSecurityGroupIngress(String groupName, String secGroupName, String secGroupOwnerId) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); params.put("GroupName", groupName); params.put("SourceSecurityGroupOwnerId", secGroupOwnerId); params.put("SourceSecurityGroupName", secGroupName); GetMethod method = new GetMethod(); try { RevokeSecurityGroupIngressResponse response = makeRequest(method, "RevokeSecurityGroupIngress", params, RevokeSecurityGroupIngressResponse.class); if (!response.isReturn()) { throw new EC2Exception("Could not revoke security ingress : " + groupName + ". No reason given."); } } catch (JAXBException ex) { throw new EC2Exception("Problem parsing returned message.", ex); } catch (MalformedURLException ex) { throw new EC2Exception(ex.getMessage(), ex); } catch (IOException ex) { throw new EC2Exception(ex.getMessage(), ex); } finally { method.releaseConnection(); } } /** * Revokes incoming permissions from a security group. * * @param groupName name of group to modify * @param ipProtocol protocol to revoke (tcp, udp, icmp) * @param fromPort bottom of port range to revoke * @param toPort top of port range to revoke * @param cidrIp CIDR IP range to revoke (i.e. 0.0.0.0/0) * @throws EC2Exception wraps checked exceptions */ public void revokeSecurityGroupIngress(String groupName, String ipProtocol, int fromPort, int toPort, String cidrIp) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); params.put("GroupName", groupName); params.put("IpProtocol", ipProtocol); params.put("FromPort", "" + fromPort); params.put("ToPort", "" + toPort); params.put("CidrIp", cidrIp); GetMethod method = new GetMethod(); try { RevokeSecurityGroupIngressResponse response = makeRequest(method, "RevokeSecurityGroupIngress", params, RevokeSecurityGroupIngressResponse.class); if (!response.isReturn()) { throw new EC2Exception("Could not revoke security ingress : " + groupName + ". No reason given."); } } catch (JAXBException ex) { throw new EC2Exception("Problem parsing returned message.", ex); } catch (MalformedURLException ex) { throw new EC2Exception(ex.getMessage(), ex); } catch (IOException ex) { throw new EC2Exception(ex.getMessage(), ex); } finally { method.releaseConnection(); } } /** * Creates a public/private keypair. * * @param keyName Name of the keypair. * @return A keypair description ({@link KeyPairInfo}). * @throws EC2Exception wraps checked exceptions */ public KeyPairInfo createKeyPair(String keyName) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); params.put("KeyName", keyName); GetMethod method = new GetMethod(); try { CreateKeyPairResponse response = makeRequest(method, "CreateKeyPair", params, CreateKeyPairResponse.class); return new KeyPairInfo(response.getKeyName(), response.getKeyFingerprint(), response.getKeyMaterial()); } catch (JAXBException ex) { throw new EC2Exception("Problem parsing returned message.", ex); } catch (MalformedURLException ex) { throw new EC2Exception(ex.getMessage(), ex); } catch (IOException ex) { throw new EC2Exception(ex.getMessage(), ex); } finally { method.releaseConnection(); } } /** * Lists public/private keypairs. * * @param keyIds An array of keypairs. * @return A list of keypair descriptions ({@link KeyPairInfo}). * @throws EC2Exception wraps checked exceptions */ public List<KeyPairInfo> describeKeyPairs(String[] keyIds) throws EC2Exception { return describeKeyPairs(Arrays.asList(keyIds)); } /** * Lists public/private keypairs. * * @param keyIds A list of keypairs. * @return A list of keypair descriptions ({@link KeyPairInfo}). * @throws EC2Exception wraps checked exceptions */ public List<KeyPairInfo> describeKeyPairs(List<String> keyIds) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); for (int i = 0; i < keyIds.size(); i++) { params.put("KeyName." + (i + 1), keyIds.get(i)); } GetMethod method = new GetMethod(); try { DescribeKeyPairsResponse response = makeRequest(method, "DescribeKeyPairs", params, DescribeKeyPairsResponse.class); List<KeyPairInfo> result = new ArrayList<KeyPairInfo>(); DescribeKeyPairsResponseInfoType set = response.getKeySet(); Iterator set_iter = set.getItems().iterator(); while (set_iter.hasNext()) { DescribeKeyPairsResponseItemType item = (DescribeKeyPairsResponseItemType) set_iter.next(); result.add(new KeyPairInfo(item.getKeyName(), item.getKeyFingerprint(), null)); } return result; } catch (JAXBException ex) { throw new EC2Exception("Problem parsing returned message.", ex); } catch (MalformedURLException ex) { throw new EC2Exception(ex.getMessage(), ex); } catch (IOException ex) { throw new EC2Exception(ex.getMessage(), ex); } finally { method.releaseConnection(); } } /** * Deletes a public/private keypair. * * @param keyName Name of the keypair. * @throws EC2Exception wraps checked exceptions */ public void deleteKeyPair(String keyName) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); params.put("KeyName", keyName); GetMethod method = new GetMethod(); try { DeleteKeyPairResponse response = makeRequest(method, "DeleteKeyPair", params, DeleteKeyPairResponse.class); if (!response.isReturn()) { throw new EC2Exception("Could not delete keypair : " + keyName + ". No reason given."); } } catch (JAXBException ex) { throw new EC2Exception("Problem parsing returned message.", ex); } catch (MalformedURLException ex) { throw new EC2Exception(ex.getMessage(), ex); } catch (IOException ex) { throw new EC2Exception(ex.getMessage(), ex); } finally { method.releaseConnection(); } } /** * Enumerates image list attribute operation types. */ public enum ImageListAttributeOperationType { add, remove } /** * Modifies an attribute by the given items with the given operation. * * @param imageId The ID of the AMI to modify the attributes for. * @param attribute The name of the attribute to change. * @param operationType The name of the operation to change. May be add or remove. * @throws EC2Exception wraps checked exceptions */ public void modifyImageAttribute(String imageId, ImageListAttribute attribute, ImageListAttributeOperationType operationType) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); params.put("ImageId", imageId); if (attribute.getType().equals(ImageAttribute.ImageAttributeType.launchPermission)) { params.put("Attribute", "launchPermission"); switch (operationType) { case add: params.put("OperationType", "add"); break; case remove: params.put("OperationType", "remove"); break; default: throw new IllegalArgumentException("Unknown attribute operation."); } } else if (attribute.getType().equals(ImageAttribute.ImageAttributeType.productCodes)) { params.put("Attribute", "productCodes"); } int gNum = 1; int iNum = 1; int pNum = 1; for (ImageListAttributeItem item : attribute.getImageListAttributeItems()) { switch (item.getType()) { case group: params.put("UserGroup." + gNum, item.getValue()); gNum++; break; case userId: params.put("UserId." + iNum, item.getValue()); iNum++; break; case productCode: params.put("ProductCode." + pNum, item.getValue()); pNum++; break; default: throw new IllegalArgumentException("Unknown item type."); } } GetMethod method = new GetMethod(); try { ModifyImageAttributeResponse response = makeRequest(method, "ModifyImageAttribute", params, ModifyImageAttributeResponse.class); if (!response.isReturn()) { throw new EC2Exception("Could not reset image attribute. No reason given."); } } catch (JAXBException ex) { throw new EC2Exception("Problem parsing returned message.", ex); } catch (MalformedURLException ex) { throw new EC2Exception(ex.getMessage(), ex); } catch (IOException ex) { throw new EC2Exception(ex.getMessage(), ex); } finally { method.releaseConnection(); } } /** * Resets an attribute on an AMI. * * @param imageId The AMI to reset the attribute on. * @param imageAttribute The attribute type to reset. * @throws EC2Exception wraps checked exceptions */ public void resetImageAttribute(String imageId, ImageAttribute.ImageAttributeType imageAttribute) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); params.put("ImageId", imageId); if (imageAttribute.equals(ImageAttribute.ImageAttributeType.launchPermission)) { params.put("Attribute", "launchPermission"); } else if (imageAttribute.equals(ImageAttribute.ImageAttributeType.productCodes)) { throw new IllegalArgumentException("Cannot reset productCodes attribute"); } GetMethod method = new GetMethod(); try { ResetImageAttributeResponse response = makeRequest(method, "ResetImageAttribute", params, ResetImageAttributeResponse.class); if (!response.isReturn()) { throw new EC2Exception("Could not reset image attribute. No reason given."); } } catch (JAXBException ex) { throw new EC2Exception("Problem parsing returned message.", ex); } catch (MalformedURLException ex) { throw new EC2Exception(ex.getMessage(), ex); } catch (IOException ex) { throw new EC2Exception(ex.getMessage(), ex); } finally { method.releaseConnection(); } } /** * Describes an attribute of an AMI. * * @param imageId The AMI for which the attribute is described. * @param imageAttribute The attribute type to describe. * @return An object containing the imageId and a list of list attribute item types and values. * @throws EC2Exception wraps checked exceptions */ public DescribeImageAttributeResult describeImageAttribute(String imageId, ImageAttribute.ImageAttributeType imageAttribute) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); params.put("ImageId", imageId); if (imageAttribute.equals(ImageAttribute.ImageAttributeType.launchPermission)) { params.put("Attribute", "launchPermission"); } else if (imageAttribute.equals(ImageAttribute.ImageAttributeType.productCodes)) { params.put("Attribute", "productCodes"); } GetMethod method = new GetMethod(); try { DescribeImageAttributeResponse response = makeRequest(method, "DescribeImageAttribute", params, DescribeImageAttributeResponse.class); ImageListAttribute attribute = null; if (response.getLaunchPermission() != null) { LaunchPermissionListType list = response.getLaunchPermission(); attribute = new LaunchPermissionAttribute(); java.util.ListIterator i = list.getItems().listIterator(); while (i.hasNext()) { LaunchPermissionItemType item = (LaunchPermissionItemType) i.next(); if (item.getGroup() != null) { attribute.addImageListAttributeItem(ImageListAttribute.ImageListAttributeItemType.group, item.getGroup()); } else if (item.getUserId() != null) { attribute.addImageListAttributeItem(ImageListAttribute.ImageListAttributeItemType.userId, item.getUserId()); } } } else if (response.getProductCodes() != null) { ProductCodeListType list = response.getProductCodes(); attribute = new ProductCodesAttribute(); java.util.ListIterator i = list.getItems().listIterator(); while (i.hasNext()) { ProductCodeItemType item = (ProductCodeItemType) i.next(); if (item.getProductCode() != null) { attribute.addImageListAttributeItem( ImageListAttribute.ImageListAttributeItemType.productCode, item.getProductCode()); } } } ArrayList<String> codes = new ArrayList<String>(); ProductCodeListType set = response.getProductCodes(); if (set != null) { for (ProductCodeItemType code : set.getItems()) { codes.add(code.getProductCode()); } } NullableAttributeValueType val = response.getKernel(); String kernel = (val != null) ? val.getValue() : ""; val = response.getRamdisk(); String ramdisk = (val != null) ? val.getValue() : ""; ArrayList<BlockDeviceMapping> bdm = new ArrayList<BlockDeviceMapping>(); BlockDeviceMappingType bdmSet = response.getBlockDeviceMapping(); if (bdmSet != null) { for (BlockDeviceMappingItemType mapping : bdmSet.getItems()) { bdm.add(new BlockDeviceMapping(mapping.getVirtualName(), mapping.getDeviceName())); } } return new DescribeImageAttributeResult(response.getImageId(), attribute, codes, kernel, ramdisk, bdm); } catch (JAXBException ex) { throw new EC2Exception("Problem parsing returned message.", ex); } catch (MalformedURLException ex) { throw new EC2Exception(ex.getMessage(), ex); } catch (IOException ex) { throw new EC2Exception(ex.getMessage(), ex); } finally { method.releaseConnection(); } } /** * Returns true if the productCode is associated with the instance. * * @param instanceId An instance's id ({@link com.xerox.amazonws.ec2.ReservationDescription.Instance#instanceId}. * @param productCode the code for the project you registered with AWS * @return null if no relationship exists, otherwise information about the owner * @throws EC2Exception wraps checked exceptions */ public ProductInstanceInfo confirmProductInstance(String instanceId, String productCode) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); params.put("InstanceId", instanceId); params.put("ProductCode", productCode); GetMethod method = new GetMethod(); try { ConfirmProductInstanceResponse response = makeRequest(method, "ConfirmProductInstance", params, ConfirmProductInstanceResponse.class); if (response.isReturn()) { return new ProductInstanceInfo(instanceId, productCode, response.getOwnerId()); } else return null; } catch (JAXBException ex) { throw new EC2Exception("Problem parsing returned message.", ex); } catch (MalformedURLException ex) { throw new EC2Exception(ex.getMessage(), ex); } catch (IOException ex) { throw new EC2Exception(ex.getMessage(), ex); } finally { method.releaseConnection(); } } /** * Returns a list of availability zones and their status. * * @param zones a list of zones to limit the results, or null * @return a list of zones and their availability * @throws EC2Exception wraps checked exceptions */ public List<AvailabilityZone> describeAvailabilityZones(List<String> zones) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); if (zones != null && zones.size() > 0) { for (int i = 0; i < zones.size(); i++) { params.put("ZoneName." + (i + 1), zones.get(i)); } } GetMethod method = new GetMethod(); try { DescribeAvailabilityZonesResponse response = makeRequest(method, "DescribeAvailabilityZones", params, DescribeAvailabilityZonesResponse.class); List<AvailabilityZone> ret = new ArrayList<AvailabilityZone>(); AvailabilityZoneSetType set = response.getAvailabilityZoneInfo(); Iterator set_iter = set.getItems().iterator(); while (set_iter.hasNext()) { AvailabilityZoneItemType item = (AvailabilityZoneItemType) set_iter.next(); ret.add(new AvailabilityZone(item.getZoneName(), item.getZoneState())); } return ret; } catch (JAXBException ex) { throw new EC2Exception("Problem parsing returned message.", ex); } catch (MalformedURLException ex) { throw new EC2Exception(ex.getMessage(), ex); } catch (IOException ex) { throw new EC2Exception(ex.getMessage(), ex); } finally { method.releaseConnection(); } } /** * Returns a list of addresses associated with this account. * * @param addresses a list of zones to limit the results, or null * @return a list of addresses and their associated instance * @throws EC2Exception wraps checked exceptions */ public List<AddressInfo> describeAddresses(List<String> addresses) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); if (addresses != null && addresses.size() > 0) { for (int i = 0; i < addresses.size(); i++) { params.put("PublicIp." + (i + 1), addresses.get(i)); } } GetMethod method = new GetMethod(); try { DescribeAddressesResponse response = makeRequest(method, "DescribeAddresses", params, DescribeAddressesResponse.class); List<AddressInfo> ret = new ArrayList<AddressInfo>(); DescribeAddressesResponseInfoType set = response.getAddressesSet(); Iterator set_iter = set.getItems().iterator(); while (set_iter.hasNext()) { DescribeAddressesResponseItemType item = (DescribeAddressesResponseItemType) set_iter.next(); ret.add(new AddressInfo(item.getPublicIp(), item.getInstanceId())); } return ret; } catch (JAXBException ex) { throw new EC2Exception("Problem parsing returned message.", ex); } catch (MalformedURLException ex) { throw new EC2Exception(ex.getMessage(), ex); } catch (IOException ex) { throw new EC2Exception(ex.getMessage(), ex); } finally { method.releaseConnection(); } } /** * Allocates an address for this account. * * @return the new address allocated * @throws EC2Exception wraps checked exceptions */ public String allocateAddress() throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); GetMethod method = new GetMethod(); try { AllocateAddressResponse response = makeRequest(method, "AllocateAddress", params, AllocateAddressResponse.class); return response.getPublicIp(); } catch (JAXBException ex) { throw new EC2Exception("Problem parsing returned message.", ex); } catch (MalformedURLException ex) { throw new EC2Exception(ex.getMessage(), ex); } catch (IOException ex) { throw new EC2Exception(ex.getMessage(), ex); } finally { method.releaseConnection(); } } /** * Associates an address with an instance. * * @param instanceId the instance * @param publicIp the ip address to associate * @throws EC2Exception wraps checked exceptions */ public void associateAddress(String instanceId, String publicIp) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); params.put("InstanceId", instanceId); params.put("PublicIp", publicIp); GetMethod method = new GetMethod(); try { AssociateAddressResponse response = makeRequest(method, "AssociateAddress", params, AssociateAddressResponse.class); if (!response.isReturn()) { throw new EC2Exception("Could not associate address with instance (no reason given)."); } } catch (JAXBException ex) { throw new EC2Exception("Problem parsing returned message.", ex); } catch (MalformedURLException ex) { throw new EC2Exception(ex.getMessage(), ex); } catch (IOException ex) { throw new EC2Exception(ex.getMessage(), ex); } finally { method.releaseConnection(); } } /** * Disassociates an address with an instance. * * @param publicIp the ip address to disassociate * @throws EC2Exception wraps checked exceptions */ public void disassociateAddress(String publicIp) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); params.put("PublicIp", publicIp); GetMethod method = new GetMethod(); try { DisassociateAddressResponse response = makeRequest(method, "DisassociateAddress", params, DisassociateAddressResponse.class); if (!response.isReturn()) { throw new EC2Exception("Could not disassociate address with instance (no reason given)."); } } catch (JAXBException ex) { throw new EC2Exception("Problem parsing returned message.", ex); } catch (MalformedURLException ex) { throw new EC2Exception(ex.getMessage(), ex); } catch (IOException ex) { throw new EC2Exception(ex.getMessage(), ex); } finally { method.releaseConnection(); } } /** * Releases an address * * @param publicIp the ip address to release * @throws EC2Exception wraps checked exceptions */ public void releaseAddress(String publicIp) throws EC2Exception { Map<String, String> params = new HashMap<String, String>(); params.put("PublicIp", publicIp); GetMethod method = new GetMethod(); try { ReleaseAddressResponse response = makeRequest(method, "ReleaseAddress", params, ReleaseAddressResponse.class); if (!response.isReturn()) { throw new EC2Exception("Could not release address (no reason given)."); } } catch (JAXBException ex) { throw new EC2Exception("Problem parsing returned message.", ex); } catch (MalformedURLException ex) { throw new EC2Exception(ex.getMessage(), ex); } catch (IOException ex) { throw new EC2Exception(ex.getMessage(), ex); } finally { method.releaseConnection(); } } }