cloudformation-ruby-dsl 0.5.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3c4ac135faa6e385379b3156225d4408853fe025
-  data.tar.gz: 683175d8ba2a0933803e4cdfdb07eaed10a00a2c
+  metadata.gz: 8876df582be39f256601ca2194db3405936c941a
+  data.tar.gz: 2fe2e643711d1a26327553436d95c45b28632107
 SHA512:
-  metadata.gz: 8d25c190a403f173dd70def2b7b59bad1682e969cf3ccf6b786e2901a6a33f20c15ca59ce00520bf51e13acabd383ddcb65c57d7ee78efc974064ab071ccf808
-  data.tar.gz: 034d390533c3197d2f2fbffeeed5b4ccb352a6c40475d389cacb997b9a255e3f4111f7e39caa2f05906566499ee54629e497ac3b7525db7255e51cc537b716f9
+  metadata.gz: f96a60535eb7da50a6b7e21f38670a58186f8b7b8e09c33c44f638d4e333dfa2c951c8a20b96b361013b89f79ee147498c04cbd8056935c64d1363d852cc0c5c
+  data.tar.gz: df0e8ec6cfaa0497aa90bf8fa1d7eb68fa154133ab67ff1941ca1eaa8beb759d72b08bf14bb9db6de40dc61f853cf26e66c13535ab06e4378441fa8199a0ad26

data/README.md

@@ -39,9 +39,9 @@ You may need to preface this with `bundle exec` if you installed via Bundler.
 Make the resulting file executable (`chmod +x [NEW_NAME.rb]`). It can respond to the following subcommands (which are listed if you run without parameters):
 - `expand`: output the JSON template to the command line (takes optional `--nopretty` to minimize the output)
 - `diff`: compare output with existing JSON for a stack
-- `cfn-validate-template`: run validation against the stack definition
-- `cfn-create-stack`: create a new stack from the output
-- `cfn-update-stack`: update an existing stack from the output
+- `validate`: run validation against the stack definition
+- `create`: create a new stack from the output
+- `update`: update an existing stack from the output
 
 Below are the various functions currently available in the DSL. See [the example script](examples/cloudformation-ruby-script.rb) for more usage information.
 

data/bin/cfntemplate-to-ruby

@@ -119,6 +119,8 @@ def pprint_cfn_template(tpl)
         v.each { |name, options| pprint_cfn_section 'mapping', name, options }
       when 'Resources'
         v.each { |name, options| pprint_cfn_resource name, options }
+      when 'Conditions'
+        v.each { |name, options| pprint_cfn_section 'condition', name, options }
       when 'Outputs'
         v.each { |name, options| pprint_cfn_section 'output', name, options }
       else

data/cloudformation-ruby-dsl.gemspec

@@ -23,8 +23,8 @@ Gem::Specification.new do |gem|
   gem.version       = Cfn::Ruby::Dsl::VERSION
   gem.authors       = ["Shawn Smith", "Dave Barcelo", "Morgan Fletcher", "Csongor Gyuricza", "Igor Polishchuk", "Nathaniel Eliot", "Jona Fenocchi", "Tony Cui"]
   gem.email         = ["Shawn.Smith@bazaarvoice.com", "Dave.Barcelo@bazaarvoice.com", "Morgan.Fletcher@bazaarvoice.com", "Csongor.Gyuricza@bazaarvoice.com", "Igor.Polishchuk@bazaarvoice.com", "Nathaniel.Eliot@bazaarvoice.com", "Jona.Fenocchi@bazaarvoice.com", "Tony.Cui@bazaarvoice.com"]
