sumomo 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 32e4cbb699706aa8e81613f2e781aeb4d9868daf
-  data.tar.gz: 7d83d874b32195063ebb437ad9062da01ce72833
+  metadata.gz: cb1aedf8b2967520988740daf5e85b6c068302b4
+  data.tar.gz: 7fa8031ebf8b52c3ffbe9450d0ed3f7c7672a1c8
 SHA512:
-  metadata.gz: b233a9eaae20d275c787adb1dde73ad5ca6e532c7aed417b8c02e662208537d7393cfaefcc4f7bc769ee4003fd1a5dcc8e2be58588f29fe1c7f3ce51edc45de4
-  data.tar.gz: a2bdea1719464211ec9046a0f30cd8702ae0fdac12eac107c00954b358bd4ec34f18457f9195438f129c84441a8a9bbb4742e66c4a7b804bc4ce4d65b927f1c8
+  metadata.gz: 83a0194a2aeb0a63ee35bed97c7521546511ab9fa7677d5e282c1bbeb5caed9f3091a70f63df81ae4dcb574732ee2a10059ede53e99491078a79c42914d0ea3c
+  data.tar.gz: 775a27622a8deb089fb94921644566baa1937b1beba30811055ba21f4ebb117fa4b45a9d951b65bc92bd4a3ce50f9ea8414cf0a95b924b462108f4e6b89c5f26

data/README.md

