Example usage for com.amazonaws.services.ec2.model LaunchSpecification withNetworkInterfaces

Introduction

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

Prototype

public LaunchSpecification withNetworkInterfaces(
        java.util.Collection<InstanceNetworkInterfaceSpecification> networkInterfaces) 

Source Link

Document

One or more network interfaces.

Usage

From source file:hudson.plugins.ec2.SlaveTemplate.java

License:Open Source License

/**
 * Provision a new slave for an EC2 spot instance to call back to Jenkins
 *//*  w w  w .  ja  v a 2 s  .  c  o m*/
private EC2AbstractSlave provisionSpot(TaskListener listener) throws AmazonClientException, IOException {
    PrintStream logger = listener.getLogger();
    AmazonEC2 ec2 = getParent().connect();

    try {
        logger.println("Launching " + ami + " for template " + description);
        KeyPair keyPair = getKeyPair(ec2);

        RequestSpotInstancesRequest spotRequest = new RequestSpotInstancesRequest();

        // Validate spot bid before making the request
        if (getSpotMaxBidPrice() == null) {
            // throw new FormException("Invalid Spot price specified: " + getSpotMaxBidPrice(), "spotMaxBidPrice");
            throw new AmazonClientException("Invalid Spot price specified: " + getSpotMaxBidPrice());
        }

        spotRequest.setSpotPrice(getSpotMaxBidPrice());
        spotRequest.setInstanceCount(Integer.valueOf(1));
        spotRequest.setType(getBidType());

        LaunchSpecification launchSpecification = new LaunchSpecification();
        InstanceNetworkInterfaceSpecification net = new InstanceNetworkInterfaceSpecification();

        launchSpecification.setImageId(ami);
        launchSpecification.setInstanceType(type);

        if (StringUtils.isNotBlank(getZone())) {
            SpotPlacement placement = new SpotPlacement(getZone());
            launchSpecification.setPlacement(placement);
        }

        if (StringUtils.isNotBlank(getSubnetId())) {
            if (getAssociatePublicIp()) {
                net.setSubnetId(getSubnetId());
            } else {
                launchSpecification.setSubnetId(getSubnetId());
            }

            /* If we have a subnet ID then we can only use VPC security groups */
            if (!securityGroupSet.isEmpty()) {
                List<String> group_ids = getEc2SecurityGroups(ec2);
                if (!group_ids.isEmpty()) {
                    if (getAssociatePublicIp()) {
                        net.setGroups(group_ids);
                    } else {
                        ArrayList<GroupIdentifier> groups = new ArrayList<GroupIdentifier>();

                        for (String group_id : group_ids) {
                            GroupIdentifier group = new GroupIdentifier();
                            group.setGroupId(group_id);
                            groups.add(group);
                        }
                        if (!groups.isEmpty())
                            launchSpecification.setAllSecurityGroups(groups);
                    }
                }
            }
        } else {
            /* No subnet: we can use standard security groups by name */
            if (securityGroupSet.size() > 0)
                launchSpecification.setSecurityGroups(securityGroupSet);
        }

        // The slave must know the Jenkins server to register with as well
        // as the name of the node in Jenkins it should register as. The only
        // way to give information to the Spot slaves is through the ec2 user data
        String jenkinsUrl = Hudson.getInstance().getRootUrl();
        // We must provide a unique node name for the slave to connect to Jenkins.
        // We don't have the EC2 generated instance ID, or the Spot request ID
        // until after the instance is requested, which is then too late to set the
        // user-data for the request. Instead we generate a unique name from UUID
        // so that the slave has a unique name within Jenkins to register to.
        String slaveName = UUID.randomUUID().toString();
        String newUserData = "";

        // We want to allow node configuration with cloud-init and user-data,
        // while maintaining backward compatibility with old ami's
        // The 'new' way is triggered by the presence of '${SLAVE_NAME}'' in the user data 
        // (which is not too much to ask)
        if (userData.contains("${SLAVE_NAME}")) {
            // The cloud-init compatible way
            newUserData = new String(userData);
            newUserData = newUserData.replace("${SLAVE_NAME}", slaveName);
            newUserData = newUserData.replace("${JENKINS_URL}", jenkinsUrl);
        } else {
            // The 'old' way - maitain full backward compatibility
            newUserData = "JENKINS_URL=" + jenkinsUrl + "&SLAVE_NAME=" + slaveName + "&USER_DATA="
                    + Base64.encodeBase64String(userData.getBytes());
        }

        String userDataString = Base64.encodeBase64String(newUserData.getBytes());

        launchSpecification.setUserData(userDataString);
        launchSpecification.setKeyName(keyPair.getKeyName());
        launchSpecification.setInstanceType(type.toString());

        if (getAssociatePublicIp()) {
            net.setAssociatePublicIpAddress(true);
            net.setDeviceIndex(0);
            launchSpecification.withNetworkInterfaces(net);
        }

        boolean hasCustomTypeTag = false;
        HashSet<Tag> inst_tags = null;
        if (tags != null && !tags.isEmpty()) {
            inst_tags = new HashSet<Tag>();
            for (EC2Tag t : tags) {
                inst_tags.add(new Tag(t.getName(), t.getValue()));
                if (StringUtils.equals(t.getName(), EC2Tag.TAG_NAME_JENKINS_SLAVE_TYPE)) {
                    hasCustomTypeTag = true;
                }
            }
        }
        if (!hasCustomTypeTag) {
            inst_tags.add(new Tag(EC2Tag.TAG_NAME_JENKINS_SLAVE_TYPE, "spot"));
        }

        if (StringUtils.isNotBlank(getIamInstanceProfile())) {
            launchSpecification.setIamInstanceProfile(
                    new IamInstanceProfileSpecification().withArn(getIamInstanceProfile()));
        }

        spotRequest.setLaunchSpecification(launchSpecification);

        // Make the request for a new Spot instance
        RequestSpotInstancesResult reqResult = ec2.requestSpotInstances(spotRequest);

        List<SpotInstanceRequest> reqInstances = reqResult.getSpotInstanceRequests();
        if (reqInstances.size() <= 0) {
            throw new AmazonClientException("No spot instances found");
        }

        SpotInstanceRequest spotInstReq = reqInstances.get(0);
        if (spotInstReq == null) {
            throw new AmazonClientException("Spot instance request is null");
        }

        /* Now that we have our Spot request, we can set tags on it */
        if (inst_tags != null) {
            for (int i = 0; i < 5; i++) {
                try {
                    updateRemoteTags(ec2, inst_tags, spotInstReq.getSpotInstanceRequestId());
                    break;
                } catch (AmazonServiceException e) {
                    if (e.getErrorCode().equals("InvalidSpotInstanceRequestID.NotFound")) {
                        Thread.sleep(5000);
                        continue;
                    }
                    throw e;
                }
            }

            // That was a remote request - we should also update our local instance data.
            spotInstReq.setTags(inst_tags);
        }

        logger.println("Spot instance id in provision: " + spotInstReq.getSpotInstanceRequestId());

        return newSpotSlave(spotInstReq, slaveName);

    } catch (FormException e) {
        throw new AssertionError(); // we should have discovered all configuration issues upfront
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
}

---