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

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

  1. HOME
  2. Java
  3. com.amazonaws
  4. com.amazonaws.services.ec2.model.*
  5. Tag
  6. Tag

Introduction

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

Prototype

public Tag()

Source Link

Document

Default constructor for Tag object.

Usage

From source file:aws.example.ec2.CreateInstance.java

License:Open Source License

public static void main(String[] args) {
    final String USAGE = "To run this example, supply an instance name and AMI image id\n"
            + "Ex: CreateInstance <instance-name> <ami-image-id>\n";

    if (args.length != 2) {
        System.out.println(USAGE);
        System.exit(1);/*w  ww  .j ava 2 s  .c  om*/
    }

    String name = args[0];
    String ami_id = args[1];

    final AmazonEC2 ec2 = AmazonEC2ClientBuilder.defaultClient();

    RunInstancesRequest run_request = new RunInstancesRequest().withImageId(ami_id)
            .withInstanceType(InstanceType.T1Micro).withMaxCount(1).withMinCount(1);

    RunInstancesResult run_response = ec2.runInstances(run_request);

    String instance_id = run_response.getReservation().getReservationId();

    Tag tag = new Tag().withKey("Name").withValue(name);

    CreateTagsRequest tag_request = new CreateTagsRequest().withTags(tag);

    CreateTagsResult tag_response = ec2.createTags(tag_request);

    System.out.printf("Successfully started EC2 instance %s based on AMI %s", instance_id, ami_id);
}

From source file:com.deploymentio.ec2namer.helpers.InstanceTagger.java

License:Apache License

/**
 * Tags the EC2 instance we are naming. The tag's name/values are provided
 * in the request. Additionally, if no <code>Name</code> tag is provided,
 * this method will add one in the format of
 * <code>{environment}:{reserved-name}</code>.
 * /*  w w  w. ja  va  2 s.co m*/
 * @param req
 *            the namer request
 * @param context
 *            the lambda function execution context
 * @param name
 *            the reserved name for this instance
 * @throws IOException
 *             if the instance cannot be tagged
 */
public void tag(NamerRequest req, LambdaContext context, ReservedName name) throws IOException {

    HashMap<String, String> map = new HashMap<>(req.getRequestedTags());
    if (!map.containsKey("Name")) {
        map.put("Name", req.getEnvironment() + ":" + name.getHostname());
    }

    ArrayList<Tag> tags = new ArrayList<>();
    for (String key : map.keySet()) {
        String val = map.get(key);
        tags.add(new Tag().withKey(key).withValue(val));
    }

    ec2.createTags(new CreateTagsRequest().withResources(req.getInstanceId()).withTags(tags));
}

From source file:com.epam.dlab.automation.cloud.aws.AmazonHelper.java

License:Apache License

public static Instance getInstance(String instanceName) {
    return (ConfigPropertyValue.isRunModeLocal()
            ? new Instance().withPrivateDnsName("localhost").withPrivateIpAddress(LOCALHOST_IP)
                    .withPublicDnsName("localhost").withPublicIpAddress(LOCALHOST_IP)
                    .withTags(new Tag().withKey("Name").withValue(instanceName))
            : getInstances(instanceName).get(0));
}

From source file:com.kpbird.aws.Main.java

