autostacker24 1.0.71 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e911951935b531613df5334a7fe6257cc06e3ec8
-  data.tar.gz: 40ce45a938a1152c61a6831abc8617f9b0e3081a
+  metadata.gz: c854bfc3f7bc00704f86c14a3d2fc742da028083
+  data.tar.gz: 1c1f01cb79ef33a2b822ce28b2a51a52fea8667b
 SHA512:
-  metadata.gz: 5f852171e3d662cc0e8c986911a618fa0ecfba3b4701fee9ac74586860f8cfeb0401af54003ea9b5347f33c450bc982047f7a77a16e392baf50cd22c80f2aa6d
-  data.tar.gz: 58e75d34a406723ecc471b2c7d66b7de1d336d8d0a92a7bf63dc26cabec2ba56d72df1c1192c05d7a38dae9563b144d9101833658455ece87fe1a75b21eadadb
+  metadata.gz: be4caf16f2fe3a6f84bb94669aea7170fe1c9962751e22a0386ee7873db989f1f8be6c9d6dadf5a111ce57f1093f70ee13f532f9c9437c0317dae6c2f3420cb3
+  data.tar.gz: 78036ff04e15108b194214087c77210da73cb1b5f9ea33b5c7354ded08cd3f98711cf55d5ae2ce666cdeff82c0fafd6be1d6d2eefac34b947a531c72f21e53fb

data/bin/autostacker24

@@ -24,22 +24,22 @@ parser = OptionParser.new do |opts|
   opts.banner = 'Usage: autostacker24 command [options]'
   opts.separator ''
   opts.separator 'Commands:'
-  opts.separator "\tcreate\t\t create or update a stack"
+  opts.separator "\tupdate\t\t create or update a stack"
   opts.separator "\tdelete\t\t delete a stack"
-  opts.separator "\tshow\t\t pretty print template after preprocessing"
+  opts.separator "\tprocess\t\t pretty print processed template"
   opts.separator "\tvalidate\t validate the template"
-  opts.separator "\tconvert\t\t convert a template to yaml"
+  opts.separator "\tconvert\t\t convert template to and from YAML"
   opts.separator ''
   opts.separator 'Options:'
   opts.on('--template TEMPLATE', 'Path to template')                {|v| args.template = v}
   opts.on('--stack STACK',       'Name of stack')                   {|v| args.stack = v}
   opts.on('--parent PARENT',     'Name of parent stack')            {|v| args.parent = v}
-  opts.on('--to-json',           'Convert yaml template to json')   {|_| args.json = true}
   opts.on('--region REGION',     'AWS region')                      {|v| args.region = v}
   opts.on('--profile PROFILE',   'AWS profile (use aws configure)') {|v| args.profile = v}
   opts.on('--param KEY=VALUE',   'Stack Parameter')                 {|v| args.params.store(*v.split('=')) }
   opts.on('--help',              'Show this help')                  {|_| puts opts; exit!;}
   opts.on('--version',           'Show version')                    {|_| puts `gem list autostacker24`; exit!;}
+  opts.separator ''
 end
 USAGE = parser.to_s
 
@@ -67,17 +67,17 @@ case args.command
   when /delete/
     check_stack(args)
     Stacker.delete_stack(args.stack)
-  when /preprocess|show/
+  when /process|show/
     check_template(args)
     puts JSON.pretty_generate(JSON.parse(Stacker.template_body(args.template)))
   when /convert/
     check_template(args)
     template = File.read(args.template)
