lono 0.5.2 → 1.0.0

data/lib/starter_project_yaml/templates/partial/user_data/bootstrap.sh.erb

@@ -0,0 +1,5 @@
+#!/bin/bash -lexv
+<% stack_name = "#{@app}-#{@role}-#{@env}" -%>
+exec > >(tee /var/log/user-data.log|logger -t user-data -s 2>/dev/console) 2>&1
+echo <%= stack_name %> > /tmp/stack_name
+cat /proc/uptime | cut -f1 -d'.' > /tmp/time-to-boot

data/lib/starter_project_yaml/templates/web.yml.erb

@@ -0,0 +1,205 @@
+<% @app,@role,@env = name.sub('.yml','').split('-') -%>
+---
+AWSTemplateFormatVersion: '2010-09-09'
+Description: <%= @app.capitalize %> Stack
+Outputs:
+  ELBHostname:
+    Description: The URL of the website
+    Value:
+      Fn::Join:
+      - ''
+      - - http://
+        - Fn::GetAtt:
+          - elb
+          - DNSName
+Parameters:
+  Ami:
+    Default: <%= @ami %>
+    Description: Ami id
+    Type: String
+  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
+    - t2.nano
+    - t2.micro
+    - t2.small
+    - t2.medium
+    - t2.large
+    - t2.xlarge
+    - t2.2xlarge
+    - m4.large
+    - m4.xlarge
+    - m4.2xlarge
+    - m4.4xlarge
+    - m4.10xlarge
+    - m4.16xlarge
+    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
+  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 %>
+      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
+<%= partial("host_record.yml.erb", domain: "mydomain.net") %>
+  LaunchConfig:
+    Properties:
+      BlockDeviceMappings:
+      - DeviceName: "/dev/sdb"
+        VirtualName: ephemeral0
+      ImageId: !Ref Ami
+      InstanceType: !Ref InstanceType
+      KeyName:
+        Ref: KeyName
+      SecurityGroups:
+      - global
+      - Fn::Join:
+        - "-"
+        - - Ref: Application
+          - Ref: Environment
+      - Ref: ServiceSecurityGroup
+      UserData:
+        Fn::Base64: !Sub | # No more Fn::Join needed
+<%= partial("user_data/bootstrap.sh.erb", {}, indent: 10) %>
+    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: !GetAZs ""
+      HealthCheckGracePeriod: '300'
+      HealthCheckType: ELB
+      LaunchConfigurationName:
+        Ref: LaunchConfig
+      LoadBalancerNames:
+      - Ref: elb
+      MaxSize: '<%= @max_size %>'
+      MinSize: '<%= @min_size %>'
+    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: !GetAZs ""
+      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
+      <% if @ssl_cert %>
+      - InstancePort:
+          Ref: WebServerPort
+        LoadBalancerPort: '443'
+        PolicyNames: []
+        Protocol: HTTPS
+        SSLCertificateId: '<%= @ssl_cert %>'
+      <% end %>
+    Type: AWS::ElasticLoadBalancing::LoadBalancer

data/lono.gemspec

@@ -28,5 +28,5 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'rspec'
   gem.add_development_dependency 'guard-rspec'
   gem.add_development_dependency 'guard-bundler'
-
+  gem.add_development_dependency 'byebug'
 end

data/spec/lib/lono/dsl_spec.rb

