Example usage for com.amazonaws.services.ec2.model Tag setValue

List of usage examples for com.amazonaws.services.ec2.model Tag setValue

Introduction

In this page you can find the example usage for com.amazonaws.services.ec2.model Tag setValue.

Prototype


public void setValue(String value) 

Source Link

Document

The value of the tag.

Usage

From source file:com.liferay.amazontools.AsgardAMIDeployer.java

License:Open Source License

protected String createAutoScalingGroup() throws Exception {
    DescribeAutoScalingGroupsResult describeAutoScalingGroupsResult = amazonAutoScalingClient
            .describeAutoScalingGroups();

    List<AutoScalingGroup> autoScalingGroups = describeAutoScalingGroupsResult.getAutoScalingGroups();

    int oldAutoScalingGroupsSize = autoScalingGroups.size();

    String availabilityZone = properties.getProperty("availability.zone");

    Map<String, String> parameters = new HashMap<String, String>();

    parameters.put("checkHealth", "true");
    parameters.put("imageId", getImageId(_imageName));

    String asgardClusterName = properties.getProperty("asgard.cluster.name");

    parameters.put("name", asgardClusterName);

    parameters.put("trafficAllowed", "true");

    if (!_parallelDeployment) {
        parameters.put("desiredCapacity", "1");
        parameters.put("min", "1");
    }/*  w  w w.j  av a  2 s  .c  o  m*/

    _jsonWebServiceClient.doPost("/" + availabilityZone + "/cluster/createNextGroup", parameters);

    for (int i = 0; i < 30; i++) {
        describeAutoScalingGroupsResult = amazonAutoScalingClient.describeAutoScalingGroups();

        autoScalingGroups = describeAutoScalingGroupsResult.getAutoScalingGroups();

        int newAutoScalingGroupsSize = autoScalingGroups.size();

        if (oldAutoScalingGroupsSize == newAutoScalingGroupsSize) {
            sleep(15);
        } else {
            break;
        }
    }

    String autoScalingGroupName = null;
    boolean created = false;
    int maxSize = 0;

    for (int i = 0; i < 30; i++) {
        String json = _jsonWebServiceClient.doGet(
                "/" + availabilityZone + "/cluster/show/" + asgardClusterName + ".json",
                Collections.<String, String>emptyMap());

        JSONArray autoScalingGroupsJSONArray = new JSONArray(json);

        JSONObject autoScalingGroupJSONObject = autoScalingGroupsJSONArray
                .getJSONObject(autoScalingGroupsJSONArray.length() - 1);

        autoScalingGroupName = autoScalingGroupJSONObject.getString("autoScalingGroupName");
        maxSize = autoScalingGroupJSONObject.getInt("maxSize");

        List<String> instanceIds = new ArrayList<String>();

        JSONArray instancesJSONArray = autoScalingGroupJSONObject.getJSONArray("instances");

        for (int j = 0; j < instancesJSONArray.length(); j++) {
            JSONObject instanceJSONObject = instancesJSONArray.getJSONObject(j);

            instanceIds.add(instanceJSONObject.getString("instanceId"));
        }

        if (instanceIds.isEmpty() || !isInService(autoScalingGroupJSONObject)) {

            sleep(15);
        } else {
            CreateTagsRequest createTagsRequest = new CreateTagsRequest();

            createTagsRequest.setResources(instanceIds);

            List<Tag> tags = new ArrayList<Tag>();

            Tag tag = new Tag();

            tag.withKey("Name");
            tag.withValue(properties.getProperty("instance.name"));

            tags.add(tag);

            createTagsRequest.setTags(tags);

            amazonEC2Client.createTags(createTagsRequest);

            CreateOrUpdateTagsRequest createOrUpdateTagsRequest = new CreateOrUpdateTagsRequest();

            com.amazonaws.services.autoscaling.model.Tag autoScalingTag = new com.amazonaws.services.autoscaling.model.Tag();

            autoScalingTag.setKey("Name");
            autoScalingTag.setPropagateAtLaunch(true);
            autoScalingTag.setResourceId(autoScalingGroupName);
            autoScalingTag.setResourceType("auto-scaling-group");
            autoScalingTag.setValue(properties.getProperty("instance.name"));

            createOrUpdateTagsRequest.withTags(autoScalingTag);

            amazonAutoScalingClient.createOrUpdateTags(createOrUpdateTagsRequest);

            created = true;

            break;
        }
    }

    if (!created) {
        throw new RuntimeException("Unable to create Auto Scaling Group " + autoScalingGroupName);
    }

    if (!_parallelDeployment) {
        int minSize = Integer.parseInt(properties.getProperty("instance.min.size"));

        if (minSize > 1) {
            checkAutoScalingGroup(autoScalingGroupName, 1);

            parameters.clear();

            parameters.put("maxSize", String.valueOf(maxSize));
            parameters.put("minSize", String.valueOf(minSize));
            parameters.put("name", autoScalingGroupName);

            _jsonWebServiceClient.doPost("/" + availabilityZone + "/cluster/resize", parameters);

            for (int i = 0; i < 30; i++) {
                String json = _jsonWebServiceClient.doGet(
                        "/" + availabilityZone + "/cluster/show/" + asgardClusterName + ".json",
                        Collections.<String, String>emptyMap());

                JSONArray autoScalingGroupsJSONArray = new JSONArray(json);

                JSONObject autoScalingGroupJSONObject = autoScalingGroupsJSONArray
                        .getJSONObject(autoScalingGroupsJSONArray.length() - 1);

                JSONArray instancesJSONArray = autoScalingGroupJSONObject.getJSONArray("instances");

                if (instancesJSONArray.length() == 1) {
                    sleep(15);
                } else {
                    break;
                }
            }
        }
    }

    return autoScalingGroupName;
}

