lono 0.1.1

data/lib/lono.rb

@@ -0,0 +1,6 @@
+require 'json'
+
+$:.unshift File.dirname(__FILE__)
+require 'lono/cli'
+require 'lono/task'
+require 'lono/dsl'

data/lib/lono/cli.rb

@@ -0,0 +1,25 @@
+require 'thor'
+
+module Lono
+  class CLI < Thor
+
+    desc "init", "Setup lono project"
+    long_desc "Sets up config/lono.rb"
+    def init
+      Lono::Task.init
+    end
+
+    desc "generate", "Generate the cloud formation templates"
+    long_desc <<EOL
+Examples:
+
+1. lono generate
+
+Builds the cloud formation templates files based on config/lono.rb and writes them to the output folder on the filesystem.
+EOL
+    def generate
+      Lono::Task.generate(options.dup.merge(:verbose => true))
+    end
+  end
+  
+end

data/lib/lono/dsl.rb

@@ -0,0 +1,69 @@
+require 'erb'
+
+module Lono
+  class DSL
+    def initialize(options={})
+      @options = options
+      @path = options[:config_path] || 'config/lono.rb'
+      @templates = []
+      @results = {}
+    end
+
+    def evaluate
+      instance_eval(File.read(@path), @path)
+    end
+
+    def template(name, &block)
+      @templates << {:name => name, :block => block}
+    end
+
+    def build
+      @templates.each do |t|
+        @results[t[:name]] = Template.new(t[:name], t[:block], @options).build
+      end
+    end
+
+    def output(options={})
+      output_path = options[:output_path] || 'output'
+      FileUtils.mkdir(output_path) unless File.exist?(output_path)
+      puts "Generating Cloud Formation templates:" if options[:verbose]
+      @results.each do |name,json|
+        path = "#{output_path}/#{name}"
+        puts "  #{path}" if options[:verbose]
+        File.open(path, 'w') {|f| f.write(json) }
+      end
+    end
+
+    def run(options={})
+      evaluate
+      build
+      options.empty? ? output : output(options)
+    end
+  end
+
+  class Template
+    include ERB::Util
+    def initialize(name, block, options={})
+      @name = name
+      @block = block
+      @options = options
+      @options[:project_root] ||= '.'
+    end
+
+    def build
+      instance_eval(&@block)
+      template = IO.read(@source)
+      ERB.new(template).result(binding)
+    end
+
+    def source(path)
+      @source = "#{@options[:project_root]}/templates/#{path}"
+    end
+
+    def variables(vars={})
+      vars.each do |var,value|
+        instance_variable_set("@#{var}", value)
+      end
+    end
+  end
+end

data/lib/lono/task.rb

@@ -0,0 +1,36 @@
+module Lono
+  class Task
+    def self.init(options={})
+      project_root = options[:project_root] || '.'
+      puts "Settin up lono project" unless options[:quiet]
+      %w[Guardfile config/lono.rb templates/app.json.erb].each do |name|
+        source = File.expand_path("../../files/#{name}", __FILE__)
+        dirname = File.dirname(name)
+        FileUtils.mkdir(dirname) unless File.exist?(dirname)
+        dest = "#{project_root}/#{name}"
+
+        if File.exist?(dest)
+          puts "already exists: #{dest}" unless options[:quiet]
+        else
+          puts "creating: #{dest}" unless options[:quiet]
+          FileUtils.cp(source, dest)
+        end
+      end
+    end
+    def self.generate(options)
+      new(options).generate
+    end
+
+    def initialize(options={})
+      @options = options
+      if options.empty?
+        @dsl = DSL.new
+      else
+        @dsl = DSL.new(options)
+      end
+    end
+    def generate
+      @dsl.run(@options)
+    end
+  end
+end

data/lib/lono/version.rb

@@ -0,0 +1,3 @@
+module Lono
+  VERSION = "0.1.1"
+end

