· 8 years ago · Nov 24, 2017, 11:50 AM
1/**
2 * This is the class that provides the cloud resource provisioner functionalities.
3 * @author Aravind Mohan.
4 */
5
6package cloud.resource.provisioner;
7
8import java.io.IOException;
9import java.io.PrintWriter;
10import java.net.InetAddress;
11import java.net.InetSocketAddress;
12import java.net.UnknownHostException;
13import java.nio.channels.SocketChannel;
14import java.sql.Time;
15import java.util.ArrayList;
16import java.util.Date;
17import java.util.Iterator;
18import java.util.List;
19import java.util.Timer;
20import java.util.TimerTask;
21
22import com.amazonaws.auth.AWSCredentials;
23import com.amazonaws.auth.BasicAWSCredentials;
24import com.amazonaws.regions.Region;
25import com.amazonaws.regions.Regions;
26import com.amazonaws.services.ec2.AmazonEC2Client;
27import com.amazonaws.services.ec2.model.AuthorizeSecurityGroupIngressRequest;
28import com.amazonaws.services.ec2.model.CreateKeyPairRequest;
29import com.amazonaws.services.ec2.model.CreateKeyPairResult;
30import com.amazonaws.services.ec2.model.CreateSecurityGroupRequest;
31import com.amazonaws.services.ec2.model.DeleteKeyPairRequest;
32import com.amazonaws.services.ec2.model.DeleteSecurityGroupRequest;
33import com.amazonaws.services.ec2.model.DescribeInstancesResult;
34import com.amazonaws.services.ec2.model.DescribeKeyPairsRequest;
35import com.amazonaws.services.ec2.model.DescribeKeyPairsResult;
36import com.amazonaws.services.ec2.model.DescribeSecurityGroupsRequest;
37import com.amazonaws.services.ec2.model.DescribeSecurityGroupsResult;
38import com.amazonaws.services.ec2.model.Instance;
39import com.amazonaws.services.ec2.model.IpPermission;
40import com.amazonaws.services.ec2.model.KeyPair;
41import com.amazonaws.services.ec2.model.RebootInstancesRequest;
42import com.amazonaws.services.ec2.model.Reservation;
43import com.amazonaws.services.ec2.model.RunInstancesRequest;
44import com.amazonaws.services.ec2.model.StartInstancesRequest;
45import com.amazonaws.services.ec2.model.StopInstancesRequest;
46import com.amazonaws.services.ec2.model.TerminateInstancesRequest;
47import com.amazonaws.services.elasticache.AmazonElastiCacheClient;
48import com.amazonaws.services.elasticmapreduce.model.InstanceState;
49import com.amazonaws.services.rds.AmazonRDSClient;
50import com.amazonaws.services.s3.AmazonS3;
51
52public class VMProvisioner {
53 public static String accessKey = "AKIAIVY2ERNF5CURIVCA";
54 public static String secretKey = "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";
55 public static String groupName = "skater-parse-server-dev";
56 public static String keyName = "skater_parse_server_ssh_key";
57 public static String imageID = "ami-41e0d557";
58 public static String instanceType = "c4.4xlarge";
59 public static AWSCredentials credentials;
60 public static Region region;
61 public static AmazonEC2Client ec2client;
62 public static AmazonRDSClient rdsclient;
63
64 public static Timer myTimer = new Timer();
65 public static TimerTask task = new TimerTask(){
66 public void run()
67 {
68 startInstance("i-02e58f9feb08f223d");
69 startInstance("i-083a665f5d80f9f16");
70 startInstance("i-0de3dea3acc1dda24");
71 startInstance("i-0f0c8803cab5f8adf");
72
73 }
74 };
75 public static void main(String[] args) throws Exception {
76
77 VMProvisioner m = new VMProvisioner();
78 m.init();
79 /*
80 ArrayList<String> ips = provisionVMs(3);
81 for (String ip : ips)
82 System.out.println(ips);
83 System.out
84 .println("--------------------------------------------------------------");
85 for (String ipAddress : getAvailableVMIPs()) {
86 System.out.println(ipAddress);
87 }*/
88 stopInstance("i-02e58f9feb08f223d");
89 stopInstance("i-083a665f5d80f9f16");
90 stopInstance("i-0de3dea3acc1dda24");
91 stopInstance("i-0f0c8803cab5f8adf");
92 myTimer.scheduleAtFixedRate(task, 60000, 60000);
93 }
94
95 public static void terminateAllButMasterNode() {
96 VMProvisioner m = new VMProvisioner();
97 m.init();
98 ArrayList<String> allButMasterNode = VMProvisioner.getAvailableInstIds();
99 String masterNodeInstanceId = "i-772ba059";
100 allButMasterNode.remove(masterNodeInstanceId);
101 System.out.println("terminating " + allButMasterNode);
102 for (String id : allButMasterNode)
103 VMProvisioner.terminateInstance(id);
104 }
105
106 public void init() {
107 credentials = new BasicAWSCredentials(accessKey, secretKey);
108 region = Region.getRegion(Regions.US_EAST_1);
109 ec2client = new AmazonEC2Client(credentials);
110 ec2client.setRegion(region);
111 }
112
113 public String createEC2Instance(int noOfInstances) {
114 try {
115 RunInstancesRequest rir = new RunInstancesRequest();
116 rir.withImageId(imageID);
117 rir.withInstanceType(instanceType);
118 rir.withMinCount(noOfInstances);
119 rir.withMaxCount(noOfInstances);
120 rir.withKeyName(keyName);
121 rir.withMonitoring(true);
122 rir.withSecurityGroups(groupName);
123 ec2client.runInstances(rir);
124 return null;
125 } catch (Exception e) {
126 e.printStackTrace();
127 System.exit(0);
128 }
129 return null;
130 }
131
132 public static void stopInstance(String instanceId) {
133 StopInstancesRequest sir = new StopInstancesRequest();
134 sir.withInstanceIds(instanceId);
135 ec2client.stopInstances(sir);
136 }
137
138 public static void startInstance(String instanceId) {
139 StartInstancesRequest sir = new StartInstancesRequest();
140 sir.withInstanceIds(instanceId);
141 ec2client.startInstances(sir);
142 }
143 public static void rebootInstance(String instanceId)
144 {
145 RebootInstancesRequest rir = new RebootInstancesRequest();
146 rir.withInstanceIds(instanceId);
147 ec2client.rebootInstances(rir);
148
149 }
150
151 public static void terminateInstance(String instanceId) {
152 TerminateInstancesRequest tir = new TerminateInstancesRequest();
153 tir.withInstanceIds(instanceId);
154 ec2client.terminateInstances(tir);
155 }
156
157 public static void initializeProvisioner(String paramaccessKey,
158 String paramsecretKey, String paramgroupName, String paramkeyName,
159 String paramimageID, String paraminstanceType) {
160 VMProvisioner.accessKey = paramaccessKey;
161 VMProvisioner.secretKey = paramsecretKey;
162 VMProvisioner.groupName = paramgroupName;
163 VMProvisioner.keyName = paramkeyName;
164 VMProvisioner.imageID = paramimageID;
165 VMProvisioner.instanceType = paraminstanceType;
166 System.out.println("#Initialized successfully....");
167 }
168
169 public static ArrayList<String> provisionVMs(int noOfInstances)
170 throws Exception {
171 ArrayList<String> initialVMs = VMProvisioner.getAvailableInstIds();
172 VMProvisioner.justLaunchVMs(noOfInstances);
173 ArrayList<String> runningAndPendingVMs = VMProvisioner
174 .getAvailableAndPendingInstIds();
175 runningAndPendingVMs.removeAll(initialVMs);
176 VMProvisioner.waitUntilAllPendingBecomeRunning(runningAndPendingVMs);
177 ArrayList<String> ipAddresses = getIPaddresses(runningAndPendingVMs);
178 System.out.println("#Provisioned machines successfully....");
179 return ipAddresses;
180 }
181
182 public static void writePemFile(String privateKey, String pemFilePath,
183 String keyname) {
184 try {
185 PrintWriter writer = new PrintWriter(pemFilePath + "/" + keyname
186 + ".pem", "UTF-8");
187 writer.print(privateKey);
188 writer.close();
189 } catch (Exception e) {
190 e.printStackTrace();
191 }
192 }
193
194 public static void checkIfKeyExists(AmazonEC2Client ec2Client, String keyName)
195 {
196 DescribeKeyPairsRequest request = new DescribeKeyPairsRequest();
197 DescribeKeyPairsResult response = ec2Client.describeKeyPairs(request);
198 for (int i=0; i < response.getKeyPairs().size(); i++){
199 if (response.getKeyPairs().get(i).getKeyName().equalsIgnoreCase(keyName)){
200 System.out.println("key already exists, need to delete");
201 deleteKeyPair(keyName);
202 }
203
204 }
205
206
207 }
208 public static void checkIfSecGroupExists(AmazonEC2Client ec2Client, String secGroupName)
209 {
210 DescribeSecurityGroupsRequest request = new DescribeSecurityGroupsRequest();
211 DescribeSecurityGroupsResult response = ec2Client.describeSecurityGroups(request);
212 for (int i=0; i < response.getSecurityGroups().size(); i++){
213 if (response.getSecurityGroups().get(i).getGroupName().equalsIgnoreCase(secGroupName)){
214 System.out.println("group already exists, need to delete");
215 deleteSecurityGroup(secGroupName);
216 }
217
218 }
219
220
221 }
222 public static boolean deleteKeyPair(String paramkeyName) {
223 boolean result = false;
224 try {
225 VMProvisioner provisioner = new VMProvisioner();
226 provisioner.init();
227 DeleteKeyPairRequest ckpr = new DeleteKeyPairRequest();
228 ckpr.setKeyName(paramkeyName);
229 ec2client.deleteKeyPair(ckpr);
230 System.out
231 .println("Following key:" + paramkeyName + " is deleted.");
232 result = true;
233
234 // log.Info("KeyPair :" + privateKey);
235
236 } catch (Exception e) {
237 System.out.println("Failure...");
238 System.out.println(e.toString());
239 }
240 return result;
241 }
242 public static boolean createKeyPair(String pemFilePath, String paramkeyName) {
243 boolean result = false;
244 try {
245 VMProvisioner provisioner = new VMProvisioner();
246 provisioner.init();
247 CreateKeyPairRequest ckpr = new CreateKeyPairRequest();
248 ckpr.withKeyName(paramkeyName);
249 checkIfKeyExists(ec2client, paramkeyName);
250
251 CreateKeyPairResult ckpresult = ec2client.createKeyPair(ckpr);
252 KeyPair keypair = ckpresult.getKeyPair();
253 String privateKey = keypair.getKeyMaterial();
254 writePemFile(privateKey, pemFilePath, paramkeyName);
255 System.out
256 .println("Following key:" + paramkeyName + " is created.");
257 result = true;
258
259 // log.Info("KeyPair :" + privateKey);
260
261 } catch (Exception e) {
262 System.out.println("Failure...");
263 System.out.println(e.toString());
264 }
265 return result;
266 }
267
268 public static boolean deleteSecurityGroup(String paramSecGroupName) {
269 boolean result = false;
270 try {
271 VMProvisioner provisioner = new VMProvisioner();
272 provisioner.init();
273 DeleteSecurityGroupRequest csgr = new DeleteSecurityGroupRequest();
274 csgr.setGroupName(paramSecGroupName);
275 ec2client
276 .deleteSecurityGroup(csgr);
277
278 System.out.println("Following group:" + paramSecGroupName
279 + " is delete.");
280 result = true;
281 // log.Info("KeyPair :" + privateKey);
282 // writePemFile(privateKey, pemFilePath, pemFileName);
283 } catch (Exception e) {
284 System.out.println("Failure...");
285 System.out.println(e.toString());
286 }
287 return result;
288 }
289 public static boolean createSecurityGroup(String paramSecGroupName) {
290 boolean result = false;
291 try {
292 VMProvisioner provisioner = new VMProvisioner();
293 provisioner.init();
294 CreateSecurityGroupRequest csgr = new CreateSecurityGroupRequest();
295 csgr.withGroupName(paramSecGroupName).withDescription(
296 "My security group");
297 checkIfSecGroupExists(ec2client, paramSecGroupName);
298 ec2client
299 .createSecurityGroup(csgr);
300 Thread.sleep(2000);
301
302 IpPermission ipPermission1 = new IpPermission();
303 ipPermission1.withIpRanges("0.0.0.0/0").withIpProtocol("tcp")
304 .withFromPort(22).withToPort(22);
305
306 IpPermission ipPermission2 = new IpPermission();
307 ipPermission2.withIpRanges("0.0.0.0/0").withIpProtocol("tcp")
308 .withFromPort(3306).withToPort(3306);
309
310 AuthorizeSecurityGroupIngressRequest authorizeSecurityGroupIngressRequest = new AuthorizeSecurityGroupIngressRequest();
311 authorizeSecurityGroupIngressRequest.withGroupName(
312 paramSecGroupName).withIpPermissions(ipPermission1);
313 authorizeSecurityGroupIngressRequest.withGroupName(
314 paramSecGroupName).withIpPermissions(ipPermission2);
315 ec2client
316 .authorizeSecurityGroupIngress(authorizeSecurityGroupIngressRequest);
317
318 System.out.println("Following group:" + paramSecGroupName
319 + " is created.");
320 result = true;
321 // log.Info("KeyPair :" + privateKey);
322 // writePemFile(privateKey, pemFilePath, pemFileName);
323 } catch (Exception e) {
324 System.out.println("Failure...");
325 System.out.println(e.toString());
326 }
327 return result;
328 }
329
330 public static void justLaunchVMs(int noOfInstances) {
331 VMProvisioner provisioner = new VMProvisioner();
332 provisioner.init();
333 provisioner.createEC2Instance(noOfInstances);
334 }
335
336 public static ArrayList<String> getAvailableVMIPs() throws Exception {
337 ArrayList<String> resultList = new ArrayList<String>();
338 VMProvisioner provisioner = new VMProvisioner();
339 provisioner.init();
340 DescribeInstancesResult result = VMProvisioner.ec2client
341 .describeInstances();
342 Iterator<Reservation> i = result.getReservations().iterator();
343 while (i.hasNext()) {
344 Reservation r = i.next();
345 List<Instance> instances = r.getInstances();
346 for (Instance ii : instances) {
347 if (ii.getState().getName().equals("running")) {
348 resultList.add(ii.getPublicIpAddress());
349 }
350 }
351 }
352 return resultList;
353 }
354
355 public static ArrayList<String> getAvailableAndPendingVMIPs() {
356 ArrayList<String> resultList = new ArrayList<String>();
357 VMProvisioner provisioner = new VMProvisioner();
358 provisioner.init();
359 DescribeInstancesResult result = VMProvisioner.ec2client
360 .describeInstances();
361 Iterator<Reservation> i = result.getReservations().iterator();
362 while (i.hasNext()) {
363 Reservation r = i.next();
364 List<Instance> instances = r.getInstances();
365 System.out.println("iiiiiiiiiiiiiiiiiiiiiinstances size: "
366 + instances.size());
367 for (Instance ii : instances) {
368 if (ii.getState().getName().equals("running")
369 || ii.getState().getName().equals("pending")) {
370 System.out
371 .println("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaadding "
372 + ii.getPublicIpAddress());
373 resultList.add(ii.getPublicIpAddress());
374 }
375 }
376 }
377 return resultList;
378 }
379
380 public static void waitUntilAllPendingBecomeRunning(
381 ArrayList<String> pendingInstIds) throws Exception {
382 int noOfPending = pendingInstIds.size();
383 VMProvisioner provisioner = new VMProvisioner();
384 provisioner.init();
385 boolean isWaiting = true;
386 while (isWaiting) {
387 Thread.sleep(1000);
388 DescribeInstancesResult r = VMProvisioner.ec2client
389 .describeInstances();
390 Iterator<Reservation> ir = r.getReservations().iterator();
391 while (ir.hasNext()) {
392 Reservation rr = ir.next();
393 List<Instance> instances = rr.getInstances();
394 for (Instance ii : instances) {
395 for (String pendingVMInstId : pendingInstIds) {
396 if (ii.getInstanceId().trim()
397 .equals(pendingVMInstId.trim()))
398 if (ii.getState().getName().trim()
399 .equals("running")
400 && ii.getInstanceId().trim()
401 .equals(pendingVMInstId.trim())) {
402 noOfPending--;
403 if (noOfPending == 0)
404 isWaiting = false;
405 }
406 }
407 }
408 }
409 }
410
411 }
412
413 public static ArrayList<String> getAvailableInstIds() {
414 ArrayList<String> resultList = new ArrayList<String>();
415 VMProvisioner provisioner = new VMProvisioner();
416 provisioner.init();
417 DescribeInstancesResult result = VMProvisioner.ec2client
418 .describeInstances();
419 Iterator<Reservation> i = result.getReservations().iterator();
420 while (i.hasNext()) {
421 Reservation r = i.next();
422 List<Instance> instances = r.getInstances();
423 for (Instance ii : instances) {
424 if (ii.getState().getName().equals("running")) {
425 resultList.add(ii.getInstanceId());
426 }
427 }
428 }
429 return resultList;
430 }
431
432 public static ArrayList<String> getAvailableInstIdsFromIps(
433 ArrayList<String> ips) {
434 ArrayList<String> resultList = new ArrayList<String>();
435 VMProvisioner provisioner = new VMProvisioner();
436 provisioner.init();
437 DescribeInstancesResult result = VMProvisioner.ec2client
438 .describeInstances();
439 Iterator<Reservation> i = result.getReservations().iterator();
440 while (i.hasNext()) {
441 Reservation r = i.next();
442 List<Instance> instances = r.getInstances();
443 for (Instance ii : instances) {
444 for (String ip : ips) {
445 if (ii.getState().getName().equals("running")) {
446 if (ii.getPublicIpAddress().equalsIgnoreCase(ip))
447 resultList.add(ii.getInstanceId());
448 }
449 }
450
451 }
452 }
453 return resultList;
454 }
455
456 public static ArrayList<String> getAvailableAndPendingInstIds() {
457 ArrayList<String> resultList = new ArrayList<String>();
458 VMProvisioner provisioner = new VMProvisioner();
459 provisioner.init();
460 DescribeInstancesResult result = VMProvisioner.ec2client
461 .describeInstances();
462 Iterator<Reservation> i = result.getReservations().iterator();
463 while (i.hasNext()) {
464 Reservation r = i.next();
465 List<Instance> instances = r.getInstances();
466 for (Instance ii : instances) {
467 if (ii.getState().getName().equals("running")
468 || ii.getState().getName().equals("pending")) {
469 resultList.add(ii.getInstanceId());
470 }
471 }
472 }
473 return resultList;
474 }
475
476 public static ArrayList<String> getIPaddresses(ArrayList<String> instIds) {
477 ArrayList<String> resultList = new ArrayList<String>();
478 VMProvisioner provisioner = new VMProvisioner();
479 provisioner.init();
480 DescribeInstancesResult result = VMProvisioner.ec2client
481 .describeInstances();
482 Iterator<Reservation> i = result.getReservations().iterator();
483 while (i.hasNext()) {
484 Reservation r = i.next();
485 List<Instance> instances = r.getInstances();
486 for (Instance ii : instances) {
487 for (String instId : instIds) {
488 if (ii.getInstanceId().trim().equals(instId))
489 resultList.add(ii.getPublicIpAddress());
490 }
491 }
492 }
493 return resultList;
494 }
495
496 public static ArrayList<String> getPendingVMs() {
497 ArrayList<String> resultList = new ArrayList<String>();
498 VMProvisioner provisioner = new VMProvisioner();
499 provisioner.init();
500 DescribeInstancesResult result = VMProvisioner.ec2client
501 .describeInstances();
502 Iterator<Reservation> i = result.getReservations().iterator();
503 while (i.hasNext()) {
504 Reservation r = i.next();
505 List<Instance> instances = r.getInstances();
506 for (Instance ii : instances) {
507 if (ii.getState().getName().equals("pending")) {
508 resultList.add(ii.getInstanceId());
509 }
510 }
511 }
512 return resultList;
513 }
514
515 public static void waitOutPendingVMs() throws Exception {
516 while (getPendingVMs().size() > 0) {
517 System.out.println(getPendingVMs());
518 Thread.sleep(500);
519 }
520 }
521
522 public static void hostIsReachableSocket(String ip, int port) {
523 String hostAddress = ip;
524 long timeToRespond = 0; // in milliseconds
525 try {
526 timeToRespond = test(hostAddress, port);
527 } catch (NumberFormatException e) {
528 e.printStackTrace();
529 }
530 if (timeToRespond >= 0)
531 System.out.println(hostAddress + " responded in " + timeToRespond
532 + " ms");
533 else
534 System.out.println("Failed");
535 }
536
537 static long test(String hostAddress, int port) {
538 InetAddress inetAddress = null;
539 InetSocketAddress socketAddress = null;
540 SocketChannel sc = null;
541 long timeToRespond = -1;
542 Date start, stop;
543 try {
544 inetAddress = InetAddress.getByName(hostAddress);
545 } catch (UnknownHostException e) {
546 e.printStackTrace();
547 }
548 try {
549 socketAddress = new InetSocketAddress(inetAddress, port);
550 } catch (IllegalArgumentException e) {
551 e.printStackTrace();
552 }
553 try {
554 sc = SocketChannel.open();
555 sc.configureBlocking(true);
556 start = new Date();
557 if (sc.connect(socketAddress)) {
558 stop = new Date();
559 timeToRespond = (stop.getTime() - start.getTime());
560 }
561 } catch (IOException e) {
562 e.printStackTrace();
563 }
564 try {
565 sc.close();
566 } catch (IOException e) {
567 e.printStackTrace();
568 }
569 return timeToRespond;
570 }
571
572 public static boolean pingAllIPs() throws Exception {
573 for (String ipAddress : getAvailableVMIPs()) {
574 hostIsReachableSocket(ipAddress, 22);
575 }
576 return true;
577 }
578
579 public static boolean pingIP(String ipAddress) throws Exception {
580 hostIsReachableSocket(ipAddress, 22);
581 return true;
582 }
583
584}