cfndsl 0.1.16 → 0.1.17

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: 3639153a22d283db62bc8c36f03ae111675e6482
-  data.tar.gz: 8295dfbcbdc172a276a6b192ed99b5cc1d7769b3
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MzU3YmUxZDJhYTg1YWNjNmE5MWE5OWY3NDBiNzM5NjNhMTMxYmM4Mw==
+  data.tar.gz: !binary |-
+    OGM0MGQ3ZjY4YzllMDFiMGM2N2ZjNWNhZDhkN2U2OTVjY2QwYjhjMQ==
 SHA512:
-  metadata.gz: 89870880a076338d49b2b5d05770206cb7ef30b3f179098331f9424b883b4e61ae6c2e33bc240808b91c4a441429429d332ddb3533db460c67f4becbd20ea866
-  data.tar.gz: ce0e651c1738128b3513ac6da3badcf184795a21410952434685d71f83a3bebd64eabc579377c82d46467dd4ca80cd5cc442af21a31012bb058ecf82141e17f2
+  metadata.gz: !binary |-
+    ZmUwNTYyZmY0NjM4YWJmYzdhZmY2ZmVjNThmOTZhZTc0OGZjZDRmZmZjMzE5
+    N2UyNzg2NmM0MTJjZGUzMDNmMTc4YTk0ZmYxMjViMWY5MGQ0ZTI4ZDIzZmU2
+    MGNiZWU5Y2QxNWJlZmEyMTY3ZjMzNGQxYzBlYWFmOWNjNDlmMjE=
+  data.tar.gz: !binary |-
+    ZTczZDA1NTAzNDUyNDIwNGYxY2M4YjcxMjI3OWE1Mzc5YzQwNTM2MGQ3MjNi
+    ZWZiMWM0Y2ZhMWRkMGI4NGU2MDE5NDUyNDU0YjljYTQyNWNhY2JlNjU5Y2Qy
+    MDM1OWRkMTBlMTUxZDFiNzQ2NjU1NDQxNDYxMWNmNWQ2YmM4MjE=

data/.gitignore