private void createEC2OnDemandInstance() {
    try {/*from w  ww  . j a  v  a 2s  . co  m*/

        // request for new on demand instance
        RunInstancesRequest rir = new RunInstancesRequest();
        rir.withImageId(imageId);
        rir.withInstanceType(instanceType);
        rir.withMinCount(1);
        rir.withMaxCount(1);
        rir.withKeyName(keyName);
        rir.withMonitoring(true);
        rir.withSecurityGroups(groupName);

        RunInstancesResult riresult = ec2client.runInstances(rir);
        log.Info(riresult.getReservation().getReservationId());

        /// Find newly created instance id
        String instanceId = null;
        DescribeInstancesResult result = ec2client.describeInstances();
        Iterator<Reservation> i = result.getReservations().iterator();
        while (i.hasNext()) {
            Reservation r = i.next();
            List<Instance> instances = r.getInstances();
            for (Instance ii : instances) {
                log.Info(ii.getImageId() + "\t" + ii.getInstanceId() + "\t" + ii.getState().getName() + "\t"
                        + ii.getPrivateDnsName());
                if (ii.getState().getName().equals("pending")) {
                    instanceId = ii.getInstanceId();
                }
            }
        }

        log.Info("New Instance ID :" + instanceId);
        /// Waiting for Instance Running////
        boolean isWaiting = true;
        while (isWaiting) {
            log.Info("*** Waiting ***");
            Thread.sleep(1000);
            DescribeInstancesResult r = ec2client.describeInstances();
            Iterator<Reservation> ir = r.getReservations().iterator();
            while (ir.hasNext()) {
                Reservation rr = ir.next();
                List<Instance> instances = rr.getInstances();
                for (Instance ii : instances) {
                    log.Info(ii.getImageId() + "\t" + ii.getInstanceId() + "\t" + ii.getState().getName() + "\t"
                            + ii.getPrivateDnsName());
                    if (ii.getState().getName().equals("running") && ii.getInstanceId().equals(instanceId)) {
                        log.Info(ii.getPublicDnsName());
                        isWaiting = false;
                    }
                }
            }
        }

        /// Creating Tag for New Instance ////
        log.Info("Creating Tags for New Instance");
        CreateTagsRequest crt = new CreateTagsRequest();
        ArrayList<Tag> arrTag = new ArrayList<Tag>();
        arrTag.add(new Tag().withKey("Name").withValue(instanceName));
        crt.setTags(arrTag);

        ArrayList<String> arrInstances = new ArrayList<String>();
        arrInstances.add(instanceId);
        crt.setResources(arrInstances);
        ec2client.createTags(crt);

    } catch (Exception e) {
        e.printStackTrace();
        System.exit(0);
    }
}

From source file:com.kpbird.aws.Main.java