@@ -0,0 +1,184 @@
+require File.expand_path("../../../spec_helper", __FILE__)
+
+describe Lono::DSL do
+  before(:each) do
+    @project_root = File.expand_path("../../../../tmp/lono_project", __FILE__)
+  end
+  after(:each) do
+    FileUtils.rm_rf(@project_root) unless ENV['KEEP_TMP_PROJECT']
+  end
+
+  context "json starter project" do
+    before(:each) do
+      new_project = Lono::New.new(
+        force: true,
+        quiet: true,
+        format: 'json',
+        project_root: @project_root
+      )
+      new_project.run
+    end
+
+    it "json" do
+      dsl = Lono::DSL.new(
+        project_root: @project_root,
+        quiet: true
+      )
+      dsl.evaluate # run the dependent instance_eval and load_subfoler so @templates is assigned
+      detected_format = dsl.detect_format
+      expect(detected_format).to eq 'json'
+    end
+  end
+
+  context "yaml starter project" do
+    before(:each) do
+      new_project = Lono::New.new(
+        force: true,
+        quiet: true,
+        format: 'yaml',
+        project_root: @project_root
+      )
+      new_project.run
+    end
+
+    it "yaml" do
+      dsl = Lono::DSL.new(
+        project_root: @project_root,
+        quiet: true
+      )
+      dsl.evaluate # run the dependent instance_eval and load_subfoler so @templates is assigned
+      detected_format = dsl.detect_format
+      expect(detected_format).to eq 'yaml'
+    end
+  end
+
+  context "multiple format starter project" do
+    # it "yaml" do
+    #   dsl = Lono::DSL.new(
+    #     project_root: @project,
+    #     quiet: true
+    #   )
+    #   detected_format = dsl.detect_format
+    #   expect(detected_format).to eq 'yaml'
+    # end
+  end
+
+  context "json starter project" do
+    before(:each) do
+      new_project = Lono::New.new(
+        force: true,
+        quiet: true,
+        format: 'json',
+        project_root: @project_root
+      )
+      new_project.run
+
+      dsl = Lono::DSL.new(
+        project_root: @project_root,
+        quiet: true
+      )
+      dsl.run
+    end
+
+    it "should generate cloudformation template" do
+      raw = IO.read("#{@project_root}/output/api-web-prod.json")
+      json = JSON.load(raw)
+      expect(json['Description']).to eq "Api Stack"
+      expect(json['Mappings']['AWSRegionArch2AMI']['us-east-1']['64']).to eq 'ami-123'
+    end
+
+    it "should make trailing options pass to the partial helper available as instance variables" do
+      raw = IO.read("#{@project_root}/output/api-web-prod.json")
+      json = JSON.load(raw)
+      expect(json['Resources']['HostRecord']['Properties']['Comment']).to eq 'DNS name for mydomain.com'
+    end
+
+    it "should generate user data with variables" do
+      raw = IO.read("#{@project_root}/output/api-redis-prod.json")
+      json = JSON.load(raw)
+      expect(json['Description']).to eq "Api redis"
+      user_data = json['Resources']['server']['Properties']['UserData']['Fn::Base64']['Fn::Join'][1]
+      expect(user_data).to include("VARTEST=foo\n")
+    end
+
+    it "should include multiple user_data scripts" do
+      raw = IO.read("#{@project_root}/output/api-redis-prod.json")
+      json = JSON.load(raw)
+      expect(json['Description']).to eq "Api redis"
+      user_data = json['Resources']['server']['Properties']['UserData']['Fn::Base64']['Fn::Join'][1]
+      expect(user_data).to include("DB2=test\n")
+    end
+
+    it "should generate db template" do
+      raw = IO.read("#{@project_root}/output/api-redis-prod.json")
+      json = JSON.load(raw)
+      expect(json['Description']).to eq "Api redis"
+      user_data = json['Resources']['server']['Properties']['UserData']['Fn::Base64']['Fn::Join'][1]
+      expect(user_data).to include({"Ref" => "AWS::StackName"})
+      expect(user_data).to include({"Ref" => "WaitHandle"})
+      expect(user_data).to include({
+        "Fn::FindInMap" => [
+          "EnvironmentMapping",
+          "HostnamePrefix",
+          {"Ref" => "Environment"}
+        ]
+      })
+      expect(user_data).to include({
+        "Fn::FindInMap" => [
+          "MapName",
+          "TopLevelKey",
+          "SecondLevelKey"
+        ]
+      })
+      expect(user_data).to include({"Ref" => "DRINK"})
+
+      expect(user_data).to include({"Fn::Base64" => "value to encode"})
+      expect(user_data).to include({"Fn::GetAtt" => ["server", "PublicDnsName"]})
+      expect(user_data).to include({"Fn::GetAZs" => "AWS::Region"})
+      expect(user_data).to include({"Fn::Join" => [ ':', ['a','b','c']]})
+      expect(user_data).to include({"Fn::Select" => [ '1', ['a','b','c']]})
+    end
+
+    it "should transform bash script to CF template user_data" do
+      block = Proc.new { }
+      template = Lono::Template.new("foo", block)
+
+      line = 'echo {"Ref"=>"AWS::StackName"} > /tmp/stack_name ; {"Ref"=>"Ami"}'
+      data = template.transform(line)
+      expect(data).to eq ["echo ", {"Ref"=>"AWS::StackName"}, " > /tmp/stack_name ; ", {"Ref"=>"Ami"}, "\n"]
+
+      line = 'echo {"Ref"=>"AWS::StackName"} > /tmp/stack_name'
+      data = template.transform(line)
+      expect(data).to eq ["echo ", {"Ref"=>"AWS::StackName"}, " > /tmp/stack_name\n"]
+
+      line = 'echo {"Fn::FindInMap" => [ "A", "B", {"Ref"=>"AWS::StackName"} ]}'
+      data = template.transform(line)
+      expect(data).to eq ["echo ", {"Fn::FindInMap" => ["A", "B", {"Ref"=>"AWS::StackName"}]}, "\n"]
+
+      line = 'echo {"Fn::FindInMap" => [ "A", "B", {"Ref"=>"AWS::StackName"} ]} > /tmp/stack_name ; {"Ref"=>"Ami"}'
+      data = template.transform(line)
+      expect(data).to eq ["echo ", {"Fn::FindInMap" => ["A", "B", {"Ref"=>"AWS::StackName"}]}, " > /tmp/stack_name ; ", {"Ref"=>"Ami"}, "\n"]
+    end
+
+    it "should not transform user_data ruby scripts" do
+      raw = IO.read("#{@project_root}/output/api-worker-prod.json")
+      json = JSON.load(raw)
+      user_data = json['Resources']['LaunchConfig']['Properties']['UserData']['Fn::Base64']['Fn::Join'][1]
+      expect(user_data).to include(%Q|ec2.tags.create(ec2.instances[my_instance_id], "Name", {value: Facter.hostname})\n|)
+      expect(user_data).to include(%Q{find_all{ |record_set| record_set[:name] == record_name }\n})
+    end
+
+    it "should create parent folders for parent/db-stack.json" do
+      directory_created = File.exist?("#{@project_root}/output/parent")
+      expect(directory_created).to be true
+    end
+
+    it "task should generate CloudFormation templates" do
+      raw = IO.read("#{@project_root}/output/api-web-prod.json")
+      json = JSON.load(raw)
+      expect(json['Description']).to eq "Api Stack"
+      expect(json['Mappings']['AWSRegionArch2AMI']['us-east-1']['64']).to eq 'ami-123'
+    end
+  end
+
+end

