lono 0.3.3 → 0.3.4

data/lib/lono/template.rb

@@ -96,26 +96,45 @@ module Lono
     # Output:
     #   Array of parse positions
     #
-    # The positions indicate when the brackets start and close.  
-    # Handles nested brackets.
+    # The positions of tokens taking into account when brackets start and close, 
+    # handles nested brackets.
     def bracket_positions(line)
       positions,pair,count = [],[],0
+
       line.split('').each_with_index do |char,i|
-        if char == '{'
-          count += 1
-          pair << i if count == 1
-          next
-        end
+        pair << i if pair.empty?
+
+        first_pair_char = line[pair[0]]  
+        if first_pair_char == '{' # object logic
+          if char == '{'
+            count += 1
+          end
 
-        if char == '}'
-          count -= 1
-          if count == 0
+          if char == '}'
+            count -= 1
+            if count == 0
+              pair << i
+              positions << pair
+              pair = []
+            end
+          end
+        else # string logic
+          lookahead = line[i+1]
+          if lookahead == '{'
             pair << i
             positions << pair
             pair = []
           end
         end
+      end # end of loop
+
+      # for string logic when lookahead does not contain a object token
+      # need to clear out what's left to match the final pair
+      if !pair.empty?
+        pair << line.size - 1
+        positions << pair
       end
+
       positions
     end
 
@@ -125,8 +144,7 @@ module Lono
     #   Array - positions that can be use to determine what to parse
     def parse_positions(line)
       positions = bracket_positions(line)
-      # add 1 to the element in the position pair to make parsing easier in decompose
-      positions.map {|pair| [pair[0],pair[1]+1]}.flatten
+      positions.flatten
     end
 
     # Input
@@ -143,29 +161,46 @@ module Lono
 
       result = []
       str = ''
-      last_index = line.size - 1
-      parse_position = positions.shift
-
-      line.split('').each_with_index do |char,current_i|
-        # the current item's creation will end when
-        #   the next item's index is reached
-        #   or the end of the line is reached
-        str << char
-        next_i = current_i + 1
-        end_of_item = next_i == parse_position
-        end_of_line = current_i == last_index
-        if end_of_item or end_of_line
-          parse_position = positions.shift
-          result << str
-          str = ''
+      until positions.empty?
+        left = positions.shift
+        right = positions.shift
+        token = line[left..right]
+        # if cfn object, add to the result set but after clearing out
+        # the temp str that is being built up when the token is just a string
+        if cfn_object?(token)
+          unless str.empty? # first token might be a object
+            result << str
+            str = ''
+          end
+          result << token
+        else
+          str << token # keeps building up the string
         end
       end
 
+      # at the of the loop there's a leftover string, unless the last token
+      # is an object
+      result << str unless str.empty?
+
       result
     end
 
+    def cfn_object?(s)
+      whitelist = %w[
+        Ref
+        Fn::FindInMap
+        Fn::Base64
+        Fn::GetAtt
+        Fn::GetAZs
+        Fn::Join
+        Fn::Select
+      ]
+      whitelisted = !!whitelist.detect {|word| s.include?(word)}
+      whitelisted && s =~ /^{/ && s =~ /=>/
+    end
+
     def recompose(decomposition)
-      decomposition.map { |s| (s =~ /^{/ && s =~ /=>/) ? eval(s) : s }
+      decomposition.map { |s| cfn_object?(s) ? eval(s) : s }
     end
 
     def evaluate(line)

data/lib/lono/version.rb

@@ -1,3 +1,3 @@
 module Lono
-  VERSION = "0.3.3"
+  VERSION = "0.3.4"
 end

data/lib/starter_project/config/lono/api.rb

@@ -20,6 +20,29 @@ template "prod-api-app.json" do
   )
 end
 
+template "prod-api-worker.json" do
+  env,app,role = name.sub('.json','').split('-')
+  source "app.json.erb"
+  variables(
+    :env => env,
+    :app => app,
+    :role => role,
+    :ami => "ami-123",
+    :instance_type => "m1.small",
+    :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",
+    :user_data_script => "ruby_script.rb.erb",
+    :ssl_cert => "arn:aws:iam::12345:server-certificate/wildcard"
+  )
+end
+
 template "prod-api-redis.json" do
   env,app,role = name.sub('.json','').split('-')
   source "db.json.erb"

data/lib/starter_project/templates/app.json.erb

@@ -233,7 +233,8 @@
           "Fn::Base64": {
             "Fn::Join": [
               "",
-              <%= user_data('app.sh.erb') %>
+              <% script = @user_data_script || 'app.sh.erb' %>
+              <%= user_data(script) %>
             ]
           }
         }

data/lib/starter_project/templates/user_data/ruby_script.rb.erb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+ec2.tags.create(ec2.instances[my_instance_id], "Name", {:value => Facter.hostname})
+
+find_all{ |record_set| record_set[:name] == record_name }

data/spec/lib/lono_spec.rb

@@ -25,38 +25,54 @@ describe Lono do
       template = Lono::Template.new("foo", block)
 
       line = '0{2345}7'