private void createEC2SpotInstance() {
    try {//  w w w .j  a v  a2s.  c o m
        /// Creating Spot Instance ////

        // Initializes a Spot Instance Request
        RequestSpotInstancesRequest requestRequest = new RequestSpotInstancesRequest();
        // Request 1 x t1.micro instance with a bid price of $0.03.
        requestRequest.setSpotPrice(spotPrice);
        requestRequest.setInstanceCount(Integer.valueOf(1));
        LaunchSpecification launchSpecification = new LaunchSpecification();
        launchSpecification.setImageId(imageId);
        launchSpecification.setInstanceType(instanceType);
        launchSpecification.setMonitoringEnabled(true);

        // Add the security group to the request.
        ArrayList<String> securityGroups = new ArrayList<String>();
        securityGroups.add(groupName);
        launchSpecification.setSecurityGroups(securityGroups);

        launchSpecification.setKeyName(keyName);

        // Add the launch specifications to the request.
        requestRequest.setLaunchSpecification(launchSpecification);

        // Call the RequestSpotInstance API.
        RequestSpotInstancesResult requestResult = ec2client.requestSpotInstances(requestRequest);

        List<SpotInstanceRequest> requestResponses = requestResult.getSpotInstanceRequests();

        // Setup an arraylist to collect all of the request ids we want to
        // watch hit the running state.
        ArrayList<String> spotInstanceRequestIds = new ArrayList<String>();

        // Add all of the request ids to the hashset, so we can determine when they hit the
        // active state.
        for (SpotInstanceRequest requestResponse : requestResponses) {
            System.out.println("Created Spot Request: " + requestResponse.getSpotInstanceRequestId());
            spotInstanceRequestIds.add(requestResponse.getSpotInstanceRequestId());
            log.Info(requestResponse.getInstanceId() + "\t" + requestResponse.getState());
        }

        String instanceId = null;
        boolean isWaiting = true;
        while (isWaiting) {
            log.Info("*** Waiting for Spot Instance Request ***");
            Thread.sleep(5000);
            DescribeSpotInstanceRequestsRequest describeRequest = new DescribeSpotInstanceRequestsRequest();
            describeRequest.setSpotInstanceRequestIds(spotInstanceRequestIds);

            DescribeSpotInstanceRequestsResult describeResult = ec2client
                    .describeSpotInstanceRequests(describeRequest);
            List<SpotInstanceRequest> describeResponses = describeResult.getSpotInstanceRequests();
            for (SpotInstanceRequest describeResponse : describeResponses) {
                log.Info(describeResponse.getInstanceId() + "\t" + describeResponse.getState() + "\t"
                        + describeResponse.getSpotInstanceRequestId() + "\t"
                        + describeResponse.getStatus().getCode() + "\t"
                        + describeResponse.getStatus().getMessage());
                if (describeResponse.getState().equals("active")) {
                    isWaiting = false;
                    instanceId = describeResponse.getInstanceId();
                    break;
                }
            }

        }
        isWaiting = true;
        while (isWaiting) {
            log.Info("*** Waiting for Instance Running ***");
            Thread.sleep(1000);
            DescribeInstancesResult r = ec2client.describeInstances();
            Iterator<Reservation> ir = r.getReservations().iterator();
            while (ir.hasNext()) {
                Reservation rr = ir.next();
                List<Instance> instances = rr.getInstances();
                for (Instance ii : instances) {
                    log.Info(ii.getImageId() + "\t" + ii.getInstanceId() + "\t" + ii.getState().getName() + "\t"
                            + ii.getPrivateDnsName());
                    if (ii.getState().getName().equals("running") && ii.getInstanceId().equals(instanceId)) {
                        log.Info(ii.getPublicDnsName());
                        String publicDNS = ii.getPublicDnsName();
                        log.Info("Public DNS :" + publicDNS);
                        isWaiting = false;
                    }
                }
            }
        }

        /// Creating Tag for New Instance ////
        log.Info("Creating Tags for New Instance");
        CreateTagsRequest crt = new CreateTagsRequest();
        ArrayList<Tag> arrTag = new ArrayList<Tag>();
        arrTag.add(new Tag().withKey("Name").withValue(instanceName));
        crt.setTags(arrTag);

        ArrayList<String> arrInstances = new ArrayList<String>();
        arrInstances.add(instanceId);
        crt.setResources(arrInstances);
        ec2client.createTags(crt);

    } catch (Exception e) {
        e.printStackTrace();
    }
}

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");
    }//www  .j ava2s.c  om

    _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:com.vmware.photon.controller.model.adapters.awsadapter.AWSUtils.java

License:Open Source License

public static void createTags(String resourceID, Map<String, String> tags, AmazonEC2AsyncClient client) {
    ArrayList<Tag> awsTags = new ArrayList<>();
    if (tags != null) {
        tags.forEach((k, v) -> {// w  w w  .j a v  a 2s  .  co  m
            Tag t = new Tag().withKey(k).withValue(v);
            awsTags.add(t);
        });
    }
    ArrayList<String> resource = new ArrayList<>();
    resource.add(resourceID);
    createTags(resource, awsTags, client);
}

From source file:com.vmware.photon.controller.model.adapters.awsadapter.AWSUtils.java

License:Open Source License

public static void setResourceName(String resourceID, String name, AmazonEC2AsyncClient client) {
    Tag awsName = new Tag().withKey(AWS_TAG_NAME).withValue(name);
    ArrayList<Tag> tags = new ArrayList<>();
    tags.add(awsName);// w w  w  .  j  a  va 2  s.  c om
    ArrayList<String> resource = new ArrayList<>();
    resource.add(resourceID);
    createTags(resource, tags, client);
}

From source file:de.unibi.cebitec.bibigrid.meta.aws.CreateClusterAWS.java