-  gem.description   = %q{Ruby DSL library that provides a wrapper around the cfn-cmd.}
-  gem.summary       = %q{Ruby DSL library that provides a wrapper around the cfn-cmd.  Written by [Bazaarvoice](http://www.bazaarvoice.com).}
+  gem.description   = %q{Ruby DSL library that provides a wrapper around the CloudFormation.}
+  gem.summary       = %q{Ruby DSL library that provides a wrapper around the CloudFormation.  Written by [Bazaarvoice](http://www.bazaarvoice.com).}
   gem.homepage      = "http://github.com/bazaarvoice/cloudformation-ruby-dsl"
 
   gem.files         = `git ls-files`.split($/)
@@ -34,6 +34,7 @@ Gem::Specification.new do |gem|
 
   gem.add_runtime_dependency    'detabulator'
   gem.add_runtime_dependency    'json'
-  gem.add_runtime_dependency    'xml-simple'
   gem.add_runtime_dependency    'bundler'
+  gem.add_runtime_dependency    'aws-sdk'
+  gem.add_runtime_dependency    'diffy'
 end

data/examples/cloudformation-ruby-script.rb

@@ -30,7 +30,7 @@ template do
             :MaxLength => '25',
             :AllowedPattern => '[_a-zA-Z0-9]*',
             :ConstraintDescription => 'Maximum length of the Label parameter may not exceed 25 characters and may only contain letters, numbers and underscores.',
-            # The :Immutable attribute is a Ruby CFN extension.  It affects the behavior of the '<template> cfn-update-stack ...'
+            # The :Immutable attribute is a Ruby CFN extension.  It affects the behavior of the '<template> update ...'
             # operation in that a stack update may not change the values of parameters marked w/:Immutable => true.
             :Immutable => true
 
@@ -94,18 +94,18 @@ template do
   mapping 'TableExampleMultimap',
           vpc.get_multimap({ :visibility => 'private', :zone => ['a', 'c'] }, :env, :region, :subnet)
 
-  # The tag type is a Ruby CFN extension. These tags are excised from the template and used to generate a series of --tag arguments
-  #   which are passed to cfn-cmd. They do not ultimately appear in the expanded CloudFormation template. The diff subcommand will
-  #   compare tags with the running stack and identify any changes, but cfn-update-stack will do the diff and throw an error on any
+  # The tag type is a DSL extension; it is not a property of actual CloudFormation templates.
+  #   These tags are excised from the template and used to generate a series of --tag arguments which are passed to CloudFormation when a stack is created.
+  #   They do not ultimately appear in the expanded CloudFormation template.
+  #   The diff subcommand will compare tags with the running stack and identify any changes, but a stack update will do the diff and throw an error on any
   #   changes. The tags are propagated to all resources created by the stack, including the stack itself.
   #
   # Amazon has set the following restrictions on CloudFormation tags:
   #   => limit 10
-  #   => immutable (you may not cfn-update-stack with new tags or different values for existing tags -- they will be rejected)
+  #   => immutable (you may not update a stack with new tags or different values for existing tags -- they will be rejected)
   #
-  # Additionally, cfn-cmd throws an error if your tag value contains spaces. This limitation will be lifted when we move from cfn-cmd
-  #   to the new unified CLI.
   tag :MyTag => 'MyValue'
+  tag :MyOtherTag => 'My Value With Spaces'
 
   resource 'SecurityGroup', :Type => 'AWS::EC2::SecurityGroup', :Properties => {
       :GroupDescription => 'Lets any vpc traffic in.',
@@ -173,7 +173,7 @@ template do
 
   resource 'InstanceProfile', :Type => 'AWS::IAM::InstanceProfile', :Properties => {
       # use cfn intrinsic conditional to choose the 2nd value because the expression evaluates to false
-      :Path => fn_if(equals(3, 0), '/unselected/', '/'),
+      :Path => fn_if(equal(3, 0), '/unselected/', '/'),
       :Roles => [ ref('InstanceRole') ],
   }
 
@@ -191,7 +191,7 @@ template do
   }
 
   # add conditions that can be used elsewhere in the template
-  condition 'myCondition', fn_and(equals("one", "two"), not_equals("three", "four"))
+  condition 'myCondition', fn_and(equal("one", "two"), not_equal("three", "four"))
 
   output 'EmailSNSTopicARN',
           :Value => ref('EmailSNSTopic'),

data/lib/cloudformation-ruby-dsl/cfntemplate.rb

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require 'cloudformation-ruby-dsl/dsl'
+
 unless RUBY_VERSION >= '1.9'
   # This script uses Ruby 1.9 functions such as Enumerable.slice_before and Enumerable.chunk
   $stderr.puts "This script requires ruby 1.9+.  On OS/X use Homebrew to install ruby 1.9:"
@@ -23,25 +25,41 @@ require 'rubygems'
 require 'json'
 require 'yaml'
 require 'erb'
-require 'xmlsimple'
-
-VENDOR_PATH = File.expand_path("../../../vendor/AWSCloudFormation-1.0.12", __FILE__)
-SYSTEM_ENV = "export PATH=#{VENDOR_PATH}/bin:$PATH; export AWS_CLOUDFORMATION_HOME=#{VENDOR_PATH}"
+require 'aws-sdk'
+require 'diffy'
+
+############################# AWS SDK Support
+
+class AwsCfn
+  attr_accessor :cfn_client_instance
+
+  def cfn_client
+    if @cfn_client_instance == nil
+        # region and credentials are loaded from the environment; see http://docs.aws.amazon.com/sdkforruby/api/Aws/CloudFormation/Client.html
+        @cfn_client_instance = Aws::CloudFormation::Client.new(
+        # we don't validate parameters because the aws-ruby-sdk gets a number parameter and expects it to be a string and fails the validation
+        # see: https://github.com/aws/aws-sdk-ruby/issues/848
+        validate_params: false,
+      )
+    end
+    @cfn_client_instance
+  end
+end
 
-############################# Command-line and "cfn-cmd" Support
+############################# Command-line support
 
-# Parse command-line arguments based on cfn-cmd syntax (cfn-create-stack etc.) and return the parameters and region
-def cfn_parse_args
+# Parse command-line arguments and return the parameters and region
+def parse_args
   stack_name = nil
   parameters = {}
-  region = ENV['EC2_REGION'] || ENV['AWS_DEFAULT_REGION'] || 'us-east-1'
-  nopretty = false
+  region     = default_region
+  nopretty   = false
   ARGV.slice_before(/^--/).each do |name, value|
     case name
     when '--stack-name'
       stack_name = value
     when '--parameters'
-      parameters = Hash[value.split(/;/).map { |pair| pair.split(/=/, 2) }]
+      parameters = Hash[value.split(/;/).map { |pair| pair.split(/=/, 2) }]  #/# fix for syntax highlighting
     when '--region'
       region = value
     when '--nopretty'
@@ -51,14 +69,13 @@ def cfn_parse_args
   [stack_name, parameters, region, nopretty]
 end
 
-def cfn_cmd(template)
+def cfn(template)
+  aws_cfn = AwsCfn.new
+  cfn_client = aws_cfn.cfn_client
+
   action = ARGV[0]
-  unless %w(expand diff cfn-validate-template cfn-create-stack cfn-update-stack).include? action
-    $stderr.puts "usage: #{$PROGRAM_NAME} <expand|diff|cfn-validate-template|cfn-create-stack|cfn-update-stack>"
-    exit(2)
-  end
-  unless (ARGV & %w(--template-file --template-url)).empty?
-    $stderr.puts "#{File.basename($PROGRAM_NAME)}:  The --template-file and --template-url command-line options are not allowed."
+  unless %w(expand diff validate create update).include? action
+    $stderr.puts "usage: #{$PROGRAM_NAME} <expand|diff|validate|create|update>"
     exit(2)
   end
 
@@ -66,27 +83,27 @@ def cfn_cmd(template)
   # cfn template since we can't pass it to CloudFormation.
   immutable_parameters = template.excise_parameter_attribute!(:Immutable)
 
-  # Tag CloudFormation stacks based on :Tags defined in the template
+  # Tag CloudFormation stacks based on :Tags defined in the template.
+  # Remove them from the template as well, so that the template is valid.
   cfn_tags = template.excise_tags!
 
-  # Can't currently support spaces because the system() call escapes them and that fouls up the CLI
-  unless cfn_tags.select { |i| i =~ /\s+/ }.empty?
-    $stderr.puts "ERROR: Tag names or values cannot currently contain spaces. Please remove spaces and try again."
-    exit(2)
-  end
-
-  # The command line string looks like: --tag "Key=key; Value=value" --tag "Key2=key2; Value2=value"
-  cfn_tags_options = cfn_tags.sort.map { |tag| ["--tag", "Key=%s; Value=%s" % tag.split('=')] }.flatten
-
-  # example: <template.rb> cfn-create-stack my-stack-name --parameters "Env=prod" --region eu-west-1
-  # Execute the AWS CLI cfn-cmd command to validate/create/update a CloudFormation stack.
   if action == 'diff' or (action == 'expand' and not template.nopretty)
     template_string = JSON.pretty_generate(template)
   else
     template_string = JSON.generate(template)
   end
 
-  if action == 'expand'
+  # Derive stack name from ARGV
+  _, options = extract_options(ARGV[1..-1], %w(--nopretty), %w(--stack-name --region --parameters --tag))
+  # If the first argument is not an option and stack_name is undefined, assume it's the stack name
+  if template.stack_name.nil?
+    stack_name = options.shift if options[0] && !(/^-/ =~ options[0])
+  else
+    stack_name = template.stack_name
+  end
+
+  case action
+  when 'expand'
     # Write the pretty-printed JSON template to stdout and exit.  [--nopretty] option writes output with minimal whitespace
     # example: <template.rb> expand --parameters "Env=prod" --region eu-west-1 --nopretty
     if template.nopretty
@@ -95,146 +112,189 @@ def cfn_cmd(template)
       puts template_string
     end
     exit(true)
-  end
-
-  temp_file = File.absolute_path("#{$PROGRAM_NAME}.expanded.json")
-  File.write(temp_file, template_string)
-
-  cmdline = ['cfn-cmd'] + ARGV + ['--template-file', temp_file] + cfn_tags_options
 
-  # Add the required default capability if no capabilities were specified
-  cmdline = cmdline + ['-c', 'CAPABILITY_IAM'] if not ARGV.include?('--capabilities') or ARGV.include?('-c')
-
-  case action
   when 'diff'
     # example: <template.rb> diff my-stack-name --parameters "Env=prod" --region eu-west-1
     # Diff the current template for an existing stack with the expansion of this template.
 
-    # The --parameters and --tag options were used to expand the template but we don't need them anymore.  Discard.
-    _, cfn_options = extract_options(ARGV[1..-1], %w(), %w(--parameters --tag))
+    # We default to "output nothing if no differences are found" to make it easy to use the output of the diff call from within other scripts
+    # If you want output of the entire file, simply use this option with a large number, i.e., -U 10000
+    # In fact, this is what Diffy does by default; we just don't want that, and we can't support passing arbitrary options to diff
+    # because Diffy's "context" configuration is mutually exclusive with the configuration to pass arbitrary options to diff
+    if !options.include? '-U'
+      options.push('-U', '0')
+    end
 
-    # Separate the remaining command-line options into options for 'cfn-cmd' and options for 'diff'.
-    cfn_options, diff_options = extract_options(cfn_options, %w(),
-      %w(--stack-name --region --parameters --connection-timeout -I --access-key-id -S --secret-key -K --ec2-private-key-file-path -U --url))
+    # Ensure a stack name was provided
+    if stack_name.empty?
+      $stderr.puts "Error: a stack name is required"
+      exit(false)
+    end
 
-    # If the first argument is a stack name then shift it from diff_options over to cfn_options.
-    if diff_options[0] && !(/^-/ =~ diff_options[0])
-      cfn_options.unshift(diff_options.shift)
+    # describe the existing stack
+    begin
+      old_template_body = cfn_client.get_template({stack_name: stack_name}).template_body
+    rescue Aws::CloudFormation::Errors::ValidationError => e
+      $stderr.puts "Error: #{e}"
+      exit(false)
     end
 
-    # Run CloudFormation commands to describe the existing stack
-    cfn_options_string           = cfn_options.map { |arg| "'#{arg}'" }.join(' ')
-    old_template_raw             = exec_capture_stdout("cfn-cmd cfn-get-template #{cfn_options_string}")
-    # ec2 template output is not valid json: TEMPLATE  "<json>\n"\n
-    old_template_object          = JSON.parse(old_template_raw[11..-3])
-    old_template_string          = JSON.pretty_generate(old_template_object)
-    old_stack_attributes         = exec_describe_stack(cfn_options_string)
-    old_tags_string              = old_stack_attributes["TAGS"]
-    old_parameters_string        = old_stack_attributes["PARAMETERS"]
+    # parse the string into a Hash, then convert back into a string; this is the only way Ruby JSON lets us pretty print a JSON string
+    old_template   = JSON.pretty_generate(JSON.parse(old_template_body))
+    # there is only ever one stack, since stack names are unique
+    old_attributes = cfn_client.describe_stacks({stack_name: stack_name}).stacks[0]
+    old_tags       = old_attributes.tags
+    old_parameters = old_attributes.parameters
 
     # Sort the tag strings alphabetically to make them easily comparable
-    old_tags_string = (old_tags_string || '').split(';').sort.map { |tag| %Q(TAG "#{tag}"\n) }.join
+    old_tags_string = old_tags.sort.map { |tag| %Q(TAG "#{tag.key}=#{tag.value}"\n) }.join
     tags_string     = cfn_tags.sort.map { |tag| "TAG \"#{tag}\"\n" }.join
 
     # Sort the parameter strings alphabetically to make them easily comparable
-    old_parameters_string = (old_parameters_string || '').split(';').sort.map { |param| %Q(PARAMETER "#{param}"\n) }.join
+    old_parameters_string = old_parameters.sort! {|pCurrent, pNext| pCurrent.parameter_key <=> pNext.parameter_key }.map { |param| %Q(PARAMETER "#{param.parameter_key}=#{param.parameter_value}"\n) }.join
     parameters_string     = template.parameters.sort.map { |key, value| "PARAMETER \"#{key}=#{value}\"\n" }.join
 
-    # Diff the expanded template with the template from CloudFormation.
-    old_temp_file = File.absolute_path("#{$PROGRAM_NAME}.current.json")
-    new_temp_file = File.absolute_path("#{$PROGRAM_NAME}.expanded.json")
-    File.write(old_temp_file, old_tags_string + old_parameters_string + old_template_string)
-    File.write(new_temp_file, tags_string + parameters_string + template_string)
+    # set default diff options
+    Diffy::Diff.default_options.merge!(
+      :diff    => "#{options.join(' ')}",
+    )
+    # set default diff output
+    Diffy::Diff.default_format = :color
+
+    tags_diff     = Diffy::Diff.new(old_tags_string, tags_string).to_s.strip!
+    params_diff   = Diffy::Diff.new(old_parameters_string, parameters_string).to_s.strip!
+    template_diff = Diffy::Diff.new(old_template, template_string).to_s.strip!
+
+    if !tags_diff.empty?
+      puts "====== Tags ======"
+      puts tags_diff
+      puts "=================="
+      puts
+    end
 
-    # Compare templates
-    puts %x( #{SYSTEM_ENV}; #{(["diff"] + diff_options + [old_temp_file, new_temp_file]).join(' ')} )
+    if !params_diff.empty?
+      puts "====== Parameters ======"
+      puts params_diff
+      puts "========================"
+      puts
+    end
 
-    File.delete(old_temp_file)
-    File.delete(new_temp_file)
+    if !template_diff.empty?
+      puts "====== Template ======"
+      puts template_diff
+      puts "======================"
+      puts
+    end
 
     exit(true)
 
-  when 'cfn-validate-template'
-    # The cfn-validate-template command doesn't support --parameters so remove it if it was provided for template expansion.
-    _, cmdline = extract_options(cmdline, %w(), %w(--parameters --tag))
+  when 'validate'
+    begin
+      valid = cfn_client.validate_template({template_body: template_string})
+      exit(valid.successful?)
+    rescue Aws::CloudFormation::Errors::ValidationError => e
+      $stderr.puts "Validation error: #{e}"
+      exit(false)
+    end
 
-  when 'cfn-update-stack'
-    # Pick out the subset of cfn-update-stack options that apply to cfn-describe-stacks.
-    cfn_options, other_options = extract_options(ARGV[1..-1], %w(),
-      %w(--stack-name --region --connection-timeout -I --access-key-id -S --secret-key -K --ec2-private-key-file-path -U --url))
+  when 'create'
 
-    # If the first argument is a stack name then shift it over to cfn_options.
-    if other_options[0] && !(/^-/ =~ other_options[0])
-      cfn_options.unshift(other_options.shift)
+    begin
+      create_result = cfn_client.create_stack({
+          stack_name: stack_name,
+          template_body: template_string,
+          parameters: template.parameters.map { |k,v| {parameter_key: k, parameter_value: v}}.to_a,
+          tags: cfn_tags.map { |k,v| {"key" => k.to_s, "value" => v} }.to_a,
+          capabilities: ["CAPABILITY_IAM"],
+        })
+      if create_result.successful?
+        puts create_result.stack_id
+        exit(true)
+      end
+    rescue Aws::CloudFormation::Errors::ServiceError => e
+      $stderr.puts "Failed to create stack: #{e}"
+      exit(false)
     end
 
+  when 'update'
+
     # Run CloudFormation command to describe the existing stack
-    cfn_options_string = cfn_options.map { |arg| "'#{arg}'" }.join(' ')
-    old_stack_attributes = exec_describe_stack(cfn_options_string)
+    old_stack = cfn_client.describe_stacks({stack_name: stack_name}).stacks
+
+    # this might happen if, for example, stack_name is an empty string and the Cfn client returns ALL stacks
+    if old_stack.length > 1
+      $stderr.puts "Error: found too many stacks with this name. There should only be one."
+      exit(false)
+    else
+      # grab the first (and only) result
+      old_stack = old_stack[0]
+    end
 
     # If updating a stack and some parameters are marked as immutable, fail if the new parameters don't match the old ones.
     if not immutable_parameters.empty?
-      old_parameters_string = old_stack_attributes["PARAMETERS"]
-      old_parameters = Hash[(old_parameters_string || '').split(';').map { |pair| pair.split('=', 2) }]
+      old_parameters = Hash[old_stack.parameters.map { |p| [p.parameter_key, p.parameter_value]}]
       new_parameters = template.parameters
 
       immutable_parameters.sort.each do |param|
         if old_parameters[param].to_s != new_parameters[param].to_s
-          $stderr.puts "Error: cfn-update-stack may not update immutable parameter " +
+          $stderr.puts "Error: unable to update immutable parameter " +
                            "'#{param}=#{old_parameters[param]}' to '#{param}=#{new_parameters[param]}'."
           exit(false)
         end
       end
     end
 
-    # Tags are immutable in CloudFormation.  The cfn-update-stack command doesn't support --tag options, so remove
-    # the argument (if it exists) and validate against the existing stack to ensure tags haven't changed.
+    # Tags are immutable in CloudFormation.  Validate against the existing stack to ensure tags haven't changed.
     # Compare the sorted arrays for an exact match
-    old_cfn_tags = old_stack_attributes['TAGS'].split(';').sort rescue [] # Use empty Array if .split fails
-    if cfn_tags.sort != old_cfn_tags
+    old_cfn_tags = old_stack.tags.map { |p| [p.key.to_sym, p.value]}
+    cfn_tags_ary = cfn_tags.to_a
+    if cfn_tags_ary.sort != old_cfn_tags
       $stderr.puts "CloudFormation stack tags do not match and cannot be updated. You must either use the same tags or create a new stack." +
-                      "\n" + (old_cfn_tags - cfn_tags).map {|tag| "< #{tag}" }.join("\n") +
+                      "\n" + (old_cfn_tags - cfn_tags_ary).map {|tag| "< #{tag}" }.join("\n") +
                       "\n" + "---" +
-                      "\n" + (cfn_tags - old_cfn_tags).map {|tag| "> #{tag}"}.join("\n")
+                      "\n" + (cfn_tags_ary - old_cfn_tags).map {|tag| "> #{tag}"}.join("\n")
       exit(false)
     end
-    _, cmdline = extract_options(cmdline, %w(), %w(--tag))
-  end
-
-  # Execute command cmdline
-  puts %x( #{SYSTEM_ENV}; #{cmdline.map {|i| "\"#{i}\" "}.join} )
-  unless $?
-    $stderr.puts "\nExecution of 'cfn-cmd' failed.  To facilitate debugging, the generated JSON template " +
-                     "file was not deleted.  You may delete the file manually if it isn't needed: #{temp_file}"
-    exit(false)
-  end
-
-  File.delete(temp_file)
-
-  exit(true)
-end
 
-def extract_kv_string(hash, prefix='')
-  key = "#{prefix}Key"
-  value = "#{prefix}Value"
-  hash["member"].map {|a| "#{a[key]}=#{a[value]}" }.join(';') rescue ''
-end
-
-def exec_describe_stack cfn_options_string
-  xml_data = exec_capture_stdout("cfn-cmd cfn-describe-stacks #{cfn_options_string} --show-xml")
-  xml = XmlSimple.xml_in(xml_data, :ForceArray => false)["DescribeStacksResult"]["Stacks"]["member"]
-  { "TAGS" => extract_kv_string(xml["Tags"]), "PARAMETERS" => extract_kv_string(xml["Parameters"], "Parameter") }
-end
+    # update the stack
+    begin
+      update_result = cfn_client.update_stack({
+          stack_name: stack_name,
+          template_body: template_string,
+          parameters: template.parameters.map { |k,v| {parameter_key: k, parameter_value: v}}.to_a,
+          capabilities: ["CAPABILITY_IAM"],
+        })
+      if update_result.successful?
+        puts update_result.stack_id
+        exit(true)
+      end
+    rescue Aws::CloudFormation::Errors::ServiceError => e
+      $stderr.puts "Failed to update stack: #{e}"
+      exit(false)
+    end
 
-def exec_capture_stdout command
-  stdout = %x( #{SYSTEM_ENV}; #{command} )
-  unless $?.success?
-    $stderr.puts stdout unless stdout.empty?  # cfn-cmd sometimes writes error messages to stdout
-    exit(false)
   end
-  stdout
 end
 
+# extract options and arguments from a command line string
+#
+# Example:
+#
+# desired, unknown = extract_options("arg1 --option withvalue --optionwithoutvalue", %w(--option), %w())
+# 
+# puts desired => Array{"arg1", "--option", "withvalue"}
+# puts unknown => Array{}
+#
+# @param args
+#   the Array of arguments (split the command line string by whitespace)
+# @param opts_no_val
+#   the Array of options with no value, i.e., --force
+# @param opts_1_val
+#   the Array of options with exaclty one value, i.e., --retries 3
+# @returns
+#   an Array of two Arrays.
+#   The first array contains all the options that were extracted (both those with and without values) as a flattened enumerable.
+#   The second array contains all the options that were not extracted.
 def extract_options(args, opts_no_val, opts_1_val)
   args = args.clone
   opts = []
@@ -252,230 +312,16 @@ def extract_options(args, opts_no_val, opts_1_val)
   [opts, rest]
 end
 
-############################# Generic DSL
-
-class JsonObjectDSL
-  def initialize(&block)
-    @dict = {}
-    instance_eval &block
-  end
-
-  def value(values)
-    @dict.update(values)
-  end
-
-  def default(key, value)
-    @dict[key] ||= value
-  end
-
-  def to_json(*args)
-    @dict.to_json(*args)
-  end
-
-  def print()
-    puts JSON.pretty_generate(self)
-  end
-end
-
-############################# CloudFormation DSL
-
-# Main entry point
-def template(&block)
-  TemplateDSL.new(&block)
-end
-
+##################################### Additional dsl logic
 # Core interpreter for the DSL
 class TemplateDSL < JsonObjectDSL
-  attr_reader :parameters, :aws_region, :nopretty, :stack_name
-
-  def initialize()
-    @stack_name, @parameters, @aws_region, @nopretty = cfn_parse_args
-    super
-  end
-
   def exec!()
-    cfn_cmd(self)
-  end
-
-  def parameter(name, options)
-    default(:Parameters, {})[name] = options
-    @parameters[name] ||= options[:Default]
-  end
-
-  # Find parameters where the specified attribute is true then remove the attribute from the cfn template.
-  def excise_parameter_attribute!(attribute)
-    marked_parameters = []
-    @dict.fetch(:Parameters, {}).each do |param, options|
-      if options.delete(attribute.to_sym) or options.delete(attribute.to_s)
-        marked_parameters << param
-      end
-    end
-    marked_parameters
-  end
-
-  def mapping(name, options)
-    # if options is a string and a valid file then the script will process the external file.
-    default(:Mappings, {})[name] = \
-      if options.is_a?(Hash); options
-      elsif options.is_a?(String); load_from_file(options)['Mappings'][name]
-      else; raise("Options for mapping #{name} is neither a string or a hash.  Error!")
-    end
-  end
-
-  def load_from_file(filename)
-    file = File.open(filename)
-
-    begin
-      # Figure out what the file extension is and process accordingly.
-      contents = case File.extname(filename)
-        when ".rb"; eval(file.read, nil, filename)
-        when ".json"; JSON.load(file)
-        when ".yaml"; YAML::load(file)
-        else; raise("Do not recognize extension of #{filename}.")
-      end
-    ensure
-      file.close
-    end
-    contents
-  end
-
-  def excise_tags!
-    tags = []
-    @dict.fetch(:Tags, {}).each do | tag_name, tag_value |
-      tags << "#{tag_name}=#{tag_value}"
-    end
-    @dict.delete(:Tags)
-    tags
-  end
-
-  def tag(tag)
-    tag.each do | name, value |
-      default(:Tags, {})[name] = value
-    end
-  end
-
-  def condition(name, options) default(:Conditions, {})[name] = options end
-
-  def resource(name, options) default(:Resources, {})[name] = options end
-
-  def output(name, options) default(:Outputs, {})[name] = options end
-
-  def find_in_map(map, key, name)
-    # Eagerly evaluate mappings when all keys are known at template expansion time
-    if map.is_a?(String) && key.is_a?(String) && name.is_a?(String)
-      # We don't know whether the map was built with string keys or symbol keys.  Try both.
-      def get(map, key) map[key] || map.fetch(key.to_sym) end
-      get(get(@dict.fetch(:Mappings).fetch(map), key), name)
-    else
-      { :'Fn::FindInMap' => [ map, key, name ] }
-    end
-  end
-end
-
-def base64(value) { :'Fn::Base64' => value } end
-
-def find_in_map(map, key, name) { :'Fn::FindInMap' => [ map, key, name ] } end
-
-def get_att(resource, attribute) { :'Fn::GetAtt' => [ resource, attribute ] } end
-
-def get_azs(region = '') { :'Fn::GetAZs' => region } end
-
-def join(delim, *list)
-  case list.length
-    when 0 then ''
-    when 1 then list[0]
-    else join_list(delim,list)
-  end
-end
-
-# Variant of join that matches the native CFN syntax.
-def join_list(delim, list) { :'Fn::Join' => [ delim, list ] } end
-
-def equal(one, two) { :'Fn::Equals' => [one, two] } end
-
-def fn_not(condition) { :'Fn::Not' => [condition] } end
-
-def fn_or(*condition_list)
-  case condition_list.length
-    when 0..1 then raise "fn_or needs at least 2 items."
-    when 2..10 then  { :'Fn::Or' => condition_list }
-    else raise "fn_or needs a list of 2-10 items that evaluate to true/false."
-  end
-end
-
-def fn_and(*condition_list)
-  case condition_list.length
-    when 0..1 then raise "fn_and needs at least 2 items."
-    when 2..10 then  { :'Fn::And' => condition_list }
-    else raise "fn_and needs a list of 2-10 items that evaluate to true/false."
-  end
-end
-
-def fn_if(cond, if_true, if_false) { :'Fn::If' => [cond, if_true, if_false] } end
-
-def not_equal(one, two) fn_not(equal(one,two)) end
-
-def select(index, list) { :'Fn::Select' => [ index, list ] } end
-
-def ref(name) { :Ref => name } end
-
-def aws_account_id() ref("AWS::AccountId") end
-
-def aws_notification_arns() ref("AWS::NotificationARNs") end
-
-def aws_no_value() ref("AWS::NoValue") end
-
-def aws_stack_id() ref("AWS::StackId") end
-
-def aws_stack_name() ref("AWS::StackName") end
-
-# deprecated, for backward compatibility
-def no_value()
-    warn_deprecated('no_value()', 'aws_no_value()')
-    aws_no_value()
-end
-
-# Read the specified file and return its value as a string literal
-def file(filename) File.read(File.absolute_path(filename, File.dirname($PROGRAM_NAME))) end
-
-# Interpolates a string like "NAME={{ref('Service')}}" and returns a CloudFormation "Fn::Join"
-# operation to collect the results.  Anything between {{ and }} is interpreted as a Ruby expression
-# and eval'd.  This is especially useful with Ruby "here" documents.
-# Local variables may also be exposed to the string via the `locals` hash.
-def interpolate(string, locals={})
-  list = []
-  while string.length > 0
-    head, match, string = string.partition(/\{\{.*?\}\}/)
-    list << head if head.length > 0
-    list << eval(match[2..-3], nil, 'interpolated string') if match.length > 0
-  end
-
-  # Split out strings in an array by newline, for visibility
-  list = list.flat_map {|value| value.is_a?(String) ? value.lines.to_a : value }
-  join('', *list)
-end
-
-def join_interpolate(delim, string)
-  $stderr.puts "join_interpolate(delim,string) has been deprecated; use interpolate(string) instead"
-  interpolate(string)
-end
-
-# This class is used by erb templates so they can access the parameters passed
-class Namespace
-  attr_accessor :params
-  def initialize(hash)
-    @params = hash
-  end
-  def get_binding
-    binding
+    cfn(self)
   end
 end
 
-# Combines the provided ERB template with optional parameters
-def erb_template(filename, params = {})
-  ERB.new(file(filename), nil, '-').result(Namespace.new(params).get_binding)
-end
-
-def warn_deprecated(old, new)
-    $stderr.puts "Warning: '#{old}' has been deprecated.  Please update your template to use '#{new}' instead."
+# Main entry point
+def template(&block)
+  stack_name, parameters, aws_region, nopretty = parse_args
+  raw_template(parameters, stack_name, aws_region, nopretty, &block)
 end