-      template.bracket_positions(line).should == [[1,6]]
+      template.bracket_positions(line).should == [[0,0],[1,6],[7,7]]
       line = '0{2}4{6}' # more than one bracket
-      template.bracket_positions(line).should == [[1,3],[5,7]]
+      template.bracket_positions(line).should == [[0,0],[1,3],[4,4],[5,7]]
       line = '0{2}4{6{8}0}2' # nested brackets
-      template.bracket_positions(line).should == [[1,3],[5,11]]
-
-      line = '0{2=>5}7'
-      template.parse_positions(line).should == [1,7]
-      line = '0{2=>5}4{6=>{8=>9}}2' # nested brackets
-      template.parse_positions(line).should == [1, 7, 8, 19]
-      line = '0{2=>5}4{' # nested brackets
-      template.parse_positions(line).should == [1, 7]
+      template.bracket_positions(line).should == [[0,0],[1,3],[4,4],[5,11],[12,12]]
 
       line = '{'
       template.decompose(line).should == ['{']
 
-      line = 'a{"foo"=>"bar"}h'
-      template.decompose(line).should == ['a','{"foo"=>"bar"}','h']
-      line = 'a{"foo"=>"bar"}c{"dog"=>{"cat"=>"mouse"}}e' # nested brackets
-      template.decompose(line).should == ['a','{"foo"=>"bar"}','c','{"dog"=>{"cat"=>"mouse"}}','e']
+      ##########################
+      line = '1{"Ref"=>"A"}{"Ref"=>"B"}'
+      template.decompose(line).should == ['1','{"Ref"=>"A"}','{"Ref"=>"B"}']
+
+      line = '{"Ref"=>"A"}{"Ref"=>"B"}2'
+      template.decompose(line).should == ['{"Ref"=>"A"}','{"Ref"=>"B"}','2']
+
+      line = '1{"Ref"=>"A"}{"Ref"=>"B"}2'
+      template.decompose(line).should == ['1','{"Ref"=>"A"}','{"Ref"=>"B"}','2']
+
+      line = '{"Ref"=>"A"}{"Ref"=>"B"}'
+      template.decompose(line).should == ['{"Ref"=>"A"}','{"Ref"=>"B"}']
+
+      line = 'Ref{"Ref"=>"B"}'
+      template.decompose(line).should == ['Ref','{"Ref"=>"B"}']
+      ##############################
 
-      line = 'test{"hello"=>"world"}me' # nested brackets
+      # only allow whitelist
+      line = 'a{b}{"foo"=>"bar"}h'
+      template.decompose(line).should == ['a{b}{"foo"=>"bar"}h']
+
+      line = 'a{b}{"Ref"=>"bar"}h'
+      template.decompose(line).should == ['a{b}','{"Ref"=>"bar"}','h']
+      line = 'a{"Ref"=>"bar"}c{"Ref"=>{"cat"=>"mouse"}}e' # nested brackets
+      template.decompose(line).should == ['a','{"Ref"=>"bar"}','c','{"Ref"=>{"cat"=>"mouse"}}','e']
+
+      line = 'test{"Ref"=>"world"}me' # nested brackets
       decomposition = template.decompose(line)
       result = template.recompose(decomposition)
-      result.should == ["test", {"hello" => "world"}, "me"]
+      result.should == ["test", {"Ref" => "world"}, "me"]
 
-      line = 'test{"hello"=>"world"}me'
-      template.transform(line).should == ["test", {"hello" => "world"}, "me\n"]
-      line = '{"hello"=>"world"}'
-      template.transform(line).should == [{"hello" => "world"}, "\n"]
+      line = 'test{"Ref"=>"world"}me'
+      template.transform(line).should == ["test", {"Ref" => "world"}, "me\n"]
+      line = '{"Ref"=>"world"}'
+      template.transform(line).should == [{"Ref" => "world"}, "\n"]
       line = '{'
       template.transform(line).should == ["{\n"]
+      line = 'Ref{"Ref"=>"B"}'
+      template.transform(line).should == ['Ref',{"Ref"=>"B"}, "\n"]
     end
   end
 
@@ -133,6 +149,14 @@ describe Lono do
       data.should == ["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}/output/prod-api-worker.json")
+      json = JSON.load(raw)
+      user_data = json['Resources']['LaunchConfig']['Properties']['UserData']['Fn::Base64']['Fn::Join'][1]
+      user_data.should include(%Q|ec2.tags.create(ec2.instances[my_instance_id], "Name", {:value => Facter.hostname})\n|)
+      user_data.should include(%Q{find_all{ |record_set| record_set[:name] == record_name }\n})
+    end
+
     it "task should generate cloud formation templates" do
       Lono::Task.generate(
         :project_root => @project,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lono
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-18 00:00:00.000000000 Z
+date: 2013-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -223,6 +223,7 @@ files:
 - lib/starter_project/templates/user_data/app.sh.erb
 - lib/starter_project/templates/user_data/db.sh.erb
 - lib/starter_project/templates/user_data/db2.sh.erb
+- lib/starter_project/templates/user_data/ruby_script.rb.erb
 - lono.gemspec
 - spec/fixtures/cfn.json
 - spec/lib/lono_spec.rb