From source file:net.roboconf.iaas.ec2.IaasEc2.java

License:Apache License

@Override
public String createVM(String messagingIp, String messagingUsername, String messagingPassword,
        String rootInstanceName, String applicationName) throws IaasException {

    String instanceId = null;/*www . ja v a  2  s.c  o  m*/
    try {
        String userData = DataHelpers.writeIaasDataAsString(messagingIp, messagingUsername, messagingPassword,
                applicationName, rootInstanceName);
        RunInstancesRequest runInstancesRequest = prepareEC2RequestNode(
                this.iaasProperties.get(Ec2Constants.AMI_VM_NODE), userData);

        RunInstancesResult runInstanceResult = this.ec2.runInstances(runInstancesRequest);
        instanceId = runInstanceResult.getReservation().getInstances().get(0).getInstanceId();

        // Is there any volume (ID or name) to attach ?
        String snapshotIdToAttach = iaasProperties.get(Ec2Constants.VOLUME_SNAPSHOT_ID);
        if (snapshotIdToAttach != null) {
            boolean running = false;
            while (!running) {
                DescribeInstancesRequest dis = new DescribeInstancesRequest();
                ArrayList<String> instanceIds = new ArrayList<String>();
                instanceIds.add(instanceId);
                dis.setInstanceIds(instanceIds);
                DescribeInstancesResult disresult = ec2.describeInstances(dis);
                running = "running"
                        .equals(disresult.getReservations().get(0).getInstances().get(0).getState().getName());
                if (!running) {
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
            CreateVolumeRequest createVolumeRequest = new CreateVolumeRequest()
                    .withAvailabilityZone("eu-west-1c").withSnapshotId(snapshotIdToAttach);
            //.withSize(2); // The size of the volume, in gigabytes.

            CreateVolumeResult createVolumeResult = ec2.createVolume(createVolumeRequest);

            running = false;
            while (!running) {
                DescribeVolumesRequest dvs = new DescribeVolumesRequest();
                ArrayList<String> volumeIds = new ArrayList<String>();
                volumeIds.add(createVolumeResult.getVolume().getVolumeId());
                DescribeVolumesResult dvsresult = ec2.describeVolumes(dvs);
                running = "available".equals(dvsresult.getVolumes().get(0).getState());
                System.out.println(dvsresult.getVolumes().get(0).getState());
                if (!running) {
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }

            AttachVolumeRequest attachRequest = new AttachVolumeRequest().withInstanceId(instanceId)
                    .withDevice("/dev/sda2").withVolumeId(createVolumeResult.getVolume().getVolumeId());

            AttachVolumeResult attachResult = ec2.attachVolume(attachRequest);
        }

        // Set name tag for instance (human-readable in AWS webapp)
        List<Tag> tags = new ArrayList<Tag>();
        Tag t = new Tag();
        t.setKey("Name");
        t.setValue(applicationName + "." + rootInstanceName);
        tags.add(t);
        CreateTagsRequest ctr = new CreateTagsRequest();
        ctr.setTags(tags);
        ctr.withResources(instanceId);
        this.ec2.createTags(ctr);

    } catch (AmazonServiceException e) {
        this.logger.severe("An error occurred on Amazon while instantiating a machine. " + e.getMessage());
        throw new IaasException(e);

    } catch (AmazonClientException e) {
        this.logger.severe("An error occurred while creating a machine on Amazon EC2. " + e.getMessage());
        throw new IaasException(e);

    } catch (UnsupportedEncodingException e) {
        this.logger.severe("An error occurred while contacting Amazon EC2. " + e.getMessage());
        throw new IaasException(e);

    } catch (IOException e) {
        this.logger.severe("An error occurred while preparing the user data. " + e.getMessage());
        throw new IaasException(e);
    }

    return instanceId;
}

From source file:org.apache.usergrid.chop.api.store.amazon.EC2InstanceManager.java

License:Apache License

/**
 * Launches instances of given cluster./* www . j  av a  2s.c  om*/
 *
 * After launching instances, blocks for maximum <code>timeout</code> amount until all
 * instances get into the Running state.
 *
 * @param stack     <code>ICoordinatedStack</code> object containing the <code>cluster</code>
 * @param cluster
 * @param timeout   in milliseconds, if smaller than <code>getDefaultTimeout()</code> it doesn't wait
 * @return          resulting runner instances which successfully got in Running state
 */
@Override
public LaunchResult launchCluster(ICoordinatedStack stack, ICoordinatedCluster cluster, int timeout) {

    RunInstancesResult runInstancesResult = null;
    try {
        RunInstancesRequest runInstancesRequest = new RunInstancesRequest();

        runInstancesRequest.withImageId(cluster.getInstanceSpec().getImageId())
                .withInstanceType(cluster.getInstanceSpec().getType()).withMinCount(cluster.getSize())
                .withMaxCount(cluster.getSize()).withKeyName(cluster.getInstanceSpec().getKeyName())
                .withSecurityGroups(stack.getIpRuleSet().getName());

        if (stack.getDataCenter() != null && !stack.getDataCenter().isEmpty()) {
            runInstancesRequest = runInstancesRequest.withPlacement(new Placement(stack.getDataCenter()));
            client.setEndpoint(AmazonUtils.getEndpoint(stack.getDataCenter()));
        }

        runInstancesResult = client.runInstances(runInstancesRequest);
    } catch (Exception e) {
        LOG.error("Error while launching cluster instances.", e);
        return new EC2LaunchResult(cluster.getInstanceSpec(), Collections.EMPTY_LIST);
    }

    LOG.info("Created instances, setting the names now...");

    List<String> instanceIds = new ArrayList<String>(cluster.getSize());

    String instanceNames = getInstanceName(stack, cluster);

    int i = 0;
    for (com.amazonaws.services.ec2.model.Instance instance : runInstancesResult.getReservation()
            .getInstances()) {

        try {
            instanceIds.add(i, instance.getInstanceId());
            LOG.debug("Setting name of cluster instance with id: {}", instanceIds.get(i));

            List<Tag> tags = new ArrayList<Tag>();

            Tag t = new Tag();
            t.setKey("Name");
            t.setValue(instanceNames);
            tags.add(t);

            CreateTagsRequest ctr = new CreateTagsRequest();
            ctr.setTags(tags);
            ctr.withResources(instanceIds.get(i));
            client.createTags(ctr);
        } catch (Exception e) {
            LOG.warn("Error while setting names", e);
        }
        i++;
    }

    LOG.info("Names of the instances are set");

    if (timeout > SLEEP_LENGTH) {
        LOG.info("Waiting for maximum {} msec until all instances are running", timeout);
        boolean stateCheck = waitUntil(instanceIds, InstanceState.Running, timeout);

        if (!stateCheck) {
            LOG.warn("Waiting for instances to get into Running state has timed out");
        }
    }

    Collection<Instance> instances = toInstances(getEC2Instances(instanceIds));

    return new EC2LaunchResult(cluster.getInstanceSpec(), instances);
}

From source file:org.apache.usergrid.chop.api.store.amazon.EC2InstanceManager.java

License:Apache License

/**
 * Launches runner instances of given stack.
 *
 * Given <code>ICoordinatedStack</code> and an <code>InstanceSpec</code>
 * defining its runners' instance specifications, launches all runner instances.
 * After launching instances, blocks for maximum <code>timeout</code> amount until all
 * instances get into the Running state.
 *
 * @param stack// w  w w .  j  a  v  a  2 s .c o  m
 * @param spec
 * @param timeout   in milliseconds, if smaller than <code>getDefaultTimeout()</code> it doesn't wait
 * @return          resulting runner instances which successfully got in Running state
 */
@Override
public LaunchResult launchRunners(ICoordinatedStack stack, InstanceSpec spec, int timeout) {

    RunInstancesResult runInstancesResult = null;
    try {
        RunInstancesRequest runInstancesRequest = new RunInstancesRequest();

        runInstancesRequest.withImageId(spec.getImageId()).withInstanceType(spec.getType())
                .withMinCount(stack.getRunnerCount()).withMaxCount(stack.getRunnerCount())
                .withKeyName(spec.getKeyName()).withSecurityGroups(stack.getIpRuleSet().getName());

        if (stack.getDataCenter() != null && !stack.getDataCenter().isEmpty()) {
            runInstancesRequest = runInstancesRequest.withPlacement(new Placement(stack.getDataCenter()));
            client.setEndpoint(AmazonUtils.getEndpoint(stack.getDataCenter()));
        }

        runInstancesResult = client.runInstances(runInstancesRequest);
    } catch (Exception e) {
        LOG.error("Error while launching runner instances.", e);
        return new EC2LaunchResult(spec, Collections.EMPTY_LIST);
    }

    LOG.info("Created instances, setting the names now...");

    List<String> instanceIds = new ArrayList<String>(stack.getRunnerCount());
    String runnerNames = getRunnerName(stack);

    int i = 0;
    for (com.amazonaws.services.ec2.model.Instance instance : runInstancesResult.getReservation()
            .getInstances()) {

        try {
            instanceIds.add(i, instance.getInstanceId());
            LOG.debug("Setting name of runner instance with id: {}", instanceIds.get(i));

            List<Tag> tags = new ArrayList<Tag>();

            Tag t = new Tag();
            t.setKey("Name");
            t.setValue(runnerNames);
            tags.add(t);

            CreateTagsRequest ctr = new CreateTagsRequest();
            ctr.setTags(tags);
            ctr.withResources(instanceIds.get(i));
            client.createTags(ctr);
        } catch (Exception e) {
            LOG.warn("Error while setting names", e);
        }
        i++;
    }

    LOG.info("Names of the instances are set");

    if (timeout > SLEEP_LENGTH) {
        LOG.info("Waiting for maximum {} msec until all instances are running", timeout);
        boolean stateCheck = waitUntil(instanceIds, InstanceState.Running, timeout);

        if (!stateCheck) {
            LOG.warn("Waiting for instances to get into Running state has timed out");
        }
    }

    Collection<Instance> instances = toInstances(getEC2Instances(instanceIds));

    return new EC2LaunchResult(spec, instances);
}

From source file:org.openinfinity.cloud.application.worker.component.EC2Worker.java

License:Apache License

private boolean createCluster(Cluster cluster, String service, EC2Wrapper ec2, String zone, int cloud,
        String key, String secretKey, String image, String instanceType, String needsLoadBalancer)
        throws WorkerException {
    String lbAddresses = "";
    boolean hasLoadBalancer = false;
    String threadName = Thread.currentThread().getName();

    String securityGroupName = "C" + Integer.toString(cluster.getId());
    String securityGroupId = ec2.createSecurityGroup(securityGroupName,
            "Cluster " + Integer.toString(cluster.getId()) + " security group");
    cluster.setSecurityGroupId(securityGroupId);
    cluster.setSecurityGroupName(securityGroupName);
    clusterService.updateCluster(cluster);
    if (cloud == InstanceService.CLOUD_TYPE_AMAZON) {
        //String adminPortalAddress = PropertyManager.getProperty("cloudadmin.worker.adminportal.address.amazon");
        //   ec2.authorizeIPs(cluster.getSecurityGroupName(), "0.0.0.0/0", 22, 22, "tcp");
        String cmtGroup = PropertyManager.getProperty("cloudadmin.worker.cmt.securitygroup.amazon");
        String securityGroupOwner = PropertyManager.getProperty("cloudadmin.worker.amazon.securitygroup.owner");
        //ec2.authorizeIPs(cluster.getSecurityGroupName(), adminPortalAddress+"/32", 22, 22, "tcp");
        //ec2.authorizeIPs(cluster.getSecurityGroupName(), adminPortalAddress+"/32", 8181, 8181, "tcp");
        ec2.authorizeGroup(cluster.getSecurityGroupName(), cmtGroup, securityGroupOwner, 22, 22, "tcp");
        ec2.authorizeGroup(cluster.getSecurityGroupName(), cmtGroup, securityGroupOwner, 8181, 8181, "tcp");
        ec2.authorizeGroup(cluster.getSecurityGroupName(), cluster.getSecurityGroupName(), securityGroupOwner,
                0, 65535, "tcp");
        ec2.authorizeGroup(cluster.getSecurityGroupName(), cluster.getSecurityGroupName(), securityGroupOwner,
                0, 65535, "udp");
        ec2.authorizeGroup(cmtGroup, cluster.getSecurityGroupName(), securityGroupOwner, 0, 65535, "tcp");
        ec2.authorizeGroup(cmtGroup, cluster.getSecurityGroupName(), securityGroupOwner, 0, 65535, "udp");
    } else if (cloud == InstanceService.CLOUD_TYPE_EUCALYPTUS) {
        String adminPortalAddress = PropertyManager.getProperty("cloudadmin.worker.adminportal.address");
        //   ec2.authorizeIPs(cluster.getSecurityGroupName(), "0.0.0.0/0", 22, 22, "tcp");
        ec2.authorizeIPs(cluster.getSecurityGroupName(), adminPortalAddress + "/32", 22, 22, "tcp");
        ec2.authorizeIPs(cluster.getSecurityGroupName(), adminPortalAddress + "/32", 8181, 8181, "tcp");
    }/*from   ww  w  .  ja  v  a 2  s  . c  om*/
    List<String> securityGroups = new ArrayList<String>();
    securityGroups.add(cluster.getSecurityGroupName());
    List<com.amazonaws.services.ec2.model.Instance> instances = new ArrayList<com.amazonaws.services.ec2.model.Instance>();
    if (needsLoadBalancer != null && needsLoadBalancer.equalsIgnoreCase("yes")) {
        if (cloud == InstanceService.CLOUD_TYPE_AMAZON) {
            /* Maybe in the future   String lbDns = ec2.createLoadBalancer(cluster.getLbName(), zone, key);
               if (lbDns == null) {
                  throw new WorkerException("Error creating load balancer for service " + service);
               }
               cluster.setLbDns(lbDns);
               ec2.setAppCookieStickiness("JSESSIONID", "JavaSessionPolicy", cluster.getLbName());
               ec2.setLoadBalancerPoliciesOfListener("JavaSessionPolicy", cluster.getLbName(), 80); */
            /* currently just use the same instance based balancing as in euca */
            Reservation reservation = ec2.createInstance(imageId(cloud, service, 0), 1, key, zone, "m1.small",
                    securityGroups);
            if (reservation == null) {
                ec2.deleteSecurityGroup(cluster.getSecurityGroupName());
                throw new WorkerException("Error creating virtual machines for service " + service);
            }
            instances.addAll(reservation.getInstances());
        } else {
            //cluster.setNumberOfMachines(cluster.getNumberOfMachines()+1);

            Reservation reservation = ec2.createInstance(imageId(cloud, service, 0), 1, key, zone, "m1.small",
                    securityGroups);
            if (reservation == null) {
                ec2.deleteSecurityGroup(cluster.getSecurityGroupName());
                throw new WorkerException("Error creating virtual machines for service " + service);
            }
            instances.addAll(reservation.getInstances());
        }
        clusterService.updateCluster(cluster);
        hasLoadBalancer = true;
    }

    Reservation reservation = ec2.createInstance(image, cluster.getNumberOfMachines(), key, zone, instanceType,
            securityGroups);
    if (reservation == null) {
        ec2.deleteLoadBalancer(cluster.getLbName(), cluster.getLbInstanceId());
        ec2.deleteSecurityGroup(cluster.getSecurityGroupName());
        throw new WorkerException("Error creating virtual machines for service " + service);
    }
    instances.addAll(reservation.getInstances());
    Iterator<com.amazonaws.services.ec2.model.Instance> ite = instances.iterator();
    Collection<String> machinesToTag = new ArrayList<String>();
    //   Collection<com.amazonaws.services.elasticloadbalancing.model.Instance> lbInstanceList = new ArrayList<com.amazonaws.services.elasticloadbalancing.model.Instance>();
    boolean loadBalancerMarked = false;
    while (ite.hasNext()) {

        com.amazonaws.services.ec2.model.Instance tempInstance = ite.next();
        Machine machine = new Machine();
        machine.setName(cluster.getName());
        machine.setCloud(cloud);

        machine.setInstanceId(tempInstance.getInstanceId());
        LOG.debug(threadName + ": Instance " + tempInstance.getInstanceId() + " root device type: "
                + tempInstance.getRootDeviceType());
        if (tempInstance.getInstanceType().equalsIgnoreCase("m1.small") && !loadBalancerMarked
                && hasLoadBalancer && tempInstance.getRootDeviceType().equalsIgnoreCase("instance-store")) {
            machine.setType("loadbalancer");
            loadBalancerMarked = true;
            cluster.setLbInstanceId(machine.getInstanceId());
            clusterService.updateCluster(cluster);
        } else {
            machine.setType("clustermember");

            if (cluster.getEbsVolumesUsed() > 0) {
                String volumeId = ec2.createVolume(cluster.getEbsVolumesUsed(), zone);
                machine.setEbsVolumeId(volumeId);
                machine.setEbsVolumeSize(cluster.getEbsVolumesUsed());
            }
        }
        int maxWait = 500;
        while ((tempInstance.getPrivateDnsName().equals("0.0.0.0")
                || tempInstance.getPrivateDnsName().startsWith("euca-0-0-0-0")) && maxWait > 0) {
            LOG.info(threadName + ": Could not get IP address yet, waiting for a moment");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                LOG.error(threadName + ": Something interrupted my sleep: " + e.getMessage());
            }
            maxWait--;
            tempInstance = ec2.describeInstance(tempInstance.getInstanceId());
        }
        LOG.info(threadName + ": Private dns name: " + tempInstance.getPrivateDnsName());
        LOG.info(threadName + ": Private IP address: " + tempInstance.getPrivateIpAddress());
        /*   AuthorizationRoute ip = new AuthorizationRoute();
           if(tempInstance.getPrivateIpAddress() == null) {
              ip.setCidrIp(tempInstance.getPrivateDnsName()+"/32");
           } else {
              ip.setCidrIp(tempInstance.getPrivateIpAddress()+"/32");
           }
           ip.setClusterId(cluster.getId());
           ip.setInstanceId(cluster.getInstanceId());
           ip.setFromPort(0);
           ip.setToPort(65535);
           ip.setProtocol("tcp");
           ip.setSecurityGroupName(cluster.getSecurityGroupName());
           arService.addIP(ip); */
        machine.setDnsName(tempInstance.getPublicDnsName());
        machine.setPrivateDnsName(tempInstance.getPrivateDnsName());
        machine.setState(tempInstance.getState().getName());
        machine.setClusterId(cluster.getId());
        if (cloud == InstanceService.CLOUD_TYPE_AMAZON) {
            machine.setUserName("ec2-user");
        } else {
            machine.setUserName("root");
        }
        machine.setConfigured(0);
        machine.setRunning(1);

        machineService.addMachine(machine);

        // Usage Service implementation
        Instance instance = instanceService.getInstance(cluster.getInstanceId());
        try {
            usageService.startVirtualMachineUsageMonitoring(instance.getOrganizationid(), cluster.getType(),
                    cluster.getId(), machine.getId());
        } catch (Exception e) {
            LOG.error(threadName + ": Error starting usage monitoring");
        }

        machinesToTag.add(tempInstance.getInstanceId());
        /*   if(tempInstance.getInstanceType().equalsIgnoreCase("m1.small")) {
              com.amazonaws.services.elasticloadbalancing.model.Instance lbI = new com.amazonaws.services.elasticloadbalancing.model.Instance();
              lbI.setInstanceId(tempInstance.getInstanceId());
              lbInstanceList.add(lbI);
           } */

    }
    //LOG.info("Addresses: "+lbAddresses);
    Tag clusterNameTag = new Tag();
    clusterNameTag.setKey("Name");
    clusterNameTag.setValue(cluster.getName());
    Collection<Tag> tags = new ArrayList<Tag>();
    tags.add(clusterNameTag);
    ec2.setTags(tags, machinesToTag);
    /*   if(needsLoadBalancer != null && needsLoadBalancer.equalsIgnoreCase("yes")) {
          ec2.registerInstancesToLoadBalancer(lbInstanceList, cluster.getLbName(), lbAddresses, secretKey);
       } */

    return true;
}