/**
* The names of the security groups into which the instances will be launched.
*
* <p>Returns a reference to this object so that method calls can be chained together.
*
* @param securityGroups The names of the security groups into which the instances will be
* launched.
* @return A reference to this updated object so that method calls can be chained together.
*/
public RunInstancesRequest withSecurityGroups(String... securityGroups) {
if (getSecurityGroups() == null) setSecurityGroups(new java.util.ArrayList<String>());
for (String value : securityGroups) {
getSecurityGroups().add(value);
}
return this;
}
/**
* Provisions an On-demand EC2 slave by launching a new instance or starting a previously-stopped
* instance.
*/
private EC2AbstractSlave provisionOndemand(
TaskListener listener, Label requiredLabel, EnumSet<ProvisionOptions> provisionOptions)
throws AmazonClientException, IOException {
PrintStream logger = listener.getLogger();
AmazonEC2 ec2 = getParent().connect();
try {
logProvisionInfo(logger, "Considering launching " + ami + " for template " + description);
KeyPair keyPair = getKeyPair(ec2);
RunInstancesRequest riRequest = new RunInstancesRequest(ami, 1, 1);
InstanceNetworkInterfaceSpecification net = new InstanceNetworkInterfaceSpecification();
riRequest.setEbsOptimized(ebsOptimized);
if (useEphemeralDevices) {
setupEphemeralDeviceMapping(riRequest);
} else {
setupCustomDeviceMapping(riRequest);
}
if (stopOnTerminate) {
riRequest.setInstanceInitiatedShutdownBehavior(ShutdownBehavior.Stop);
logProvisionInfo(
logger, "Setting Instance Initiated Shutdown Behavior : ShutdownBehavior.Stop");
} else {
riRequest.setInstanceInitiatedShutdownBehavior(ShutdownBehavior.Terminate);
logProvisionInfo(
logger, "Setting Instance Initiated Shutdown Behavior : ShutdownBehavior.Terminate");
}
List<Filter> diFilters = new ArrayList<Filter>();
diFilters.add(new Filter("image-id").withValues(ami));
if (StringUtils.isNotBlank(getZone())) {
Placement placement = new Placement(getZone());
if (getUseDedicatedTenancy()) {
placement.setTenancy("dedicated");
}
riRequest.setPlacement(placement);
diFilters.add(new Filter("availability-zone").withValues(getZone()));
}
if (StringUtils.isNotBlank(getSubnetId())) {
if (getAssociatePublicIp()) {
net.setSubnetId(getSubnetId());
} else {
riRequest.setSubnetId(getSubnetId());
}
diFilters.add(new Filter("subnet-id").withValues(getSubnetId()));
/*
* If we have a subnet ID then we can only use VPC security groups
*/
if (!securityGroupSet.isEmpty()) {
List<String> groupIds = getEc2SecurityGroups(ec2);
if (!groupIds.isEmpty()) {
if (getAssociatePublicIp()) {
net.setGroups(groupIds);
} else {
riRequest.setSecurityGroupIds(groupIds);
}
diFilters.add(new Filter("instance.group-id").withValues(groupIds));
}
}
} else {
/* No subnet: we can use standard security groups by name */
riRequest.setSecurityGroups(securityGroupSet);
if (!securityGroupSet.isEmpty()) {
diFilters.add(new Filter("instance.group-name").withValues(securityGroupSet));
}
}
String userDataString = Base64.encodeBase64String(userData.getBytes(StandardCharsets.UTF_8));
riRequest.setUserData(userDataString);
riRequest.setKeyName(keyPair.getKeyName());
diFilters.add(new Filter("key-name").withValues(keyPair.getKeyName()));
riRequest.setInstanceType(type.toString());
diFilters.add(new Filter("instance-type").withValues(type.toString()));
if (getAssociatePublicIp()) {
net.setAssociatePublicIpAddress(true);
net.setDeviceIndex(0);
riRequest.withNetworkInterfaces(net);
}
boolean hasCustomTypeTag = false;
HashSet<Tag> instTags = null;
if (tags != null && !tags.isEmpty()) {
instTags = new HashSet<Tag>();
for (EC2Tag t : tags) {
instTags.add(new Tag(t.getName(), t.getValue()));
diFilters.add(new Filter("tag:" + t.getName()).withValues(t.getValue()));
if (StringUtils.equals(t.getName(), EC2Tag.TAG_NAME_JENKINS_SLAVE_TYPE)) {
hasCustomTypeTag = true;
}
}
}
if (!hasCustomTypeTag) {
if (instTags == null) {
instTags = new HashSet<Tag>();
}
// Append template description as well to identify slaves provisioned per template
instTags.add(
new Tag(
EC2Tag.TAG_NAME_JENKINS_SLAVE_TYPE,
EC2Cloud.getSlaveTypeTagValue(EC2Cloud.EC2_SLAVE_TYPE_DEMAND, description)));
}
DescribeInstancesRequest diRequest = new DescribeInstancesRequest();
diRequest.setFilters(diFilters);
logProvision(logger, "Looking for existing instances with describe-instance: " + diRequest);
DescribeInstancesResult diResult = ec2.describeInstances(diRequest);
EC2AbstractSlave[] ec2Node = new EC2AbstractSlave[1];
Instance existingInstance = null;
if (!provisionOptions.contains(ProvisionOptions.FORCE_CREATE)) {
reservationLoop:
for (Reservation reservation : diResult.getReservations()) {
for (Instance instance : reservation.getInstances()) {
if (checkInstance(logger, instance, requiredLabel, ec2Node)) {
existingInstance = instance;
logProvision(
logger,
"Found existing instance: "
+ existingInstance
+ ((ec2Node[0] != null) ? (" node: " + ec2Node[0].getInstanceId()) : ""));
break reservationLoop;
}
}
}
}
if (existingInstance == null) {
if (!provisionOptions.contains(ProvisionOptions.FORCE_CREATE)
&& !provisionOptions.contains(ProvisionOptions.ALLOW_CREATE)) {
logProvision(logger, "No existing instance found - but cannot create new instance");
return null;
}
if (StringUtils.isNotBlank(getIamInstanceProfile())) {
riRequest.setIamInstanceProfile(
new IamInstanceProfileSpecification().withArn(getIamInstanceProfile()));
}
// Have to create a new instance
Instance inst = ec2.runInstances(riRequest).getReservation().getInstances().get(0);
/* Now that we have our instance, we can set tags on it */
if (instTags != null) {
updateRemoteTags(ec2, instTags, "InvalidInstanceID.NotFound", inst.getInstanceId());
// That was a remote request - we should also update our
// local instance data.
inst.setTags(instTags);
}
logProvisionInfo(logger, "No existing instance found - created new instance: " + inst);
return newOndemandSlave(inst);
}
if (existingInstance
.getState()
.getName()
.equalsIgnoreCase(InstanceStateName.Stopping.toString())
|| existingInstance
.getState()
.getName()
.equalsIgnoreCase(InstanceStateName.Stopped.toString())) {
List<String> instances = new ArrayList<String>();
instances.add(existingInstance.getInstanceId());
StartInstancesRequest siRequest = new StartInstancesRequest(instances);
StartInstancesResult siResult = ec2.startInstances(siRequest);
logProvisionInfo(
logger,
"Found stopped instance - starting it: " + existingInstance + " result:" + siResult);
} else {
// Should be pending or running at this point, just let it come up
logProvisionInfo(
logger,
"Found existing pending or running: "
+ existingInstance.getState().getName()
+ " instance: "
+ existingInstance);
}
if (ec2Node[0] != null) {
logProvisionInfo(logger, "Using existing slave: " + ec2Node[0].getInstanceId());
return ec2Node[0];
}
// Existing slave not found
logProvision(logger, "Creating new slave for existing instance: " + existingInstance);
return newOndemandSlave(existingInstance);
} catch (FormException e) {
throw new AssertionError(e); // we should have discovered all
// configuration issues upfront
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
public static void start() {
AWSCredentials credentials = null;
try {
credentials =
new PropertiesCredentials(
CreateInitialVMs.class.getResourceAsStream("AwsCredentials.properties"));
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
/**
* *******************************************
*
* <p>#1 Create Amazon Client object
*
* <p>*******************************************
*/
System.out.println("#1 Create Amazon Client object");
ec2 = new AmazonEC2Client(credentials);
try {
/**
* *******************************************
*
* <p>#6 Create an Instance
*
* <p>*******************************************
*/
System.out.println("#5 Create an Instance");
String imageId = "ami-76f0061f"; // Basic 32-bit Amazon Linux AMI
int minInstanceCount = 1;
int maxInstanceCount = 2; // create 2 instances
String keyPairName = "testElastic";
String securityGroupName = "Prachi";
ArrayList<String> securityGroup = new ArrayList<String>();
securityGroup.add(securityGroupName);
RunInstancesRequest rir =
new RunInstancesRequest(imageId, minInstanceCount, maxInstanceCount);
rir.setKeyName(keyPairName);
rir.setSecurityGroups(securityGroup);
Placement p = new Placement();
p.setAvailabilityZone("us-east-1a");
rir.setPlacement(p);
RunInstancesResult result = ec2.runInstances(rir);
// get instanceId from the result
List<Instance> resultInstance = result.getReservation().getInstances();
String createdInstanceId = null;
for (Instance ins : resultInstance) {
createdInstanceId = ins.getInstanceId();
System.out.println("State of instance " + ins.getInstanceId() + " : ");
while (true) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.print(ins.getState().getName() + "\n");
ins = updatedInstance(ins);
// if(ins.getPublicIpAddress()!= null){
// if(ins.getState().getName().equals("running")){
if (ins.getPublicIpAddress() != null && ins.getState().getName().equals("running")) {
break;
}
}
System.out.println("State: " + ins.getState().getName());
System.out.println("New instance has been created: " + ins.getInstanceId());
System.out.println("Instance Key: " + ins.getKeyName());
System.out.println("Public DNS Name: " + ins.getPublicDnsName());
System.out.println("Public DNS IP Address: " + ins.getPublicIpAddress());
System.out.println("Instance ID: " + ins.getInstanceId());
VMNode vmn = new VMNode();
vmn.setInstanceId(ins.getInstanceId());
/**
* ******************************************* Allocate elastic IP addresses.
* *******************************************
*/
System.out.println("Public IP before association: " + ins.getPublicIpAddress());
ins = allocateElasticIP(ins);
vmn.setElasticIp(ins.getPublicIpAddress());
System.out.println("Public IP after association: " + ins.getPublicIpAddress());
/**
* ******************************************* Create a volume
* *******************************************
*/
String createdVolumeId = createVolume();
/**
* ******************************************* Attach the volume to the instance
* *******************************************
*/
attachVolume(createdInstanceId, createdVolumeId);
vmn.setVolumeId(createdVolumeId);
/**
* ******************************************* Detach the volume from the instance
* *******************************************
*/
detachVolume(createdInstanceId, createdVolumeId);
/**
* ********************************* Create an AMI from an instance
* *******************************
*/
String createdImageId = createAmi(createdInstanceId);
vmn.setAmiId(createdImageId);
nodes.add(vmn);
/** ********************************* Stop the instance ******************************* */
// stopInstance(ins.getInstanceId());
// Diassociate Elastic IP from instance
disassociateElasticIp(ins.getPublicIpAddress());
}
System.out.println("Listing Nodes: ");
for (VMNode n : nodes) {
System.out.println("Instance ID: " + n.getInstanceid());
System.out.println("Elastic IP: " + n.getElasticIp());
System.out.println("Volume ID: " + n.getVolumeId());
System.out.println("AMI ID: " + n.getAmiId());
System.out.println();
}
/**
* *******************************************
*
* <p>#10 shutdown client object
*
* <p>*******************************************
*/
ec2.shutdown();
} catch (AmazonServiceException ase) {
System.out.println("Caught Exception: " + ase.getMessage());
System.out.println("Reponse Status Code: " + ase.getStatusCode());
System.out.println("Error Code: " + ase.getErrorCode());
System.out.println("Request ID: " + ase.getRequestId());
}
}