@@ -20,7 +20,21 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+This gem lets you use all of the syntax in the [momo](https://github.com/davidsiaw/momo) and more!
+
+You need to setup your AWS credentials using `aws configure`.
+
+```
+require "sumomo"
+
+Sumomo::update_stack(name: "mystack", region: "ap-northeast-1") do
+	x = hidden_value "meow"
+
+	output "Haha", x
+end
+
+Sumomo::wait_for_stack(name: "kurosawa", region: "ap-northeast-1")
+```
 
 ## Development
 
@@ -30,5 +44,5 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/sumomo.
+Bug reports and pull requests are welcome on GitHub at https://github.com/davidsiaw/sumomo.
 

data/data/sumomo/custom_resource_utils.js

@@ -0,0 +1,151 @@
+var aws = require("aws-sdk");
+
+Cloudformation = {}
+Cloudformation.SUCCESS = "SUCCESS";
+Cloudformation.FAILED = "FAILED";
+Cloudformation.status_sent = false;
+Cloudformation.send = function(request, context, responseStatus, responseData, reason, physicalResourceId) {
+ 
+    var responseBody = JSON.stringify({
+        Status: responseStatus,
+        Reason: reason + " Log Stream: " + context.logStreamName,
+        PhysicalResourceId: physicalResourceId || context.logStreamName,
+        StackId: request.StackId,
+        RequestId: request.RequestId,
+        LogicalResourceId: request.LogicalResourceId,
+        Data: responseData
+    });
+ 
+    console.log("Response body:\n", responseBody);
+ 
+    var https = require("https");
+    var url = require("url");
+ 
+    var parsedUrl = url.parse(request.ResponseURL);
+    var options = {
+        hostname: parsedUrl.hostname,
+        port: 443,
+        path: parsedUrl.path,
+        method: "PUT",
+        headers: {
+            "content-type": "",
+            "content-length": responseBody.length
+        }
+    };
+ 
+    var request = https.request(options, function(response) {
+        console.log("Status code: " + response.statusCode);
+        console.log("Status message: " + response.statusMessage);
+        context.done();
+    });
+ 
+    request.on("error", function(error) {
+        console.log("send(..) failed executing https.request(..): " + error);
+        context.done();
+    });
+ 
+    request.write(responseBody);
+    request.end();
+    Cloudformation.status_sent = true;
+}
+
+function Storage(bucket, prefix, region)
+{
+  var s3 = new aws.S3({region: region});
+
+  this.put = function(key, value, onComplete, onError) {
+
+    s3.putObject({
+      Bucket: bucket,
+      Key: "data/" + prefix + "/" + key,
+      Body: value
+    }, function(err, data) {
+      if (err) 
+      {
+        if (onError)
+        {
+          onError(err);
+        }
+        else
+        {
+          throw(err);
+        }
+      } 
+      else 
+      {
+        if (onComplete)
+        {
+          onComplete();
+        }
+      }   
+    })
+  }
+
+  this.get = function(key, onComplete, onError) {
+
+    s3.getObject({
+      Bucket: bucket,
+      Key: "data/" + prefix + "/" + key
+    }, function(err, data) {
+      if (err)
+      {
+        if (onError)
+        {
+          onError(err);
+        }
+        else
+        {
+          throw(err);
+        }
+      } 
+      else 
+      {
+        if (onComplete)
+        {
+          onComplete(data.Body.toString());
+        }
+      }   
+    })
+  }
+
+  return this;
+}
+
+Global = {}
+
+process.on('uncaughtException', function(err) {
+  console.log("Sending the following error to cloudformation: ");
+  console.log(err);
+  Cloudformation.send(Global.request, Global.context, Cloudformation.FAILED, {}, err);
+});
+
+process.on('exit', function() {
+  if (!Cloudformation.status_sent)
+  {
+    console.log("No status sent to cloudformation, assuming FAILED");
+    Cloudformation.send(Global.request, Global.context, Cloudformation.FAILED, {}, "No status sent to cloudformation");
+  }
+});
+
+exports.handler = function(request, context)
+{
+  console.log("Request:");
+  console.log(request);
+  console.log("Context:");
+  console.log(context);
+  
+  Global.request = request;
+  Global.context = context;
+  var store = Storage(request.ResourceProperties.Bucket, request.LogicalResourceId, request.ResourceProperties.Region);
+
+  try
+  {
+      {{ CODE }}
+  }
+  catch (err)
+  {
+      console.log("Sending the following error to cloudformation: ");
+      console.log(err);
+      Cloudformation.send(request, context, Cloudformation.FAILED, {}, err);
+  }
+}

data/data/sumomo/custom_resources/AMILookup.js

@@ -0,0 +1,106 @@
+
+var typeToArch = {
+      "t1.micro"    : "PV64" ,
+      "t2.nano"     : "HVM64",
+      "t2.micro"    : "HVM64",
+      "t2.small"    : "HVM64",
+      "t2.medium"   : "HVM64",
+      "t2.large"    : "HVM64",
+      "m1.small"    : "PV64" ,
+      "m1.medium"   : "PV64" ,
+      "m1.large"    : "PV64" ,
+      "m1.xlarge"   : "PV64" ,
+      "m2.xlarge"   : "PV64" ,
+      "m2.2xlarge"  : "PV64" ,
+      "m2.4xlarge"  : "PV64" ,
+      "m3.medium"   : "HVM64",
+      "m3.large"    : "HVM64",
+      "m3.xlarge"   : "HVM64",
+      "m3.2xlarge"  : "HVM64",
+      "m4.large"    : "HVM64",
+      "m4.xlarge"   : "HVM64",
+      "m4.2xlarge"  : "HVM64",
+      "m4.4xlarge"  : "HVM64",
+      "m4.10xlarge" : "HVM64",
+      "c1.medium"   : "PV64" ,
+      "c1.xlarge"   : "PV64" ,
+      "c3.large"    : "HVM64",
+      "c3.xlarge"   : "HVM64",
+      "c3.2xlarge"  : "HVM64",
+      "c3.4xlarge"  : "HVM64",
+      "c3.8xlarge"  : "HVM64",
+      "c4.large"    : "HVM64",
+      "c4.xlarge"   : "HVM64",
+      "c4.2xlarge"  : "HVM64",
+      "c4.4xlarge"  : "HVM64",
+      "c4.8xlarge"  : "HVM64",
+      "g2.2xlarge"  : "HVMG2",
+      "g2.8xlarge"  : "HVMG2",
+      "r3.large"    : "HVM64",
+      "r3.xlarge"   : "HVM64",
+      "r3.2xlarge"  : "HVM64",
+      "r3.4xlarge"  : "HVM64",
+      "r3.8xlarge"  : "HVM64",
+      "i2.xlarge"   : "HVM64",
+      "i2.2xlarge"  : "HVM64",
+      "i2.4xlarge"  : "HVM64",
+      "i2.8xlarge"  : "HVM64",
+      "d2.xlarge"   : "HVM64",
+      "d2.2xlarge"  : "HVM64",
+      "d2.4xlarge"  : "HVM64",
+      "d2.8xlarge"  : "HVM64",
+      "hi1.4xlarge" : "HVM64",
+      "hs1.8xlarge" : "HVM64",
+      "cr1.8xlarge" : "HVM64",
+      "cc2.8xlarge" : "HVM64"
+    }
+
+var archToAMINamePattern = {
+  "PV64": "amzn-ami-pv*.x86_64-ebs",
+  "HVM64": "amzn-ami-hvm*.x86_64-gp2",
+  "HVMG2": "amzn-ami-graphics-hvm-*x86_64-ebs*"
+};
+
+var ec2 = new aws.EC2({region: request.ResourceProperties.Region});
+
+var describeImagesParams = {
+  Filters: [{ Name: "name", Values: [archToAMINamePattern[typeToArch[request.ResourceProperties.InstanceType]]]}],
+  Owners: [request.ResourceProperties.Architecture == "HVMG2" ? "679593333241" : "amazon"]
+};
+
+// Check if the image is a beta or rc image. The Lambda function won't return any of those images.
+function isBeta(imageName) {
+    return imageName.toLowerCase().indexOf("beta") > -1 || imageName.toLowerCase().indexOf(".rc") > -1;
+}
+
+// Get AMI IDs with the specified name pattern and owner
+ec2.describeImages(describeImagesParams, function(err, describeImagesResult)
+{
+  if (err)
+  {
+    console.log(err, err.stack); // an error occurred
+    Cloudformation.send(request, context, Cloudformation.FAILED, {}, JSON.stringify(err));
+  }
+  else
+  {
+    var response = {}
+    var id = "NONE";
+    var images = describeImagesResult.Images;
+    // Sort images by name in decscending order. The names contain the AMI version, formatted as YYYY.MM.Ver.
+    images.sort(function(x, y) { return y.Name.localeCompare(x.Name); });
+    for (var j = 0; j < images.length; j++)
+    {
+        if (isBeta(images[j].Name)) continue;
+        id = images[j].ImageId;
+        response["Name"] = images[j].Name;
+        response["ImageType"] = images[j].ImageType;
+        response["CreationDate"] = images[j].CreationDate;
+        response["Description"] = images[j].Description;
+        response["RootDeviceType"] = images[j].RootDeviceType;
+        response["RootDeviceName"] = images[j].RootDeviceName;
+        response["VirtualizationType"] = images[j].VirtualizationType;
+        break;
+    }
+    Cloudformation.send(request, context, Cloudformation.SUCCESS, response, "Success", id);
+  }
+});

data/data/sumomo/custom_resources/AvailabilityZones.js

@@ -0,0 +1,89 @@
+// return number of zones
+// Zones = comma separated availability zone names
+
+physicalId = "0"
+response = {}
+
+function send_success()
+{
+  if (request.RequestType == "Create")
+  {
+    Cloudformation.send(request, context, Cloudformation.SUCCESS, response, "Success", physicalId);
+  }
+
+  if (request.RequestType == "Update")
+  {
+    Cloudformation.send(request, context, Cloudformation.SUCCESS, response, "Success", physicalId);
+  }
+
+  if (request.RequestType == "Delete")
+  {
+    Cloudformation.send(request, context, Cloudformation.SUCCESS, {}, "Success");
+  }
+}
+
+function get_spot_prices(instance, zones, number)
+{
+  if (zones.length == 0)
+  {
+    send_success();
+  }
+  else
+  {
+    ec2.describeSpotPriceHistory({
+      AvailabilityZone: zones[0],
+      InstanceTypes: [instance],
+      MaxResults: 10
+    }, function(err, data) {
+      if (err)
+      {
+        console.log(err, err.stack); // an error occurred
+        Cloudformation.send(request, context, Cloudformation.FAILED, {}, JSON.stringify(err));
+      }
+      else
+      {
+        console.log("HISTORY")
+        console.log(JSON.stringify(data.SpotPriceHistory))
+        var price = data.SpotPriceHistory[0].SpotPrice
+        if (response["ZoneSpotPrices"])
+        {
+          response["ZoneSpotPrices"] += ","
+        }
+        response["ZoneSpotPrices"] += price;
+        response["ZoneSpotPrice" + number] = price;
+        zones.splice(0,1);
+        get_spot_prices(instance, zones, number+1);
+      }
+    });
+  }
+}
+
+var ec2 = new aws.EC2({region: request.ResourceProperties.Region});
+ec2.describeAvailabilityZones({}, function(err, data) {
+  if (err)
+  {
+    console.log(err, err.stack); // an error occurred
+    Cloudformation.send(request, context, Cloudformation.FAILED, {}, JSON.stringify(err));
+  }
+  else
+  {
+    var zones = data.AvailabilityZones.map(function(x) {return x.ZoneName;});
+
+    physicalId = String(zones.length);
+    response["Zones"] = zones.join();
+    for(var i=0; i<zones.length; i++)
+    {
+      response["Zone"+i] = zones[i];
+    }
+
+    if (request.ResourceProperties.GetSpotPriceFor)
+    {
+      response["ZoneSpotPrices"] = ""
+      get_spot_prices(request.ResourceProperties.GetSpotPriceFor, zones, 1);
+    }
+    else
+    {
+      send_success();
+    }
+  }
+});

data/data/sumomo/custom_resources/CloudflareCNAME.js

@@ -0,0 +1,231 @@
+// Key: Cloudflare API key
+// Email: Cloudflare API email
+// Domain: Cloudflare domain
+// Entry: DNS entry text
+// CNAME: The CNAME record
+// return Record ID of the CNAME record
+
+var querystring = require('querystring');
+var https = require('https');
+
+key = request.ResourceProperties.Key
+email = request.ResourceProperties.Email
+domain = request.ResourceProperties.Domain
+entry = request.ResourceProperties.Entry
+cname = request.ResourceProperties.Cname
+
+function get(path, query, on_complete)
+{
+	var query_string = querystring.stringify(query);
+
+	var get_options = {
+		host: 'api.cloudflare.com',
+		port: '443',
+		path: '/client/v4' + path + "/?" + query_string,
+		method: 'GET',
+		headers: {
+			'X-Auth-Key': key,
+			'X-Auth-Email': email
+		}
+	};
+
+	var req = https.request(get_options, function(res) {
+		//console.log('statusCode: ', res.statusCode);
+		//console.log('headers: ', res.headers);
+		var body = "";
+		res.setEncoding('utf8');
+		res.on('data', function(d) {
+			body += d;
+		});
+		res.on('end', function() {
+			on_complete(JSON.parse(body));
+		});
+		req.on('error', function(e) {
+			console.error(e);
+		});
+	});
+	req.end();
+}
+
+function http_request(method, path, data, on_complete)
+{
+	post_data = JSON.stringify(data);
+
+	var post_options = {
+		host: 'api.cloudflare.com',
+		port: '443',
+		path: '/client/v4' + path,
+		method: method,
+		headers: {
+			'Content-Type': 'application/json',
+			'Content-Length': Buffer.byteLength(post_data),
+			'X-Auth-Key': key,
+			'X-Auth-Email': email
+		}
+	};
+
+	var req = https.request(post_options, function(res) {
+		//console.log('statusCode: ', res.statusCode);
+		//console.log('headers: ', res.headers);
+		var body = "";
+		res.setEncoding('utf8');
+		res.on('data', function(d) {
+			body += d;
+		});
+		res.on('end', function() {
+			on_complete(JSON.parse(body));
+		});
+		req.on('error', function(e) {
+			console.error(e);
+		});
+	});
+	req.write(post_data);
+	req.end();
+}
+
+function post(path, data, on_complete)
+{
+	http_request("POST", path, data, on_complete)
+}
+
+function del(path, data, on_complete)
+{
+	http_request("DELETE", path, data, on_complete)
+}
+
+function get_zone_id(zone_name, on_complete)
+{
+	get("/zones", {name: zone_name}, function (data) 
+	{
+		on_complete(data["result"][0]["id"])
+	});
+}
+
+function get_dns_record_named(zone_id, name, on_complete)
+{
+	get("/zones/"+zone_id+"/dns_records", {name: name}, function (data) 
+	{
+		on_complete(data["result"])
+	});
+}
+
+function create_cname_dns_record(zone_id, type, name, content, on_complete)
+{
+	post("/zones/"+zone_id+"/dns_records", {
+		type: type,
+		name: name,
+		content: content
+	}, function(data) {
+		on_complete(data)
+	});
+};
+
+function delete_cname_dns_record(zone_id, record_id, on_complete)
+{
+	del("/zones/"+zone_id+"/dns_records/"+record_id, {}, function(data) {
+		on_complete(data)
+	});
+};
+
+
+console.log('REQUEST RECEIVED:\n', JSON.stringify(request));
+
+function send_success(record_id)
+{
+	Cloudformation.send(request, context, Cloudformation.SUCCESS, {}, "Success", record_id);
+}
+
+function send_failure(reason)
+{
+    Cloudformation.send(request, context, Cloudformation.FAILED, {}, reason);
+}
+
+function save_data(domain_id, record_id, on_complete, on_error)
+{
+	store.put("domain_id", domain_id, function() {
+		store.put("record_id", record_id, on_complete, on_error);
+	}, on_error);
+}
+
+function load_data(on_complete, on_error)
+{
+	store.get("domain_id", function(domain_id) {
+		store.get("record_id", function(record_id) {
+			on_complete(domain_id, record_id);
+		}, on_error);
+	}, on_error);
+}
+
+if (request.RequestType == "Create") {
+
+	get_zone_id(domain, function(id) 
+	{
+		get_dns_record_named(id, entry, function(data)
+		{
+			if (data.length == 0)
+			{
+				create_cname_dns_record(id, "CNAME", entry, cname, function(data) {
+					console.log("CREATE RECORD: " + JSON.stringify(data));
+					if (data.result)
+					{
+						save_data(id, data.result.id, 
+							function() {
+								send_success(data.result.id)
+							}, 
+							function() {
+								send_failure("Failed to save data")
+							}
+						);
+					}
+					else
+					{
+						send_failure(JSON.stringify(data));
+					}
+				});
+			}
+			else
+			{
+    			send_failure("Entry " + entry + " already exists");
+			}
+			console.log(data);
+		});
+	});
+
+    return;
+}
+
+if (request.RequestType == "Update") {
+
+	load_data(function(domain_id, record_id) {
+
+		delete_cname_dns_record(domain_id, record_id, function() {
+			create_cname_dns_record(domain_id, "CNAME", entry, cname, function(data) {
+				console.log(data);
+				save_data(domain_id, data.result.id, 
+					function() {
+						send_success(data.result.id)
+					}, 
+					function() {
+						send_failure("Failed to save data")
+					}
+				);
+			});
+		});
+
+	}, send_failure.bind("Failed to load data"));
+
+
+    return;
+}
+
+if (request.RequestType == "Delete") {
+
+	load_data(function(domain_id, record_id) {
+
+		delete_cname_dns_record(domain_id, record_id, function() {
+			send_success(record_id)
+		});
+
+	}, send_failure.bind("Failed to load data"));
+    return;
+}