@Override
public CreateClusterEnvironmentAWS createClusterEnvironment() {
    ////////////////////////////////////////////////////////////////////////
    ///// create client and unique cluster-id //////////////////////////////
    ec2 = new AmazonEC2Client(this.config.getCredentials());
    ec2.setEndpoint("ec2." + this.config.getRegion() + ".amazonaws.com");

    // Cluster ID is a cut down base64 encoded version of a random UUID:
    UUID clusterIdUUID = UUID.randomUUID();
    ByteBuffer bb = ByteBuffer.wrap(new byte[16]);
    bb.putLong(clusterIdUUID.getMostSignificantBits());
    bb.putLong(clusterIdUUID.getLeastSignificantBits());
    String clusterIdBase64 = Base64.encodeBase64URLSafeString(bb.array()).replace("-", "").replace("_", "");
    int len = clusterIdBase64.length() >= 15 ? 15 : clusterIdBase64.length();
    clusterId = clusterIdBase64.substring(0, len);
    bibigridid = new Tag().withKey("bibigrid-id").withValue(clusterId);
    username = new Tag().withKey("user").withValue(config.getUser());
    log.debug("cluster id: {}", clusterId);

    return environment = new CreateClusterEnvironmentAWS(this);
}

From source file:de.unibi.cebitec.bibigrid.meta.aws.CreateClusterAWS.java