data/spec/lib/lono/new_spec.rb

@@ -0,0 +1,59 @@
+require File.expand_path("../../../spec_helper", __FILE__)
+
+describe Lono::New do
+  before(:each) do
+    @project_root = File.expand_path("../../../../tmp/lono_project", __FILE__)
+  end
+  after(:each) do
+    FileUtils.rm_rf(@project_root) unless ENV['KEEP_TMP_PROJECT']
+  end
+
+  context "json starter project" do
+    before(:each) do
+      new_project = Lono::New.new(
+        force: true,
+        quiet: true,
+        format: 'json',
+        project_root: @project_root
+      )
+      new_project.run
+    end
+
+    it "should be able to lono generate" do
+      dsl = Lono::DSL.new(
+        project_root: @project_root,
+        quiet: true
+      )
+      dsl.run
+      generated = File.exist?("#{@project_root}/output/blog-web-prod.json")
+      expect(generated).to be true
+    end
+  end
+
+  context "yaml starter project" do
+    before(:each) do
+      new_project = Lono::New.new(
+        force: true,
+        quiet: true,
+        format: 'yaml',
+        project_root: @project_root
+      )
+      new_project.run
+    end
+
+    it "should be able to lono generate" do
+      dsl = Lono::DSL.new(
+        project_root: @project_root,
+        quiet: true
+      )
+      dsl.run
+      generated = File.exist?("#{@project_root}/output/blog-web-prod.yml")
+      expect(generated).to be true
+    end
+  end
+
+  context "multiple format starter project" do
+    # TODO: this should not generate anything but puts out a message to the user that the
+    # project needs to be either all yaml or all json format
+  end
+end