data/lono.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/lono/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Tung Nguyen"]
+  gem.email         = ["tongueroo@gmail.com"]
+  gem.description   = %q{Lono generates cloud formation templates based on erb templates.}
+  gem.summary       = %q{Lono generates cloud formation templates based on erb templates.}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "lono"
+  gem.require_paths = ["lib"]
+  gem.version       = Lono::VERSION
+
+  gem.add_dependency "rake"
+  gem.add_dependency "json"
+  gem.add_dependency "thor"
+  gem.add_dependency "aws-sdk"
+  gem.add_dependency 'guard'
+  gem.add_dependency 'rb-fsevent'
+  gem.add_dependency "guard-cloudformation"
+  gem.add_dependency "guard-lono"
+
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'guard-rspec'
+  gem.add_development_dependency 'guard-bundler'
+
+end

data/spec/lib/lono_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Lono do
+  before(:each) do
+    @project_root = File.expand_path("../../project", __FILE__)
+    @dsl = Lono::DSL.new(
+      :config_path => "#{@project_root}/config/lono.rb",
+      :project_root => @project_root
+    )
+    @dsl.evaluate
+  end
+
+  after(:each) do
+    FileUtils.rm_rf("#{@project_root}/output")
+  end
+
+  it "should generate cloud formation template" do
+    @dsl.build
+    @dsl.output(:output_path => "#{@project_root}/output")
+    raw = IO.read("#{@project_root}/output/prod-api-app.json")
+    json = JSON.load(raw)
+    json['Description'].should == "Api Stack"
+    json['Mappings']['AWSRegionArch2AMI']['us-east-1']['64'].should == 'ami-123'
+  end
+end
+
+describe Lono::Task do
+  before(:each) do
+    @project_root = File.expand_path("../../project", __FILE__)
+  end
+
+  after(:each) do
+    FileUtils.rm_rf("#{@project_root}/output")
+  end
+
+  it "task should generate cloud formation templates" do
+    Lono::Task.generate(
+      :project_root => @project_root,
+      :config_path => "#{@project_root}/config/lono.rb",
+      :output_path => "#{@project_root}/output"
+    )
+    raw = IO.read("#{@project_root}/output/prod-api-app.json")
+    json = JSON.load(raw)
+    json['Description'].should == "Api Stack"
+    json['Mappings']['AWSRegionArch2AMI']['us-east-1']['64'].should == 'ami-123'
+  end
+end

data/spec/project/config/lono.rb

@@ -0,0 +1,39 @@
+template "prod-api-app.json" do
+  source "app.json.erb"
+  variables(
+    :env => 'prod',
+    :app => 'api',
+    :role => "app",
+    :ami => "ami-123",
+    :instance_type => "c1.xlarge",
+    :port => "80",
+    :high_threshold => "15",
+    :high_periods => "4",
+    :low_threshold => "5",
+    :low_periods => "10",
+    :max_size => "24",
+    :min_size => "6",
+    :down_adjustment => "-3",
+    :up_adjustment => "3",
+    :ssl_cert => "arn:aws:iam::12345:server-certificate/wildcard"
+  )
+end
+template "prod-br-app.json" do
+  source "app.json.erb"
+  variables(
+    :env => "prod",
+    :app => 'br',
+    :role => "app",
+    :ami => "ami-456",
+    :instance_type => "m1.medium",
+    :port => "80",
+    :high_threshold => "35",
+    :high_periods => "4",
+    :low_threshold => "20",
+    :low_periods => "2",
+    :max_size => "6",
+    :min_size => "3",
+    :down_adjustment => "-1",
+    :up_adjustment => "2"
+  )
+end

data/spec/project/templates/app.json.erb