@Override
public boolean launchClusterInstances() {
    log.info("Requesting master instance ...");

    if (config.isUseSpotInstances()) {
        RequestSpotInstancesRequest masterReq = new RequestSpotInstancesRequest();
        masterReq.withType(SpotInstanceType.OneTime).withInstanceCount(1).withLaunchGroup("lg_" + clusterId)
                .withSpotPrice(Double.toString(config.getBidPriceMaster()));

        LaunchSpecification masterLaunchSpecification = new LaunchSpecification();
        masterLaunchSpecification//  w  ww  . java2s  .  c  om
                .withInstanceType(InstanceType.fromValue(this.config.getMasterInstanceType().getValue()))
                .withPlacement(spotInstancePlacement).withKeyName(this.config.getKeypair())
                .withImageId(this.config.getMasterImage()).withUserData(base64MasterUserData)
                .withBlockDeviceMappings(masterDeviceMappings).withNetworkInterfaces(masterNetworkInterfaces);

        masterReq.setLaunchSpecification(masterLaunchSpecification);

        RequestSpotInstancesResult masterReqResult = ec2.requestSpotInstances(masterReq);

        List<SpotInstanceRequest> masterReqResponses = masterReqResult.getSpotInstanceRequests();
        // collect all spotInstanceRequestIds ...
        List<String> spotInstanceRequestIds = new ArrayList<>();

        for (SpotInstanceRequest requestResponse : masterReqResponses) {

            spotInstanceRequestIds.add(requestResponse.getSpotInstanceRequestId());

        }
        // Tag spotrequest
        CreateTagsRequest ctr = new CreateTagsRequest();
        ctr.withResources(spotInstanceRequestIds);
        ctr.withTags(bibigridid, username, new Tag().withKey("Name").withValue(PREFIX + "master-" + clusterId));
        ec2.createTags(ctr);
        // Wait for spot request finished  
        log.info("Waiting for master instance (spot request) to finish booting ...");
        masterInstance = waitForInstances(waitForSpotInstances(spotInstanceRequestIds)).get(0);
    } else {

        RunInstancesRequest masterReq = new RunInstancesRequest();
        masterReq.withInstanceType(InstanceType.fromValue(this.config.getMasterInstanceType().getValue()))
                .withMinCount(1).withMaxCount(1).withPlacement(instancePlacement)
                .withKeyName(this.config.getKeypair()).withImageId(this.config.getMasterImage())
                .withUserData(base64MasterUserData).withBlockDeviceMappings(masterDeviceMappings)
                .withNetworkInterfaces(masterNetworkInterfaces);

        // mounting ephemerals
        RunInstancesResult masterReqResult = ec2.runInstances(masterReq);
        String masterReservationId = masterReqResult.getReservation().getReservationId();
        masterInstance = masterReqResult.getReservation().getInstances().get(0);
        log.info("Waiting for master instance to finish booting ...");

        /////////////////////////////////////////////
        //// Waiting for master instance to run ////
        masterInstance = waitForInstances(Arrays.asList(new String[] { masterInstance.getInstanceId() }))
                .get(0);

    }
    log.info(I, "Master instance is now running!");

    ModifyInstanceAttributeRequest ia_req = new ModifyInstanceAttributeRequest();
    ia_req.setInstanceId(masterInstance.getInstanceId());
    ia_req.setSourceDestCheck(Boolean.FALSE);
    ec2.modifyInstanceAttribute(ia_req);

    ////////////////////////////////////
    //// Tagging Master with a name ////
    CreateTagsRequest masterNameTagRequest = new CreateTagsRequest();
    masterNameTagRequest.withResources(masterInstance.getInstanceId()).withTags(bibigridid, username,
            new Tag().withKey("Name").withValue(PREFIX + "master-" + clusterId));

    ec2.createTags(masterNameTagRequest);

    /*
     * Waiting for Status Checks to finish
     *
     */
    log.info("Waiting for Status Checks on master ...");
    do {
        DescribeInstanceStatusRequest request = new DescribeInstanceStatusRequest();
        request.setInstanceIds((Arrays.asList(new String[] { masterInstance.getInstanceId() })));

        DescribeInstanceStatusResult response = ec2.describeInstanceStatus(request);

        InstanceStatus status = response.getInstanceStatuses().get(0);
        String instanceStatus = status.getInstanceStatus().getStatus();
        String systemStatus = status.getSystemStatus().getStatus();
        log.debug("Status of master instance: " + instanceStatus + "," + systemStatus);
        if (instanceStatus.equalsIgnoreCase("ok") && systemStatus.equalsIgnoreCase("ok")) {
            break;
        } else {
            log.info(V, "...");
            sleep(10);
        }
    } while (true);
    log.info(I, "Status checks successful.");
    ////////////////////////////////////////////////////////////////////////
    ///// run slave instances and supply userdata //////////////////////////

    if (config.getSlaveInstanceCount() > 0) {

        String base64SlaveUserData = UserDataCreator.forSlave(masterInstance.getPrivateIpAddress(),
                masterInstance.getPrivateDnsName(), slaveDeviceMapper, this.config, environment.getKeypair());

        log.info(V, "Slave Userdata:\n{}", new String(Base64.decodeBase64(base64SlaveUserData)));

        if (config.isUseSpotInstances()) {
            RequestSpotInstancesRequest slaveReq = new RequestSpotInstancesRequest();
            slaveReq.withType(SpotInstanceType.OneTime).withInstanceCount(config.getSlaveInstanceCount())
                    .withLaunchGroup("lg_" + clusterId).withSpotPrice(Double.toString(config.getBidPrice()));

            LaunchSpecification slaveLaunchSpecification = new LaunchSpecification();
            slaveLaunchSpecification
                    .withInstanceType(InstanceType.fromValue(this.config.getSlaveInstanceType().getValue()))
                    .withPlacement(spotInstancePlacement).withKeyName(this.config.getKeypair())
                    .withImageId(this.config.getSlaveImage()).withUserData(base64SlaveUserData)
                    .withBlockDeviceMappings(slaveBlockDeviceMappings)
                    .withNetworkInterfaces(slaveNetworkInterfaces);

            slaveReq.setLaunchSpecification(slaveLaunchSpecification);

            RequestSpotInstancesResult slaveReqResult = ec2.requestSpotInstances(slaveReq);

            List<SpotInstanceRequest> slaveReqResponses = slaveReqResult.getSpotInstanceRequests();
            // collect all spotInstanceRequestIds ...
            List<String> spotInstanceRequestIds = new ArrayList<>();

            for (SpotInstanceRequest requestResponse : slaveReqResponses) {

                spotInstanceRequestIds.add(requestResponse.getSpotInstanceRequestId());

            }
            // wait for a second
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {

            }

            log.info(V, "tag spot request instances");

            // tag spot requests (slave)
            CreateTagsRequest ctr = new CreateTagsRequest();
            ctr.withResources(spotInstanceRequestIds);
            ctr.withTags(bibigridid, username,
                    new Tag().withKey("Name").withValue(PREFIX + "slave-" + clusterId));
            /* Setting tags for spot requests can cause an amazon service 
             exception, if the spot request returns an id, but the id 
             isn't registered in spot request registy yet. */
            int counter = 0;
            boolean finished = false;
            while (!finished) {
                try {
                    ec2.createTags(ctr);
                    finished = true;
                } catch (AmazonServiceException ase) {
                    if (counter < 5) {
                        log.warn("{} ... try again in 10 seconds.", ase.getMessage());
                        try {
                            Thread.sleep(10000);
                        } catch (InterruptedException e) {
                        }
                        counter++;
                    } else {
                        throw ase;
                    }
                }
            }
            log.info("Waiting for slave instance(s) (spot request) to finish booting ...");
            // wait for spot request (slave) finished
            slaveInstances = waitForInstances(waitForSpotInstances(spotInstanceRequestIds));

        } else {

            RunInstancesRequest slaveReq = new RunInstancesRequest();
            slaveReq.withInstanceType(InstanceType.fromValue(this.config.getSlaveInstanceType().getValue()))
                    .withMinCount(this.config.getSlaveInstanceCount())
                    .withMaxCount(this.config.getSlaveInstanceCount()).withPlacement(instancePlacement)
                    .withKeyName(this.config.getKeypair()).withImageId(this.config.getSlaveImage())
                    .withUserData(base64SlaveUserData).withBlockDeviceMappings(slaveBlockDeviceMappings)
                    .withNetworkInterfaces(slaveNetworkInterfaces);

            RunInstancesResult slaveReqResult = ec2.runInstances(slaveReq);
            String slaveReservationId = slaveReqResult.getReservation().getReservationId();
            // create a list of all slave instances
            List<String> slaveInstanceListIds = new ArrayList<>();
            for (Instance i : slaveReqResult.getReservation().getInstances()) {
                slaveInstanceListIds.add(i.getInstanceId());
            }

            log.info("Waiting for slave instance(s) to finish booting ...");
            slaveInstances = waitForInstances(slaveInstanceListIds);

        }

        /////////////////////////////////////////////
        //// Waiting for master instance to run ////
        log.info(I, "Slave instance(s) is now running!");

        ////////////////////////////////////
        //// Tagging all slaves  with a name
        for (Instance si : slaveInstances) {
            CreateTagsRequest slaveNameTagRequest = new CreateTagsRequest();
            slaveNameTagRequest.withResources(si.getInstanceId()).withTags(bibigridid, username,
                    new Tag().withKey("Name").withValue(PREFIX + "slave-" + clusterId));
            ec2.createTags(slaveNameTagRequest);
        }
    } else {
        log.info("No Slave instance(s) requested !");

    }

    //////////////////////////////////
    ////// post configure master
    configureMaster();

    ////////////////////////////////////
    //// Human friendly output
    StringBuilder sb = new StringBuilder();
    sb.append("\n You might want to set the following environment variable:\n\n");
    sb.append("export BIBIGRID_MASTER=").append(masterInstance.getPublicIpAddress()).append("\n\n");
    sb.append("You can then log on the master node with:\n\n").append("ssh -i ")
            .append(config.getIdentityFile()).append(" ubuntu@$BIBIGRID_MASTER\n\n");
    sb.append("The cluster id of your started cluster is : ").append(clusterId).append("\n\n");
    sb.append("The can easily terminate the cluster at any time with :\n").append("./bibigrid -t ")
            .append(clusterId).append(" ");
    if (getConfig().isAlternativeConfigFile()) {
        sb.append("-o ").append(config.getAlternativeConfigPath()).append(" ");
    }

    sb.append("\n");

    log.info(sb.toString());

    ////////////////////////////////////
    //// Grid Properties file
    if (getConfig().getGridPropertiesFile() != null) {
        Properties gp = new Properties();
        gp.setProperty("BIBIGRID_MASTER", masterInstance.getPublicIpAddress());
        gp.setProperty("IdentityFile", getConfig().getIdentityFile().toString());
        gp.setProperty("clusterId", clusterId);
        if (getConfig().isAlternativeConfigFile()) {
            gp.setProperty("AlternativeConfigFile", config.getAlternativeConfigPath());
        }
        try {
            gp.store(new FileOutputStream(getConfig().getGridPropertiesFile()), "Autogenerated by BiBiGrid");
        } catch (IOException e) {
            log.error(I, "Exception while creating grid properties file : " + e.getMessage());
        }
    }

    return true;
}