Java tutorial
/******************************************************************************* * Copyright 2012 Urbancode, Inc * * 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.urbancode.terraform.tasks.aws; import java.io.File; import java.rmi.RemoteException; import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.regex.Matcher; import java.util.regex.Pattern; import org.apache.log4j.Logger; import com.amazonaws.AmazonServiceException; import com.amazonaws.services.ec2.AmazonEC2; import com.amazonaws.services.ec2.model.BlockDeviceMapping; import com.amazonaws.services.ec2.model.GroupIdentifier; import com.amazonaws.services.ec2.model.Image; import com.amazonaws.services.ec2.model.Instance; import com.amazonaws.services.elasticloadbalancing.AmazonElasticLoadBalancing; import com.urbancode.terraform.tasks.aws.helpers.AWSHelper; import com.urbancode.terraform.tasks.common.exceptions.EnvironmentCreationException; import com.urbancode.terraform.tasks.common.exceptions.EnvironmentDestructionException; import com.urbancode.terraform.tasks.common.exceptions.PostCreateException; import com.urbancode.x2o.tasks.Task; public class InstanceTask extends Task { //********************************************************************************************** // CLASS //********************************************************************************************** final static private Logger log = Logger.getLogger(InstanceTask.class); //********************************************************************************************** // INSTANCE //********************************************************************************************** private AmazonEC2 ec2Client; private AmazonElasticLoadBalancing elbClient; private AWSHelper helper; protected ContextAWS context; // by default, do not assign an EIP private boolean elasticIp = false; private String name; private String instanceId; private String amiId; private String akiId; private String ariId; private String subnetName; private String subnetId; private String elasticIpAllocId; private String elasticIpAddress; private String keyRef; private String sizeType; private String userData; private String loadBalancer; private String privateIp; private String zone; private String platform; // default values private int count = 1; private int priority = 1; private BootActionsTask bootActions; private PostCreateActionsTask pca; private List<SecurityGroupRefTask> secRefs = new ArrayList<SecurityGroupRefTask>(); private List<EbsTask> ebsVolumes = new ArrayList<EbsTask>(); //---------------------------------------------------------------------------------------------- public InstanceTask(ContextAWS context) { this.context = context; helper = new AWSHelper(); } //---------------------------------------------------------------------------------------------- public void setPlatform(String platform) { this.platform = platform; } //---------------------------------------------------------------------------------------------- public void setZone(String zone) { this.zone = zone; } //---------------------------------------------------------------------------------------------- public void setPrivateIp(String privateIp) { String ip4RegEx = "[0-9][0-9]?[0-9]?\\.[0-9][0-9]?[0-9]?\\.[0-9][0-9]?[0-9]?\\.[0-9][0-9]?[0-9]?"; Pattern ip4Pattern = Pattern.compile(ip4RegEx); Matcher ip4Matcher = ip4Pattern.matcher(privateIp); if (ip4Matcher.find() && ip4Matcher.end() == privateIp.length()) { this.privateIp = privateIp; } else { log.error("Invalid Private IP Address for instance " + this.getName()); this.privateIp = ""; } } //---------------------------------------------------------------------------------------------- public void setLoadBalancer(String loadBalancer) { this.loadBalancer = loadBalancer; } //---------------------------------------------------------------------------------------------- public void setPriority(int priority) { this.priority = priority; } //---------------------------------------------------------------------------------------------- public void setCount(int count) { this.count = count; } //---------------------------------------------------------------------------------------------- public void setPrivateKeyRef(String keyRef) { this.keyRef = keyRef; } //---------------------------------------------------------------------------------------------- public void setImageSize(String sizeType) { this.sizeType = sizeType; } //---------------------------------------------------------------------------------------------- public void setName(String name) { this.name = name; } //---------------------------------------------------------------------------------------------- public void setId(String id) { this.instanceId = id; } //---------------------------------------------------------------------------------------------- public void setAmiId(String id) { this.amiId = id; } //---------------------------------------------------------------------------------------------- public void setSubnetName(String name) { this.subnetName = name; } //---------------------------------------------------------------------------------------------- public void setSubnetId(String id) { this.subnetId = id; } //---------------------------------------------------------------------------------------------- public void setPublicIp(String elasticIpAddress) { this.elasticIpAddress = elasticIpAddress; } //---------------------------------------------------------------------------------------------- public void setElasticIp(boolean elasticIp) { this.elasticIp = elasticIp; } //---------------------------------------------------------------------------------------------- public void setElasticIpAllocId(String id) { this.elasticIpAllocId = id; } //---------------------------------------------------------------------------------------------- public void setRamdiskId(String ariId) { this.ariId = ariId; } //---------------------------------------------------------------------------------------------- public void setKernelId(String akiId) { this.akiId = akiId; } //---------------------------------------------------------------------------------------------- public String getPlatform() { return platform; } //---------------------------------------------------------------------------------------------- public String getZone() { return zone; } //---------------------------------------------------------------------------------------------- public String getRamdiskId() { return ariId; } //---------------------------------------------------------------------------------------------- public String getKernelId() { return akiId; } //---------------------------------------------------------------------------------------------- public String getPrivateIp() { return privateIp; } //---------------------------------------------------------------------------------------------- public String getLoadBalancer() { return loadBalancer; } //---------------------------------------------------------------------------------------------- public int getPriority() { return priority; } //---------------------------------------------------------------------------------------------- public int getCount() { return count; } //---------------------------------------------------------------------------------------------- public String getId() { return instanceId; } //---------------------------------------------------------------------------------------------- public String getImageSize() { return sizeType; } //---------------------------------------------------------------------------------------------- public String getPrivateKeyRef() { return keyRef; } //---------------------------------------------------------------------------------------------- public String getName() { return name; } //---------------------------------------------------------------------------------------------- public BootActionsTask getBootActions() { return bootActions; } //---------------------------------------------------------------------------------------------- public PostCreateActionsTask getPostCreateActions() { return pca; } //---------------------------------------------------------------------------------------------- public List<SecurityGroupRefTask> getSecurityGroupRefs() { return Collections.unmodifiableList(secRefs); } //---------------------------------------------------------------------------------------------- public List<EbsTask> getEbsVolumes() { return Collections.unmodifiableList(ebsVolumes); } //---------------------------------------------------------------------------------------------- public String getAmiId() { return amiId; } //---------------------------------------------------------------------------------------------- public String getSubnetName() { return subnetName; } //---------------------------------------------------------------------------------------------- public boolean getElasticIp() { return elasticIp; } //---------------------------------------------------------------------------------------------- public String getElasticIpAllocId() { return elasticIpAllocId; } //---------------------------------------------------------------------------------------------- public String getPublicIp() { return elasticIpAddress; } //---------------------------------------------------------------------------------------------- public EbsTask createEbs() { EbsTask ebs = new EbsTask(context); ebsVolumes.add(ebs); return ebs; } //---------------------------------------------------------------------------------------------- public BootActionsTask createBootActions() { this.bootActions = new BootActionsTask(context); return bootActions; } //---------------------------------------------------------------------------------------------- public PostCreateActionsTask createPostCreateActions() { this.pca = new PostCreateActionsTask(context); return pca; } //---------------------------------------------------------------------------------------------- public SecurityGroupRefTask createEc2SecurityGroupRef() { SecurityGroupRefTask group = null; // if the instance does not have a subnet name set, then we'll // check for a zone, which would be required for an EC2 instance if (zone != null && !zone.isEmpty()) { log.debug("Creating EC2 Security Group Ref"); group = new Ec2SecurityGroupRefTask(context); } else { String msg = "No zone set! Unable to create securityGroup"; log.error(msg); // throw } if (group != null) { secRefs.add(group); } return group; } //---------------------------------------------------------------------------------------------- public SecurityGroupRefTask createVpcSecurityGroupRef() { SecurityGroupRefTask group = null; // determine which type of security group we need to make. // We will check if it's a VPC one first, that means the // instance must have a subnet name set. if (subnetName != null && !subnetName.isEmpty()) { log.debug("Creating VPC Security Group Ref"); group = new VpcSecurityGroupRefTask(context); } // if neither of those checks pass, something is wrong... else { String msg = "No subnet set! Unable to create securityGroup"; log.error(msg); // throw } if (group != null) { secRefs.add(group); } return group; } //---------------------------------------------------------------------------------------------- private boolean verifyElasticIp(Instance instance) { boolean result = false; boolean hasEIP = instance.getPublicIpAddress() != null; if (elasticIp == hasEIP) { if (elasticIp == true) { if (instance.getPublicIpAddress().equals(elasticIpAddress)) { result = true; } } else { result = true; } } return result; } //---------------------------------------------------------------------------------------------- private boolean verifyKeyPair(Instance instance) { boolean result = false; String keyName = keyRef; if (instance.getKeyName() != null && keyName != null) { if (instance.getKeyName().equals(keyName)) { result = true; } } return result; } //---------------------------------------------------------------------------------------------- private boolean verifySize(Instance instance) { boolean result = false; String size = sizeType; if (instance.getInstanceType() != null && size != null) { if (instance.getInstanceType().equals(size)) { result = true; } } return result; } //---------------------------------------------------------------------------------------------- private boolean verifySecurityGroups(Instance instance) { boolean result = false; List<String> expectedIds = new ArrayList<String>(); for (SecurityGroupRefTask group : getSecurityGroupRefs()) { expectedIds.add(group.fetchSecurityGroup().getId()); } List<String> foundIds = new ArrayList<String>(); List<GroupIdentifier> gids = instance.getSecurityGroups(); if (gids != null && !gids.isEmpty()) { for (GroupIdentifier gid : gids) { foundIds.add(gid.getGroupId()); } } return result; } //---------------------------------------------------------------------------------------------- public boolean verify() { // will return false if the id is null boolean result = false; if (instanceId != null) { if (ec2Client == null) { ec2Client = context.fetchEC2Client(); } List<String> id = new ArrayList<String>(); id.add(instanceId); List<Instance> instances = helper.getInstances(id, ec2Client); if (instances != null && !instances.isEmpty()) { for (Instance instance : instances) { if (instance.getImageId().equals(amiId)) { String subId = ((EnvironmentTaskAWS) context.getEnvironment()).getVpc() .findSubnetForName(subnetName).getId(); if (instance.getSubnetId() != null && instance.getSubnetId().equals(subId) && verifyElasticIp(instance) && verifyKeyPair(instance) && verifySize(instance) && verifySecurityGroups(instance)) { result = true; } } } } } return result; } //---------------------------------------------------------------------------------------------- private String setupBootActions() { String actions = ""; log.debug("Setting up Boot Actions"); if (getBootActions() != null) { getBootActions().setPlatform(platform); getBootActions().create(); actions = getBootActions().getUserData(); actions = context.resolve(actions); } log.info("Instance is being launched with following user-data script:\n\n" + actions); return actions; } //---------------------------------------------------------------------------------------------- private String setupType() { String size = sizeType; String defaultType = "t1.micro"; if (size.indexOf(".") == -1) { size = null; } if (size == null || size.isEmpty()) { log.warn("No instance size specified. Default to " + defaultType); size = defaultType; } return size; } //---------------------------------------------------------------------------------------------- private String setupKeyPair() { String keyPair = keyRef; if (keyPair == null || keyPair.isEmpty()) { log.warn("No key-pair specified. You may not be able to connect to instance " + name); } return keyPair; } //---------------------------------------------------------------------------------------------- private List<BlockDeviceMapping> setupEbs() { List<BlockDeviceMapping> blockMaps = new ArrayList<BlockDeviceMapping>(); if (ebsVolumes != null) { for (EbsTask ebs : ebsVolumes) { ebs.create(); blockMaps.add(ebs.getBlockDeviceMapping()); } } return blockMaps; } //---------------------------------------------------------------------------------------------- private List<String> findSecurityGroups() { List<String> groupIds = new ArrayList<String>(); if (getSecurityGroupRefs() != null) { for (SecurityGroupRefTask ref : getSecurityGroupRefs()) { SecurityGroupTask found = ref.fetchSecurityGroup(); if (found != null) { groupIds.add(found.getId()); } } } return groupIds; } //---------------------------------------------------------------------------------------------- private void updateMachineInfo() throws RemoteException { if (ec2Client == null) { throw new RemoteException("No connection to EC2"); } // update the akiId and ariId with what Amazon shows Instance instance = helper.getInstanceById(instanceId, ec2Client); if (instance != null) { log.info("Verifying Kernel Id..."); log.info("Expected: " + akiId); akiId = instance.getKernelId(); log.info("Found: " + akiId); log.info("Verifying Ramdisk Id..."); log.info("Expected: " + ariId); ariId = instance.getRamdiskId(); log.info("Found: " + ariId); } } //---------------------------------------------------------------------------------------------- private void assignElasticIp(String ipToAssign) throws RemoteException { if (ec2Client == null) { throw new RemoteException("No connection to EC2"); } if (ipToAssign == null || ipToAssign.isEmpty()) { if (subnetName != null && subnetId != null) { String allocId = helper.requestElasticIp(ec2Client); setElasticIpAllocId(allocId); String eip = helper.assignElasticIp(instanceId, allocId, ec2Client); setPublicIp(eip); } else { log.error("Cannot assign Elastic Ip to non-VPC instance"); } } } //---------------------------------------------------------------------------------------------- private void registerWithLoadBalancer() throws RemoteException, EnvironmentCreationException { if (ec2Client == null) { throw new RemoteException("No connection to EC2"); } if (loadBalancer != null && !loadBalancer.isEmpty()) { // we need to find the fullName of the load-balancer with name loadBalancer if (context != null && context.getEnvironment() != null && context.getEnvironment() instanceof EnvironmentTaskAWS) { EnvironmentTaskAWS env = (EnvironmentTaskAWS) context.getEnvironment(); if (env.getLoadBalancers() != null) { for (LoadBalancerTask load : env.getLoadBalancers()) { if (load.getName().equals(loadBalancer)) { // found it boolean allowed = false; // check if (zone != null && !zone.isEmpty()) { if (load.containsZone(zone)) { allowed = true; } else { log.error("Load balancer " + load.getName() + " does not " + "contain " + "zone " + zone + " - could not add " + "instance " + name + " to load balancer"); } } else if (subnetName != null && !subnetName.isEmpty()) { if (load.containsSubnet(subnetName)) { allowed = true; } else { log.error("Load balancer " + load.getName() + " does not " + "contain " + "subnet " + subnetName + " - could not " + "add instance " + name + " to load balancer"); } } if (allowed) { List<String> tmp = new ArrayList<String>(); tmp.add(instanceId); helper.updateInstancesOnLoadBalancer(load.getFullName(), tmp, true, elbClient); } else { log.error("Instance " + name + " cannot be registered on load " + "balancer " + load.getName()); throw new EnvironmentCreationException("Subnet " + subnetName + " or zone " + zone + " is not associated with load " + "balancer " + load.getFullName()); } break; } } } } } } //---------------------------------------------------------------------------------------------- private void deregisterWithLoadBalancer() { if (context != null && context.getEnvironment() != null && context.getEnvironment() instanceof EnvironmentTaskAWS) { EnvironmentTaskAWS env = (EnvironmentTaskAWS) context.getEnvironment(); if (env.getLoadBalancers() != null) { for (LoadBalancerTask load : env.getLoadBalancers()) { if (load.getName().equals(loadBalancer)) { // found it, deregistering instance with load balancer List<String> tmp = new ArrayList<String>(); tmp.add(instanceId); helper.updateInstancesOnLoadBalancer(load.getFullName(), tmp, false, elbClient); break; } } } } } //---------------------------------------------------------------------------------------------- private void waitForInstance() throws RemoteException, InterruptedException { if (instanceId != null && ec2Client != null) { // wait for instance to start and pass status checks helper.waitForState(instanceId, "running", 8, ec2Client); helper.waitForStatus(instanceId, "ok", 8, ec2Client); } } //---------------------------------------------------------------------------------------------- private void postStartup() throws RemoteException, InterruptedException { if (ec2Client == null) { throw new RemoteException("No connection to EC2"); } updateMachineInfo(); waitForInstance(); // name Instances String serverName = context.getEnvironment().getName() + "-" + name; helper.tagInstance(instanceId, "Name", serverName, ec2Client); // tag the instance with the environment name helper.tagInstance(instanceId, "terraform.environment", context.getEnvironment().getName(), ec2Client); } //---------------------------------------------------------------------------------------------- private void startPostCreateActions(String keyPair) throws PostCreateException { if (pca != null) { if (elasticIpAddress != null && !elasticIpAddress.isEmpty()) { pca.setHost(elasticIpAddress); } else { log.warn("Trying to do PostCreateActions on instance with no public ip!" + "\nName: " + name + "\nId: " + instanceId); } if (keyPair != null && !keyPair.isEmpty()) { String basePath = System.getProperty("user.home") + File.separator + ".terraform"; String keyPairPath = basePath + File.separator + keyPair + ".pem"; pca.setIdFile(keyPairPath); } else { log.warn("Trying to do PostCreateActions on instance " + name + " ( " + instanceId + " ) with no ssh key!"); } pca.create(); } } //---------------------------------------------------------------------------------------------- private void updatePlatform() { // update the platform List<String> imageId = new ArrayList<String>(); imageId.add(amiId); List<Image> images = helper.getImages(null, imageId, ec2Client); if (images != null) { Image image = images.get(0); platform = image.getPlatform(); } if (platform == null || "".equals(platform)) { platform = "linux"; } } //---------------------------------------------------------------------------------------------- @Override public void create() throws EnvironmentCreationException { String size; String keyPair; boolean verified = false; log.debug("Creating instance " + name); context.setProperty("server.name", name); // check AWS connections if (ec2Client == null) { ec2Client = context.fetchEC2Client(); } if (elbClient == null) { elbClient = context.fetchELBClient(); } updatePlatform(); try { // setup userData = setupBootActions(); size = setupType(); keyPair = setupKeyPair(); if (!verified) { setId(null); log.info("Starting creation"); List<String> groupIds = findSecurityGroups(); List<BlockDeviceMapping> blockMaps = setupEbs(); if (amiId == null) { String msg = "No AMI ID specified for instance " + name + ". There is no image" + " to use."; log.fatal(msg); throw new EnvironmentCreationException(msg); } // launch the instance and set the Id instanceId = helper.launchAmi(amiId, subnetId, keyPair, size, userData, groupIds, blockMaps, ariId, akiId, zone, privateIp, ec2Client); Thread.sleep(1000); postStartup(); // give instance elastic ip if (elasticIp) { // if we send null, it will grab a new EIP and assign it assignElasticIp(elasticIpAddress); } Instance instance = helper.getInstanceById(instanceId, ec2Client); // set public Ip if (zone != null && !zone.isEmpty()) { setPublicIp(instance.getPublicIpAddress()); context.setProperty(getName() + ".public.ip", getPublicIp()); } // set private Ip privateIp = instance.getPrivateIpAddress(); context.setProperty(getName() + ".private.ip", getPrivateIp()); // register with LB registerWithLoadBalancer(); // do PostCreateActions startPostCreateActions(keyPair); } } catch (Exception e) { log.error("Did not start instance " + name + " completely"); throw new EnvironmentCreationException("Failed to create Instance " + name, e); } finally { ec2Client = null; elbClient = null; } } //---------------------------------------------------------------------------------------------- @Override public void destroy() throws EnvironmentDestructionException { if (ec2Client == null) { ec2Client = context.fetchEC2Client(); } if (elbClient == null) { elbClient = context.fetchELBClient(); } try { log.info("Shutting down instance " + getId()); List<String> instanceIds = new ArrayList<String>(); instanceIds.add(instanceId); try { deregisterWithLoadBalancer(); } catch (AmazonServiceException e) { // swallow exception if we get invalidInstance // this will ignore the exception if you try to // deregister and instance that is not registered with // the load balancer - allowing the instance to terminate // completely. if (!e.getErrorCode().equals("InvalidInstance")) { throw e; } } if (elasticIpAllocId != null) { String assocId = helper.getAssociationIdForAllocationId(elasticIpAllocId, ec2Client); if (assocId != null && !assocId.isEmpty()) { helper.disassociateElasticIp(assocId, ec2Client); helper.releaseElasticIp(getElasticIpAllocId(), ec2Client); setElasticIpAllocId(null); setPublicIp(null); } else { log.error("Could not find asssociation Id for instance " + getName() + "\nUnable to disassociate and release elastic ip with " + "allocation id: " + elasticIpAllocId); } } if (instanceIds != null && !instanceIds.isEmpty()) { helper.terminateInstances(instanceIds, ec2Client); helper.waitForState(getId(), "terminated", 8, ec2Client); setId(null); setSubnetId(null); } if (bootActions != null) { bootActions.destroy(); } if (secRefs != null) { for (SecurityGroupRefTask group : secRefs) { group.destroy(); } } } catch (Exception e) { log.error("Did not destroy instance " + name + " completely", e); throw new EnvironmentDestructionException("Failed to destroy instance " + name, e); } finally { ec2Client = null; elbClient = null; log.info("Instance Destroyed."); } } //---------------------------------------------------------------------------------------------- @Override public InstanceTask clone() { InstanceTask result = new InstanceTask(context); // attributes result.setAmiId(amiId); result.setKernelId(akiId); result.setRamdiskId(ariId); result.setElasticIp(elasticIp); result.setImageSize(sizeType); result.setName(name); result.setPrivateKeyRef(keyRef); result.setSubnetName(subnetName); result.setZone(zone); // post create actions task BootActionsTask pcat = result.createBootActions(); if (getBootActions() != null) { if (getBootActions().getShell() != null) { pcat.setShell(getBootActions().getShell()); } if (getBootActions().getScript() != null) { for (BootActionSubTask script : getBootActions().getScript()) { ScriptTask scriptTask = (ScriptTask) script; ScriptTask nScript = pcat.createScript(); nScript.setCmds(script.getCmds()); nScript.setShell(scriptTask.getShell()); nScript.setUrl(scriptTask.getUrl()); for (ParamTask param : scriptTask.getParams()) { ParamTask nParam = nScript.createParam(); nParam.setValue(param.getValue()); } } } } PostCreateActionsTask pcat2 = result.createPostCreateActions(); if (getPostCreateActions() != null) { if (getPostCreateActions().getPostCreateActions() != null) { for (PostCreateActionTask ssh : getPostCreateActions().getPostCreateActions()) { if (ssh instanceof SshTask) { SshTask sshTask = pcat2.createSsh(); sshTask.setCmds(((SshTask) ssh).getCmds()); sshTask.setPassword(ssh.getPassword()); sshTask.setPort(ssh.getPort()); sshTask.setUser(ssh.getUser()); } } } } // sec group refs if (getSecurityGroupRefs() != null) { for (SecurityGroupRefTask secGroup : getSecurityGroupRefs()) { SecurityGroupRefTask nSecGroup = null; if (secGroup instanceof Ec2SecurityGroupRefTask) { nSecGroup = result.createEc2SecurityGroupRef(); } else if (secGroup instanceof VpcSecurityGroupRefTask) { nSecGroup = result.createVpcSecurityGroupRef(); } else { log.error("Unable to clone SecurityGroupRefTasks"); } nSecGroup.setSecurityGroupName(secGroup.getSecurityGroupName()); } } // ebsVolumes if (getEbsVolumes() != null) { for (EbsTask ebs : getEbsVolumes()) { EbsTask nEbs = result.createEbs(); nEbs.setVolumeSize(ebs.getVolumeSize()); nEbs.setVolumeId(ebs.getVolumeId()); nEbs.setSnapshotId(ebs.getSnapshotId()); nEbs.setPersist(ebs.getPersist()); nEbs.setName(ebs.getName()); nEbs.setDeviceName(ebs.getDeviceName()); } } return result; } }