@@ -0,0 +1,424 @@
+{
+    "AWSTemplateFormatVersion": "2010-09-09", 
+    "Description": "<%= @app.capitalize %> Stack", 
+    "Mappings": {
+        "AWSInstanceType2Arch": {
+            "c1.medium": {
+                "Arch": "64"
+            }, 
+            "c1.xlarge": {
+                "Arch": "64"
+            }, 
+            "cc1.4xlarge": {
+                "Arch": "64"
+            }, 
+            "cc2.8xlarge": {
+                "Arch": "64"
+            }, 
+            "cg1.4xlarge": {
+                "Arch": "64"
+            }, 
+            "m1.large": {
+                "Arch": "64"
+            }, 
+            "m1.medium": {
+                "Arch": "64"
+            }, 
+            "m1.small": {
+                "Arch": "64"
+            }, 
+            "m1.xlarge": {
+                "Arch": "64"
+            }, 
+            "m2.2xlarge": {
+                "Arch": "64"
+            }, 
+            "m2.4xlarge": {
+                "Arch": "64"
+            }, 
+            "m2.xlarge": {
+                "Arch": "64"
+            }, 
+            "t1.micro": {
+                "Arch": "64"
+            }
+        }, 
+        "AWSRegionArch2AMI": {
+            "us-east-1": {
+                "32": "", 
+                "64": "<%= @ami %>"
+            }, 
+            "us-west-1": {
+                "32": "", 
+                "64": ""
+            }
+        }
+    }, 
+    "Outputs": {
+        "ELBHostname": {
+            "Description": "The URL of the website", 
+            "Value": {
+                "Fn::Join": [
+                    "", 
+                    [
+                        "http://", 
+                        {
+                            "Fn::GetAtt": [
+                                "elb", 
+                                "DNSName"
+                            ]
+                        }
+                    ]
+                ]
+            }
+        }
+    }, 
+    "Parameters": {
+        "Application": {
+            "Default": "<%= @app %>", 
+            "Description": "Application name", 
+            "Type": "String"
+        }, 
+        "Environment": {
+            "Default": "<%= @env %>", 
+            "Description": "stag, prod etc", 
+            "Type": "String"
+        }, 
+        "InstanceType": {
+            "AllowedValues": [
+                "t1.micro", 
+                "m1.small", 
+                "m1.medium", 
+                "m1.large", 
+                "m1.xlarge", 
+                "m2.xlarge", 
+                "m2.2xlarge", 
+                "m2.4xlarge", 
+                "c1.medium", 
+                "c1.xlarge", 
+                "cc1.4xlarge", 
+                "cc2.8xlarge", 
+                "cg1.4xlarge"
+            ], 
+            "ConstraintDescription": "must be a valid EC2 instance type.", 
+            "Default": "<%= @instance_type %>", 
+            "Description": "WebServer EC2 instance type", 
+            "Type": "String"
+        }, 
+        "KeyName": {
+            "Default": "default", 
+            "Description": "The EC2 Key Pair to allow SSH access to the instances", 
+            "Type": "String"
+        }, 
+        "Role": {
+            "Default": "<%= @role %>", 
+            "Description": "redis, psql, app, etc", 
+            "Type": "String"
+        }, 
+        "StackNumber": {
+            "Description": "s1, s2, s3, etc", 
+            "Type": "String"
+        }, 
+        "WebServerPort": {
+            "Default": "<%= @port %>", 
+            "Description": "The TCP port for the Web Server", 
+            "Type": "Number"
+        }
+    }, 
+    "Resources": {
+        "CPUAlarmHigh": {
+            "Properties": {
+                "AlarmActions": [
+                    {
+                        "Ref": "WebServerScaleUpPolicy"
+                    }
+                ], 
+                "AlarmDescription": "Scale-up if CPU > <%= @high_threshold %>% for <%= @high_mins %> minutes", 
+                "ComparisonOperator": "GreaterThanThreshold", 
+                "Dimensions": [
+                    {
+                        "Name": "AutoScalingGroupName", 
+                        "Value": {
+                            "Ref": "WebServerGroup"
+                        }
+                    }
+                ], 
+                "EvaluationPeriods": "<%= @high_periods %>", 
+                "MetricName": "CPUUtilization", 
+                "Namespace": "AWS/EC2", 
+                "Period": "60", 
+                "Statistic": "Average", 
+                "Threshold": "<%= @high_threshold %>"
+            }, 
+            "Type": "AWS::CloudWatch::Alarm"
+        }, 
+        "CPUAlarmLow": {
+            "Properties": {
+                "AlarmActions": [
+                    {
+                        "Ref": "WebServerScaleDownPolicy"
+                    }
+                ], 
+                "AlarmDescription": "Scale-down if CPU < <%= @low_threshold %>% for 10 minutes", 
+                "ComparisonOperator": "LessThanThreshold", 
+                "Dimensions": [
+                    {
+                        "Name": "AutoScalingGroupName", 
+                        "Value": {
+                            "Ref": "WebServerGroup"
+                        }
+                    }
+                ], 
+                "EvaluationPeriods": "<%= @low_periods %>", 
+                "MetricName": "CPUUtilization", 
+                "Namespace": "AWS/EC2", 
+                "Period": "60", 
+                "Statistic": "Average", 
+                "Threshold": "<%= @low_threshold %>"
+            }, 
+            "Type": "AWS::CloudWatch::Alarm"
+        }, 
+        "HostRecord": {
+            "Properties": {
+                "Comment": "DNS name for my stack.", 
+                "HostedZoneName": "mydomain.net.", 
+                "Name": {
+                    "Fn::Join": [
+                        "", 
+                        [
+                            {
+                                "Ref": "AWS::StackName"
+                            }, 
+                            ".mydomain.net"
+                        ]
+                    ]
+                }, 
+                "ResourceRecords": [
+                    {
+                        "Fn::GetAtt": [
+                            "elb", 
+                            "DNSName"
+                        ]
+                    }
+                ], 
+                "TTL": "60", 
+                "Type": "CNAME"
+            }, 
+            "Type": "AWS::Route53::RecordSet"
+        }, 
+        "LaunchConfig": {
+            "Properties": {
+                "BlockDeviceMappings": [
+                    {
+                        "DeviceName": "/dev/sdb", 
+                        "VirtualName": "ephemeral0"
+                    }
+                ], 
+                "ImageId": {
+                    "Fn::FindInMap": [
+                        "AWSRegionArch2AMI", 
+                        {
+                            "Ref": "AWS::Region"
+                        }, 
+                        {
+                            "Fn::FindInMap": [
+                                "AWSInstanceType2Arch", 
+                                {
+                                    "Ref": "InstanceType"
+                                }, 
+                                "Arch"
+                            ]
+                        }
+                    ]
+                }, 
+                "InstanceType": {
+                    "Ref": "InstanceType"
+                }, 
+                "KeyName": {
+                    "Ref": "KeyName"
+                }, 
+                "SecurityGroups": [
+                    "global", 
+                    {
+                        "Fn::Join": [
+                            "-", 
+                            [
+                                {
+                                    "Ref": "Environment"
+                                }, 
+                                {
+                                    "Ref": "Application"
+                                }
+                            ]
+                        ]
+                    }, 
+                    {
+                        "Ref": "ServiceSecurityGroup"
+                    }
+                ], 
+                "UserData": {
+                    "Fn::Base64": {
+                        "Fn::Join": [
+                            "", 
+                            [
+                                "#!/bin/bash -lexv\n", 
+                                "exec > >(tee /var/log/user-data.log|logger -t user-data -s 2>/dev/console) 2>&1\n", 
+                                "echo ", 
+                                {
+                                    "Ref": "AWS::StackName"
+                                }, 
+                                " > /tmp/stackname\n", 
+                                "echo \"\" >> /etc/profile.d/base.sh\n", 
+                                "'\" >> /etc/profile.d/base.sh\n", 
+                                "source /etc/profile.d/base.sh\n", 
+                                "set +e\n", 
+                                "rvm use system --default\n", 
+                                "set -e\n",
+                                "echo 'running' > /tmp/type-of-instance\n", 
+                                "cat /proc/uptime | cut -f1 -d'.' > /tmp/time-to-boot\n"
+                            ]
+                        ]
+                    }
+                }
+            }, 
+            "Type": "AWS::AutoScaling::LaunchConfiguration"
+        }, 
+        "ServiceSecurityGroup": {
+            "Properties": {
+                "GroupDescription": "Enable SSH access and HTTP from the load balancer only", 
+                "SecurityGroupIngress": [
+                    {
+                        "CidrIp": "0.0.0.0/0", 
+                        "FromPort": "22", 
+                        "IpProtocol": "tcp", 
+                        "ToPort": "22"
+                    }, 
+                    {
+                        "FromPort": {
+                            "Ref": "WebServerPort"
+                        }, 
+                        "IpProtocol": "tcp", 
+                        "SourceSecurityGroupName": {
+                            "Fn::GetAtt": [
+                                "elb", 
+                                "SourceSecurityGroup.GroupName"
+                            ]
+                        }, 
+                        "SourceSecurityGroupOwnerId": {
+                            "Fn::GetAtt": [
+                                "elb", 
+                                "SourceSecurityGroup.OwnerAlias"
+                            ]
+                        }, 
+                        "ToPort": {
+                            "Ref": "WebServerPort"
+                        }
+                    }
+                ]
+            }, 
+            "Type": "AWS::EC2::SecurityGroup"
+        }, 
+        "WebServerGroup": {
+            "Properties": {
+                "AvailabilityZones": [
+                    "us-east-1a", 
+                    "us-east-1d",
+                    "us-east-1e"
+                ], 
+                "HealthCheckGracePeriod": "300", 
+                "HealthCheckType": "ELB", 
+                "LaunchConfigurationName": {
+                    "Ref": "LaunchConfig"
+                }, 
+                "LoadBalancerNames": [
+                    {
+                        "Ref": "elb"
+                    }
+                ], 
+                "MaxSize": "<%= @max_size %>", 
+                "MinSize": "<%= @min_size %>", 
+                "NotificationConfiguration": {
+                    "NotificationTypes": [
+                        "autoscaling:EC2_INSTANCE_LAUNCH", 
+                        "autoscaling:EC2_INSTANCE_LAUNCH_ERROR", 
+                        "autoscaling:EC2_INSTANCE_TERMINATE", 
+                        "autoscaling:EC2_INSTANCE_TERMINATE_ERROR"
+                    ], 
+                    "TopicARN": [
+                        "arn:aws:sns:us-east-1:867690557112:ops"
+                    ]
+                }
+            }, 
+            "Type": "AWS::AutoScaling::AutoScalingGroup"
+        }, 
+        "WebServerScaleDownPolicy": {
+            "Properties": {
+                "AdjustmentType": "ChangeInCapacity", 
+                "AutoScalingGroupName": {
+                    "Ref": "WebServerGroup"
+                }, 
+                "Cooldown": "120", 
+                "ScalingAdjustment": "<%= @down_adjustment %>"
+            }, 
+            "Type": "AWS::AutoScaling::ScalingPolicy"
+        }, 
+        "WebServerScaleUpPolicy": {
+            "Properties": {
+                "AdjustmentType": "ChangeInCapacity", 
+                "AutoScalingGroupName": {
+                    "Ref": "WebServerGroup"
+                }, 
+                "Cooldown": "120", 
+                "ScalingAdjustment": "<%= @up_adjustment %>"
+            }, 
+            "Type": "AWS::AutoScaling::ScalingPolicy"
+        }, 
+        "elb": {
+            "Properties": {
+                "AvailabilityZones": [
+                    "us-east-1a", 
+                    "us-east-1d",
+                    "us-east-1e"
+                ], 
+                "HealthCheck": {
+                    "HealthyThreshold": "3", 
+                    "Interval": "6", 
+                    "Target": {
+                        "Fn::Join": [
+                            "", 
+                            [
+                                "HTTP:", 
+                                {
+                                    "Ref": "WebServerPort"
+                                }, 
+                                "/up/elb"
+                            ]
+                        ]
+                    }, 
+                    "Timeout": "5", 
+                    "UnhealthyThreshold": "5"
+                }, 
+                "Listeners": [
+                    {
+                        "InstancePort": {
+                            "Ref": "WebServerPort"
+                        }, 
+                        "LoadBalancerPort": "80", 
+                        "Protocol": "HTTP"
+                    }, 
+                    {
+                        "InstancePort": {
+                            "Ref": "WebServerPort"
+                        }, 
+                        "LoadBalancerPort": "443", 
+                        "PolicyNames": [], 
+                        "Protocol": "HTTPS", 
+                        "SSLCertificateId": "<%= @ssl_cert %>"
+                    }
+
+                ]
+            }, 
+            "Type": "AWS::ElasticLoadBalancing::LoadBalancer"
+        }
+    }
+}