@@ -0,0 +1,3 @@
+*.gem
+*~
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,19 @@
+language: ruby
+rvm:
+- 2.1.0
+sudo: false
+
+deploy:
+  provider: rubygems
+  api_key:
+    secure: AH+4R+m6U0kmALFYAYEQl2oF/dj1yOnu/M1ZOtWttk+Zjwnw6kFc0hFLbvxdy6uivq1XmMXVa9eXzDPsRjW4ow2g+UuDLxvkvfT45SMmJ5sYQpoiD7AIJnEvMu6TXnmfiRNgM5bHnV3oilNJ8KKCbCFCd+imGRLTkBuhLkhkejA=
+  gem: cfndsl
+  on:
+    tags: true
+    repo: stevenjack/cfndsl
+notifications:
+  email:
+    recipients:
+      - stevenmajack@gmail.com
+    on_failure: change
+    on_success: never

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'rake'
+  gem 'rspec'
+end

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Steven Jack
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,221 @@
+cfndsl
+======
+
+[![Build Status](https://travis-ci.org/stevenjack/cfndsl.png?branch=master)](https://travis-ci.org/stevenjack/cfndsl)
+[![Gem Version](https://badge.fury.io/rb/cfndsl.png)](http://badge.fury.io/rb/cfndsl)
+[![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/stevenjack/cfndsl?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+
+[AWS Cloudformation](http://docs.amazonwebservices.com/AWSCloudFormation/latest/UserGuide/GettingStarted.html) templates are an incredibly powerful way to build
+sets of resources in Amazon's AWS environment. Unfortunately, because
+they are specified in JSON, they are also difficult to write and
+maintain:
+
+* JSON does not allow comments
+
+* All structures are JSON, so it is sometimes easy for a person
+  reading a template to get lost.
+  
+* References and internal functions have a particularly unpleasant syntax.
+
+
+The cnfdsl gem provides a simple DSL that allows you to write equivalent
+templates in a more friendly language and generate the correct json
+templates by running ruby.
+
+## Getting Started
+
+    sudo gem install cfndsl
+	
+Now write a template in the dsl
+   
+```ruby
+
+CloudFormation {
+  Description "Test"
+  
+  Parameter("One") {
+    String
+    Default "Test"
+	MaxLength 15
+  }
+ 
+  Output(:One,FnBase64( Ref("One")))
+
+  EC2_Instance(:MyInstance) {
+    ImageId "ami-12345678"
+  }
+  
+}
+```
+
+Then run cfndsl on the file
+
+```
+chris@raspberrypi:~/git/cfndsl$ cfndsl test.rb | json_pp
+{
+   "Parameters" : {
+      "One" : {
+         "Type" : "String",
+         "Default" : "Test",
+         "MaxLength" : 15
+      }
+   },
+   "Resources" : {
+      "MyInstance" : {
+         "Type" : "AWS::EC2::Instance",
+         "Properties" : {
+            "ImageId" : "ami-12345678"
+         }
+      }
+   },
+   "AWSTemplateFormatVersion" : "2010-09-09",
+   "Outputs" : {
+      "One" : {
+         "Value" : {
+            "Fn::Base64" : {
+               "Ref" : "One"
+            }
+         }
+      }
+   },
+   "Description" : "Test"
+}
+```
+
+*Aside: that is correct - a significant amount of the development for
+this gem was done on a [Raspberry Pi](http://www.raspberrypi.org).*
+
+## Samples
+
+There is a more detailed example in the samples directory. The file
+"autoscale.template" is one of the standard Amazon sample templates. 
+"autoscale.rb" generates an equivalent template file.
+
+## Command Line Options
+
+The cfndsl command line program now accepts some command line options. 
+
+```
+Usage: cfndsl [options] FILE
+    -o, --output FILE                Write output to file
+    -y, --yaml FILE                  Import yaml file as local variables
+    -r, --ruby FILE                  Evaluate ruby file before template
+    -j, --json FILE                  Import json file as local variables
+    -D, --define "VARIABLE=VALUE"    Directly set local VARIABLE as VALUE
+    -v, --verbose                    Turn on verbose ouptut
+    -h, --help                       Display this screen
+```
+
+By default, cfndsl will attempt to evaluate FILE as cfndsl template and print 
+the resulting cloudformation json template to stdout. With the -o option, you
+can instead have it write the resulting json template to a given file. The -v 
+option prints out additional information (to stderr) about what is happening
+in the model generation process. 
+
+The -y, -j, -r and -D options can be used to control some things about the
+environment that the template code gets evaluate in. For instance, the -D
+option allows you to set a variable at the command line that can then be 
+referred to within the template itself.
+
+This is best illustrated with a example. Consider the following cfndsl 
+template
+
+```ruby
+# cfndsl template t1.rb
+CloudFormation {
+
+  DESCRIPTION ||= "default description"
+  MACHINES ||= 3
+
+  Description DESCRIPTION
+
+  (1..MACHINES).each do |i|
+    name = "machine#{i}"
+    EC2_Instance(name) {
+      ImageId "ami-12345678"
+      Type "t1.micro"
+    }
+  end
+  
+}
+```
+
+Note the two variables "DESCRIPTION" and "MACHINES". The template
+sets these to some reasonable default values, and if you run cfndsl
+on it without changing them in any way you get the following cloudformation
+template:
+
+```json
+{
+  "Resources": {
+    "machine1": {
+      "Type": "AWS::EC2::Instance",
+      "Properties": {
+        "ImageId": "ami-12345678"
+      }
+    }
+  },
+  "Description": "default description",
+  "AWSTemplateFormatVersion": "2010-09-09"
+}
+```
+
+However if you run the command
+
+```bash
+$ cfndsl t1.rb -D 'DESCRIPTION="3 machine cluster"' -D 'MACHINES=3'
+```
+
+you get the following generated template.
+
+```json
+{
+  "Resources": {
+    "machine3": {
+      "Type": "AWS::EC2::Instance",
+      "Properties": {
+        "ImageId": "ami-12345678"
+      }
+    },
+    "machine2": {
+      "Type": "AWS::EC2::Instance",
+      "Properties": {
+        "ImageId": "ami-12345678"
+      }
+    },
+    "machine1": {
+      "Type": "AWS::EC2::Instance",
+      "Properties": {
+        "ImageId": "ami-12345678"
+      }
+    }
+  },
+  "Description": "3 machine cluster",
+  "AWSTemplateFormatVersion": "2010-09-09"
+}
+```
+
+The -y and -j options allow you to group several variable definitions
+into a single file (formated as either yaml or ruby respectively). If 
+you had a file called 't1.yaml' that contained the following,
+
+```yaml
+# t1.yaml
+DESCRIPTION: 5 machine cluster
+MACHINES: 5
+```
+
+the command
+
+```bash
+$ cfndsl t1.rb -y t1.yaml
+```
+
+would generate a template with 5 instances declared.
+
+Finally, the -r option gives you the opportunity to execute some
+arbitrary ruby code in the evaluation context before the cloudformation
+template is evaluated. 
+
+
+

data/Rakefile

@@ -0,0 +1,55 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "cfndsl/version"
+
+RSpec::Core::RakeTask.new
+
+task default: [:spec]
+
+task :bump, :type do |t, args|
+  type = args[:type].downcase
+  version_path = "lib/cfndsl/version.rb"
+
+  fail unless %w(major minor patch).include? type
+
+  if `git rev-parse --abbrev-ref HEAD` != "master"
+    fail "Looks like you're trying to create a release in a branch, you can only create one in 'master'"
+  end
+
+  version_segments = CfnDsl::VERSION.split(".").map(&:to_i)
+
+  case type
+  when "major"
+    version_segments[0]+= 1
+    version_segments[1] = 0
+    version_segments[2] = 0
+  when "minor"
+    version_segments[1]+= 1
+    version_segments[2] = 0
+  when "patch"
+    version_segments[2]+= 1
+  end
+
+  version = version_segments.join(".")
+
+  puts "Bumping gem from version #{CfnDsl::VERSION} to #{version} as a '#{type.capitalize}' release"
+
+  contents         = File.read version_path
+  updated_contents = contents.gsub(/([0-9\.]+)/, version)
+  File.write(version_path, updated_contents)
+
+  puts "Commiting version update"
+  `git add #{version_path}`
+  `git commit --message='#{type.capitalize} release #{version}'`
+
+  puts "Tagging release"
+  `git tag -a v#{version} -m 'Version #{version}'`
+
+  puts "Pushing branch"
+  `git push origin master`
+
+  puts "Pushing tag"
+  `git push origin v#{version}`
+
+  puts "All done, travis should pick up and release the gem now!"
+end

data/cfndsl.gemspec

@@ -0,0 +1,21 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "cfndsl/version"
+
+Gem::Specification.new do |s|
+  s.name                    = "cfndsl"
+  s.version                 = CfnDsl::VERSION
+  s.summary                 = "AWS Cloudformation DSL"
+  s.description             = "DSL for creating AWS Cloudformation templates"
+  s.authors                 = ["Steven Jack", "Chris Howe"]
+  s.email                   = ["stevenmajack@gmail.com", "chris@howeville.com"]
+  s.files                   = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  s.executables             << "cfndsl"
+  s.homepage                = "https://github.com/stevenjack/cfndsl"
+  s.license                 = "MIT"
+  s.test_files              = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths           = ["lib"]
+
+  s.add_development_dependency "bundler"
+end

data/lib/cfndsl/version.rb

@@ -0,0 +1,3 @@
+module CfnDsl
+  VERSION = "0.1.17"
+end

data/sample/autoscale.rb

@@ -0,0 +1,243 @@
+
+# We start things off by calling the CloudFormation function.
+CloudFormation {
+  # Declare the template format version
+  AWSTemplateFormatVersion "2010-09-09"
+
+  # As the DSL is really ruby, we get all of the different
+  # ways to quote strings that come with ruby.
+  Description %Q/
+Create a multi-az, load balanced, Auto Scaled sample web site. The
+Auto Scaling trigger is based on the CPU utilization of the web
+servers. The AMI is chosen based on the region in which the stack is
+run. This example creates a web service running across all
+availability zones in a region. The instances are load balanced with a
+simple health check. The web site is available on port 80, however,
+the instances can be configured to listen on any port (8888 by
+default).
+
+**WARNING** This template creates one or more Amazon EC2
+instances. You will be billed for the AWS resources used if you create
+a stack from this template.
+/
+
+  # We can declare Parameters anywhere in the CloudFormation
+  # block - these will get rolled up into the Parameters container
+  # in the output.
+  Parameter("InstanceType") {
+      Description "Type of EC2 instance to launch"
+      Type "String"
+      Default "m1.small"
+  }
+
+  Parameter( "WebServerPort") {
+    Description "The TCP port for the Web Server"
+    Type "String"
+    Default "8888"
+  }
+  Parameter("KeyName") {
+    Description "The EC2 Key Pair to allow SSH access to the instances"
+    Type "String"
+  }
+
+  # The same kind of thing for parameters works for mappings, 
+  # except that there is not a special object declared for mappings,
+  # so we just have to build a hash of hashes which will be turned
+  # directly into json.
+
+  Mapping("AWSRegionArch2AMI", {
+            "us-east-1" => { "32" => "ami-6411e20d", "64" => "ami-7a11e213" },
+            "us-west-1" => { "32" => "ami-c9c7978c", "64" => "ami-cfc7978a" },
+            "eu-west-1" => { "32" => "ami-37c2f643", "64" => "ami-31c2f645" },
+            "ap-southeast-1" => { "32" => "ami-66f28c34", "64" => "ami-60f28c32" },
+            "ap-northeast-1" => { "32" => "ami-9c03a89d", "64" => "ami-a003a8a1" }
+    })
+
+
+  # We can also write arbitrary ruby code
+
+  # Here we build up a ruby hash
+  architectures = {}
+  [ "t1.micro", "m1.large", "m1.xlarge", "m2.xlarge",
+    "m2.2xlarge", "m2.4xlarge", "c1.xlarge", "cc1.4xlarge" 
+  ].each do |arch|
+    # Iterate through the 64 bit machines to build a mapping for
+    # 64 bit architecture
+    architectures[arch] = { "Arch" => "64" }
+  end
+
+  [ "m1.small", "c1.medium"
+  ].each do |arch|
+    # iterate throught he 32 bit machine to build a mapping for
+    # 32 bit architectures
+    architectures[arch] = { "Arch" => "32" }
+  end
+  
+  Mapping("AWSInstanceType2Arch", architectures )
+  # This will add a mapping entry equivalent to the following to the
+  # template:
+  #
+  # "AWSInstanceType2Arch" : {
+  #   "m2.4xlarge" :  { "Arch" : "64" },
+  #   "c1.xlarge" :   { "Arch" : "64" },
+  #   "c1.medium" :   { "Arch" : "32" },
+  #   "m1.xlarge" :   { "Arch" : "64" },
+  #   "m1.large" :    { "Arch" : "64" },
+  #   "t1.micro" :    { "Arch" : "64" },
+  #   "m1.small" :    { "Arch" : "32" },
+  #   "m2.2xlarge" :  { "Arch" : "64" },
+  #   "m2.xlarge" :   { "Arch" : "64" },
+  #   "cc1.4xlarge" : { "Arch" : "64" }
+  # }
+
+
+  # Resources work similar to Parameters
+  Resource("WebServerGroup") {
+    Type "AWS::AutoScaling::AutoScalingGroup"
+
+    # To call aws template defined functions, call them like
+    # functios (leaving out the double colons). For example
+    # the following:
+    Property("AvailabilityZones", FnGetAZs("") )
+    # will generate JSON that includes
+    #     { "Fn::GetAZs : "" }
+    # as the value of the AvailabilityZones property for the
+    # "WebServerGroup" reqource.
+
+    # The same works for references
+    Property("LaunchConfigurationName", Ref( "LaunchConfig") )
+    Property("MinSize", "1")
+    Property("MaxSize", "3")
+
+    # If you need to set a property value to a JSON array in 
+    # the template, you can just use a ruby array in the DSL.
+    Property("LoadBalancerNames", [ Ref( "ElasticLoadBalancer") ] )
+
+  }
+
+  # You can use either strings or symbols for
+  # Resource/Parameter/Mapping/Output names
+  Resource( :LaunchConfig ) {
+    Type "AWS::AutoScaling::LaunchConfiguration"
+
+    Property("KeyName", Ref("KeyName") )
+    Property( "ImageId", 
+              FnFindInMap( "AWSRegionArch2AMI", Ref("AWS::Region"),
+                           FnFindInMap( "AWSInstanceType2Arch", Ref("InstanceType"),"Arch")))
+    Property("UserData",       FnBase64( Ref("WebServerPort")))
+    Property("SecurityGroups", [ Ref("InstanceSecurityGroup")])
+    Property("InstanceType",   Ref("InstanceType") )
+  }
+
+
+  Resource( "WebServerScaleUpPolicy" ) {
+    Type "AWS::AutoScaling::ScalingPolicy"
+    Property("AdjustmentType", "ChangeInCapacity")
+    Property("AutoScalingGroupName", Ref( "WebServerGroup") )
+    Property("Cooldown", "60")
+    Property("ScalingAdjustment", "1")
+  }
+   
+  Resource("WebServerScaleDownPolicy") {
+    Type "AWS::AutoScaling::ScalingPolicy"
+    Property("AdjustmentType", "ChangeInCapacity")
+    Property("AutoScalingGroupName", Ref( "WebServerGroup" ))
+    Property("Cooldown", "60")
+    Property("ScalingAdjustment", "-1")
+  }
+  
+
+  # You can use ruby language constructs to keep from repeating
+  # yourself
+
+  # declare an aray - we are going to use it to collect some
+  # resources that we create
+  alarms = [];
+
+  # When we declare a resource with "Resource", we are 
+  # actually calling a method on CfnDsl::CloudFormationTemplate
+  # that sets up the resource, and then returns it. We can use
+  # the return value for other means.
+  alarms.push Resource("CPUAlarmHigh") {
+    Type "AWS::CloudWatch::Alarm"
+    Property("AlarmDescription", "Scale-up if CPU > 90% for 10 minutes")
+    Property("Threshold", "90")
+    Property("AlarmActions", [ Ref("WebServerScaleUpPolicy" ) ])
+    Property("ComparisonOperator", "GreaterThanThreshold")
+  }
+
+  # Declare a second alarm resource and add it to our list
+  alarms.push Resource("CPUAlarmLow") {
+    Type "AWS::CloudWatch::Alarm"
+    Property("AlarmDescription", "Scale-down if CPU < 70% for 10 minutes")
+    Property("Threshold", "70")
+    Property("AlarmActions", [ Ref("WebServerScaleDownPolicy" ) ])
+    Property("ComparisonOperator", "LessThanThreshold")
+  }
+
+  # Ok, the alarms that we previously declared actually share a bunch
+  # of property declarations. Here we iterate through the alarms and
+  # call declare on each one, passing in a code block. This works the 
+  # same as the declarations placed in the code blocks that went along 
+  # with the call to Resource that was used to create the resouce above.
+  alarms.each do |alarm|
+    alarm.declare {
+      Property("MetricName", "CPUUtilization")
+      Property("Namespace", "AWS/EC2")
+      Property("Statistic", "Average")
+      Property("Period", "300")
+      Property("EvaluationPeriods", "2")
+      Property("Dimensions", [
+                              {
+                                "Name" => "AutoScalingGroupName",
+                                "Value" => Ref("WebServerGroup" )
+                              }
+                             ])
+
+    }
+  end
+
+
+  Resource( "ElasticLoadBalancer" ) {
+    Type "AWS::ElasticLoadBalancing::LoadBalancer"
+    Property( "AvailabilityZones", FnGetAZs(""))
+    Property( "Listeners" , [ {
+                                "LoadBalancerPort" => "80",
+                                "InstancePort" => Ref( "WebServerPort" ),
+                                "Protocol" => "HTTP"
+                              } ] )
+    Property( "HealthCheck" , {
+                # FnFormat replaces %0, %1, etc with passed in parameters
+                # Note that it renders to a call to Fn::Join in the json.
+                "Target" => FnFormat("HTTP:%0/", Ref( "WebServerPort" ) ),
+                "HealthyThreshold" => "3",
+                "UnhealthyThreshold" => "5",
+                "Interval" => "30",
+                "Timeout" => "5"
+              })
+  }
+  
+  Resource("InstanceSecurityGroup" ) {
+    Type "AWS::EC2::SecurityGroup"
+    Property("GroupDescription" , "Enable SSH access and HTTP access on the inbound port")
+    Property("SecurityGroupIngress", [ {
+          "IpProtocol" => "tcp",
+          "FromPort" => "22",
+          "ToPort" => "22",
+          "CidrIp" => "0.0.0.0/0"
+        },
+        {
+          "IpProtocol" => "tcp",
+          "FromPort" => Ref( "WebServerPort" ),
+          "ToPort" => Ref( "WebServerPort" ),
+          "SourceSecurityGroupOwnerId" => FnGetAtt("ElasticLoadBalancer", "SourceSecurityGroup.OwnerAlias"),
+          "SourceSecurityGroupName" => FnGetAtt("ElasticLoadBalancer", "SourceSecurityGroup.GroupName")
+        } ])
+  }
+
+  Output( "URL" ) {
+    Description "The URL of the website"
+    Value FnJoin( "", [ "http://", FnGetAtt( "ElasticLoadBalancer", "DNSName" ) ] )
+  }
+
+}