-    if args.json
-      puts '// autostacker24 CloudFormation JSON template'
-      puts JSON.pretty_generate(YAML.load(template))
+    if template =~ /\A(\s*\{)|(\s*\/{2})/
+      puts JSON.parse(template).to_yaml.sub('---', '# AutoStacker24 CloudFormation YAML Template')
     else
-      puts JSON.parse(template).to_yaml.sub('---', '# autostacker24 CloudFormation YAML template')
+      puts '// AutoStacker24 CloudFormation JSON Template '
+      puts JSON.pretty_generate(YAML.load(template))
     end
   else
     error("unknown command '#{args.command}'")

data/lib/autostacker24/template_preprocessor.rb

@@ -1,122 +1,193 @@
-
-require 'json'
-require 'set'
-require 'yaml'
-
-module AutoStacker24
-
-  module Preprocessor
-
-    def self.preprocess(template)
-      if template =~ /\A\s*\{/
-        template
-      elsif template =~ /\A\s*\/{2}/
-        preprocess_json(parse_json(template)).to_json
-      else
-        preprocess_json(parse_yaml(template)).to_json
-      end
-    end
-
-    def self.parse_json(template)
-      JSON(template)
-    rescue JSON::ParserError => e
-      require 'json/pure' # pure ruby parser has better error diagnostics
-      JSON(template)
-      raise e
-    end
-
-    def self.parse_yaml(template)
-      YAML.load(template)
-    end
-
-    def self.preprocess_json(json)
-      if json.is_a?(Hash)
-        json.inject({}) do |m, (k, v)|
-          if k == 'UserData' && v.is_a?(String)
-            m.merge(k => preprocess_user_data(v))
-          else
-            m.merge(k => preprocess_json(v))
-          end
-        end
-      elsif json.is_a?(Array)
-        json.map{|v| preprocess_json(v)}
-      elsif json.is_a?(String)
-        preprocess_string(json)
-      else
-        json
-      end
-    end
-
-    def self.preprocess_user_data(s)
-      {'Fn::Base64' => preprocess_string(s)}
-    end
-
-    def self.preprocess_string(s)
-      m = /^@file:\/\/(.*)$/.match(s)
-      s = File.read(m[1]) if m
-      parts = tokenize(s).map do |token|
-        case token
-          when '@@' then '@'
-          when '@[' then '['
-          when /\A@/ then parse_ref(token)
-          else token
-        end
-      end
-
-      # merge neighboured strings
-      parts = parts.reduce([])do |m, p|
-        if m.last.is_a?(String) && p.is_a?(String)
-          m[-1] += p
-        else
-          m << p
-        end
-        m
-      end
-
-      if parts.length == 1
-        parts.first
-      else # we need a join construct
-        {'Fn::Join' => ['', parts]}
-      end
-    end
-
-    def self.parse_ref(token)
-      m = /\A@([^\[]*)(\[([^,]*)(\s*,\s*(.*))?\])?$/.match(token)
-      m1 = m[1]
-      m2 = m[3]
-      m3 = m[5]
-      if m2
-        args = if m3
-                  [m1, m2, m3]
-               else
-                 [m1 + 'Map', '@' + m1, m2]
-               end
-        {'Fn::FindInMap' => [args[0], preprocess_string(args[1]), preprocess_string(args[2])]}
-      else
-        {'Ref' => m1}
-      end
-    end
-
-    def self.tokenize(s)
-      # for recursive bracket matching see
-      # http://stackoverflow.com/questions/19486686/recursive-nested-matching-pairs-of-curly-braces-in-ruby-regex
-      # but for we limit ourself to one level to make things less complex
-      pattern = /@@|@\[|@(\w+(::\w+)?)(\[[^\]]*\])?/
-      tokens = []
-      loop do
-        m = pattern.match(s)
-        if m
-          tokens << m.pre_match unless m.pre_match.empty?
-          tokens << m.to_s
-          s = m.post_match
-        else
-          tokens << s unless s.empty? && !tokens.empty?
-          break
-        end
-      end
-      tokens
-    end
-
-  end
-
-end
+
+require 'json'
+require 'set'
+require 'yaml'
+
+module AutoStacker24
+
+  module Preprocessor
+
+    def self.preprocess(template)
+      if template =~ /\A\s*\{/
+        template
+      elsif template =~ /\A\s*\/{2}/
+        preprocess_json(parse_json(template)).to_json
+      else
+        preprocess_json(parse_yaml(template)).to_json
+      end
+    end
+
+    def self.parse_json(template)
+      JSON(template)
+    rescue JSON::ParserError => e
+      require 'json/pure' # pure ruby parser has better error diagnostics
+      JSON(template)
+      raise e
+    end
+
+    def self.parse_yaml(template)
+      YAML.load(template)
+    end
+
+    def self.preprocess_json(json)
+      if json.is_a?(Hash)
+        json.inject({}) do |m, (k, v)|
+          if k == 'UserData' && v.is_a?(String)
+            m.merge(k => preprocess_user_data(v))
+          else
+            m.merge(k => preprocess_json(v))
+          end
+        end
+      elsif json.is_a?(Array)
+        json.map{|v| preprocess_json(v)}
+      elsif json.is_a?(String)
+        interpolate(json)
+      else
+        json
+      end
+    end
+
+    def self.preprocess_user_data(s)
+      {'Fn::Base64' => interpolate(s)}
+    end
+
+    # interpolates a string with '@' expressions and returns a string or a hash
+    # it implements the following non context free grammar in pseudo antlr3
+    #
+    # string : RAW? (expr RAW?)*;
+    # expr   : '@' '{'? name (attr+ | map)? '}'?;
+    # name   : ID ('::' ID)?;
+    # attr   : ('.' ID)+;
+    # map    : '[' key (',' key)? ']';
+    # key    : ID | expr;
+    # ID     : [a-zA-Z0-9]+;
+    # RAW    : (~['@']* | FILE)=;
+    # FILE   : '@file://' [^@\s]+ ('@' | ' ');
+    # FILE_C : '@{file://' [^}] '}';
+    #
+    def self.interpolate(s)
+      parts = []
+      while s.length > 0
+        raw, s = parse_raw(s)
+        parts << raw unless raw.empty?
+        expr, s = parse_expr(s)
+        parts << expr if expr
+      end
+      case parts.length
+        when 0 then ''
+        when 1 then parts[0]
+        else {'Fn::Join' => ['', parts]}
+      end
+    end
+
+    def self.parse_raw(s)
+      i = -1
+      loop do
+        i = s.index('@', i + 1)
+        return s, '' if i.nil?
+
+        file_match = /\A@file:\/\/([^@\s]+)@?/.match(s[i..-1])
+        file_curly_match = /\A@\{file:\/\/([^\}]+)\}/.match(s[i..-1])
+        if file_match # inline file
+          s = s[0, i] + File.read(file_match[1]) + file_match.post_match
+          i -= 1
+        elsif file_curly_match # inline file with curly braces
+          s = s[0, i] + File.read(file_curly_match[1]) + file_curly_match.post_match
+          i -= 1
+        elsif s[i, 2] =~ /\A@@/ # escape
+          s = s[0, i] + s[i+1..-1]
+        elsif s[i, 2] =~ /\A@(\w|\{)/
+          return s[0, i], s[i..-1] # return raw, '@...'
+        end
+      end
+    end
+
+    #
+    # Parse given string as AutoStacker24 expression, and produce CloudFormation
+    # function from it (Fn::GetAtt, Fn::FindInMap, Ref).
+    #
+    # == Parameters:
+    # s::
+    #  the string to parse
+    # embedded::
+    #  whether the string is embedded in an AutoStacker24 expression already.
+    #  Embedded expressions may not start with '@{', only with '@'.
+    #
+    def self.parse_expr(s, embedded = false)
+      return nil, s if s.length == 0
+
+      at, s = parse(AT, s)
+      raise "expected '@' but got #{s}" unless at
+      curly, s = parse(LEFT_CURLY, s) unless embedded
+      name, s = parse(NAME, s)
+      raise "expected parameter name #{s}" unless name
+
+      if curly
+        # try attribute, then map, then fallback to simple ref.
+        expr, s = parse_attribute(s, name)
+        expr, s = parse_map(s, name)       unless expr
+        expr, s = parse_reference(s, name) unless expr
+
+        closing_curly, s = parse(RIGHT_CURLY, s)
+        raise "expected '}' but got #{s}" unless closing_curly
+      else
+        # try attribute, then map, then fallback to simple ref.
+        # these are allowed in both embedded and top-level expressions
+        # starting with @...
+        expr, s = parse_attribute(s, name)
+        expr, s = parse_map(s, name)       unless expr
+        expr, s = parse_reference(s, name) unless expr
+      end
+
+      return expr, s
+    end
+
+    def self.parse_reference(s, name)
+      return {'Ref' => name}, s
+    end
+
+    def self.parse_attribute(s, name)
+      attr, s = parse(ATTRIB, s)
+      if attr
+        return {'Fn::GetAtt' => [name, attr[1..-1]]}, s
+      else
+        return nil, s
+      end
+    end
+
+    def self.parse_map(s, name)
+      bracket, s = parse(LEFT_BRACKET, s)
+      return nil, s unless bracket
+      top, s = parse(KEY, s)
+      top, s = parse_expr(s, nested=true) unless top
+      comma, s = parse(COMMA, s)
+      second, s = parse(KEY, s) if comma
+      second, s = parse_expr(s, embedded=true) if comma and second.nil?
+      bracket, s = parse(RIGHT_BRACKET, s)
+      raise "Expected closing ']' #{s}" unless bracket
+      map = [top, second]
+      if second # two arguments found
+        return {'Fn::FindInMap' => [name, top, second]}, s
+      else
+        return {'Fn::FindInMap' => [name + 'Map', {'Ref' => name}, top]}, s
+      end
+    end
+
+    def self.parse(re, s)
+      m = re.match(s)
+      return m.to_s, m.post_match if m
+      return nil, s
+    end
+
+    # Tokens
+    AT = /\A@/
+    NAME = /\A\w+(::\w+)?/
+    LEFT_BRACKET = /\A\[\s*/
+    RIGHT_BRACKET = /\A\s*\]/
+    LEFT_CURLY = /\A\{/
+    RIGHT_CURLY = /\A\}/
+    COMMA = /\A\s*,\s*/
+    KEY = /\A(\w+)/
+    ATTRIB = /\A(\.\w+)+/
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: autostacker24
 version: !ruby/object:Gem::Version
-  version: 1.0.71
+  version: 2.0.0
 platform: ruby
 authors:
 - Johannes Mueller
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-29 00:00:00.000000000 Z
+date: 2016-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-core
@@ -95,7 +95,13 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.4'
-description: n/a
+description: AutoStacker24 is a small ruby gem for managing AWS CloudFormation stacks.
+  It is a thin wrapper around the AWS Ruby SDK. It lets you write simple and convenient
+  automation scripts, especially if you have lots of parameters or dependencies between
+  stacks. You can use it directly from Ruby code or from the command line. It enhances
+  CloudFormation templates by parameter expansion in strings and it is even possible
+  to write templates in YAML which is much friendlier to humans than JSON. You can
+  use autostacker24 cli to convert existing templates to YAML.
 email:
 - jmueller@autoscout24.com
 - crodemeyer@autoscout24.com