cfndsl 0.0.2 → 0.0.4

data/lib/cfndsl.rb

@@ -2,7 +2,21 @@ require 'json';
 
 class Module
   private
-  def attr_setter(*symbols)
+  def dsl_attr_setter(*symbols)
+    ##
+    # Create setter methods
+    #
+    # Usage:
+    #    class Something
+    #      dsl_attr_setter :Thing
+    #    end
+    #
+    # Generates a setter method like this one for each symbol in *symbols:
+    #
+    # def Thing(value)
+    #   @Thing = value
+    # end
+    #
     symbols.each do |symbol|
       class_eval do 
         define_method(symbol) do |value|
@@ -12,16 +26,43 @@ class Module
     end
   end
   
+  ##
+  # Plural names for lists of content objects
+  #
+  
   @@plurals = { 
     :Metadata => :Metadata, 
     :Property => :Properties 
   }
   
-  def content_object(*symbols)
+  def dsl_content_object(*symbols)
+    ##
+    # Create object declaration methods.
+    #
+    # Usage:
+    #   Class Something
+    #     dsl_content_object :Stuff
+    #   end
+    #
+    # Generates methods like this:
+    #
+    # def Stuff(name, *values, &block) 
+    #   @Stuffs ||= {}
+    #   @Stuffs[name] ||= CfnDsl::#{symbol}Definition.new(*values)
+    #   @Stuffs[name].instance_eval &block if block_given?
+    #   return @Stuffs[name]
+    # end
+    #
+    # The effect of this is that you can then create named sub-objects
+    # from the main object. The sub objects get stuffed into a container
+    # on the main object, and the block is then evaluated in the context
+    # of the new object.
+    #
     symbols.each do |symbol|
       plural = @@plurals[symbol] || "#{symbol}s"
       class_eval %Q/
         def #{symbol} (name,*values,&block)
+          name = name.to_s
           @#{plural} ||= {}
           @#{plural}[name] ||= CfnDsl::#{symbol}Definition.new(*values)
           @#{plural}[name].instance_eval &block if block_given? 
@@ -33,17 +74,31 @@ end
 
 
 module RefCheck
+  ##
+  # This module defines some methods for walking the reference tree
+  # of various objects.
+  #
   def references(refs)
-    raise "Circular reference" if @visited
-
-    @visited = true
+    ##
+    # Build up a set of references.
+    #
+    raise "Circular reference" if @_visited
 
-    self.get_references(refs) if self.respond_to?(:get_references)
+    @_visited = true
+    
+    if( self.respond_to?(:get_references ) ) then
+      self.get_references.each do |ref|
+        refs[ref.to_s] = 1
+      end
+    end
 
     self.ref_children.each do |elem|
       elem.references(refs) if elem.respond_to?(:references)
     end
-    @visited = nil
+
+    @_visited = nil
+
+    return refs
   end
 
   def ref_children
@@ -70,41 +125,100 @@ module CfnDsl
   module Functions  
 
     def Ref(value) 
+      ##
+      # Equivalent to the CloudFormation template built in function Ref
       RefDefinition.new(value)
     end
         
     def FnBase64( value )
+      ##
+      # Equivalent to the CloudFormation template built in function Fn::Base64
       Fn.new("Base64", value);
     end
     
     def FnFindInMap( map, key, value)
+      ##
+      # Equivalent to the CloudFormation template built in function Fn::FindInMap
       Fn.new("FindInMap", [map,key,value] )
     end	
     
     def FnGetAtt(logicalResource, attribute)
-      Fn.new( "GetAtt", [logicalResource, attribute] )
+      ##
+      # Equivalent to the CloudFormation template built in function Fn::GetAtt
+      Fn.new( "GetAtt", [logicalResource, attribute], [logicalResource] )
     end
     
     def FnGetAZs(region)
+      ##
+      # Equivalent to the CloudFormation template built in function Fn::GetAZs
       Fn.new("GetAZs", region)
     end
     
     def FnJoin(string, array)
+      ##
+      # Equivalent to the CloudFormation template built in function Fn::Join
       Fn.new("Join", [ string, array] )
     end
+
+    def FnFormat(string, *arguments)
+      ##
+      # Usage
+      #  FnFormat( "This is a %0. It is 100%% %1","test", "effective")
+      # 
+      # This will generate a call to Fn::Join that when evaluated will produce
+      # the string "This is a test. It is 100% effective."
+      #
+      # Think of this as %0,%1, etc in the format string being replaced by the 
+      # corresponding arguments given after the format string. '%%' is replaced
+      # by the '%' character. 
+      # 
+      # The actual Fn::Join call corresponding to the above FnFormat call would be
+      # {"Fn::Join": ["",["This is a ","test",". It is 100","%"," ","effective"]]}
+      array = [];
+      string.scan( /(.*?)(%(%|\d+)|\Z)/m ) do |x,y|
+        array.push $1 if $1 && $1 != ""
+        if( $3 == '%' ) then
+          array.push '%'
+        elsif( $3 ) then
+          array.push arguments[ $3.to_i ]
+        end
+      end  
+
+      Fn.new("Join", ["", array])
+    end
   end
   
   
   class JSONable
+    ##
+    # This is the base class for just about everything useful in the 
+    # DSL. It knows how to turn DSL Objects into the corresponding
+    # json, and it lets you create new built in function objects
+    # from inside the context of a dsl object.
+
     include Functions
     extend Functions
     include RefCheck
 
     def to_json(*a)
+      ##
+      # Use instance variables to build a json object. Instance
+      # variables that begin with a single underscore are elided.
+      # Instance variables that begin with two underscores have one of
+      # them removed.
       hash = {}
       self.instance_variables.each do |var|
         name = var[1..-1]
-        hash[name] = self.instance_variable_get var
+        
+        if( name =~ /^__/ ) then
+          # if a variable starts with double underscore, strip one off
+          name = name[1..-1]
+        elsif( name =~ /^_/ ) then
+          # Hide variables that start with single underscore
+          name = nil
+        end
+          
+        hash[name] = self.instance_variable_get var if name
       end
       hash.to_json(*a)
     end
@@ -120,9 +234,12 @@ module CfnDsl
   end
   
   class Fn < JSONable
-    def initialize( function, argument )
+    ##
+    # Handles all of the Fn:: objects
+    def initialize( function, argument, refs=[] )
       @function = function
       @argument = argument
+      @_refs = refs
     end
     
     def to_json(*a)
@@ -131,30 +248,38 @@ module CfnDsl
       hash.to_json(*a)
     end
 
-    def get_references( refs )
-      refs[ @argument[0] ] = 1 if @function=="GetAtt"
+    def get_references()
+      return @_refs
     end
 
     def ref_children
       return [@argument]
     end
-
-
   end
 
 
   class RefDefinition < JSONable
+    ##
+    # Handles the Ref objects
     def initialize( value ) 
       @Ref = value
     end
 
-    def get_references( refs )
-      refs[ @Ref ] = 1
+    def get_references()
+      [@Ref]
     end
   end
   
   
   class PropertyDefinition < JSONable
+    ##
+    # Handles property objects for Resources
+    #
+    # Usage
+    #   Resource("aaa") {
+    #     Property("propName", "propValue" )
+    #   }
+    #
     def initialize(value) 
       @value = value;
     end
@@ -165,6 +290,18 @@ module CfnDsl
   end
   
   class MappingDefinition < JSONable
+    ##
+    # Handles mapping objects
+    #
+    # Usage:
+    #     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" }
+    #    })
+    
     def initialize(value)
       @value = value
     end
@@ -175,30 +312,39 @@ module CfnDsl
   end
   
   class ResourceDefinition < JSONable
-    attr_setter :Type, :DependsOn, :DeletionPolicy
-    content_object :Property, :Metadata
+    ##
+    # Handles Resource objects
+    dsl_attr_setter :Type, :DependsOn, :DeletionPolicy
+    dsl_content_object :Property, :Metadata
 
-    def get_references( refs )
+    def get_references()
+      refs = []
       if @DependsOn then
         if( @DependsOn.respond_to?(:each) ) then
           @DependsOn.each do |dep|
-            refs[ dep ] = 1
+            refs.push dep
           end
         end
 
         if( @DependsOn.instance_of?(String) ) then
-          refs[ @DependsOn ] = 1
+          refs.push @DependsOn 
         end
       end
+
+      refs
     end
   end
   
   class MetadataDefinition < JSONable
+    ## 
+    # Handles Metadata objects
   end
   
   
   class ParameterDefinition < JSONable
-    attr_setter :Type, :Default, :NoEcho, :AllowedValues, :AllowedPattern, :MaxLength, :MinLength, :MaxValue, :MinValue, :Description, :ConstraintDescription
+    ##
+    # Handles input parameter objects
+    dsl_attr_setter :Type, :Default, :NoEcho, :AllowedValues, :AllowedPattern, :MaxLength, :MinLength, :MaxValue, :MinValue, :Description, :ConstraintDescription
     def initialize
       @Type = :String
     end
@@ -223,7 +369,9 @@ module CfnDsl
   end
   
   class OutputDefinition < JSONable
-    attr_setter :Value, :Description
+    ##
+    # Handles Output objects
+    dsl_attr_setter :Value, :Description
     
     def initialize( value=nil)
       @Value = value if value
@@ -231,8 +379,10 @@ module CfnDsl
   end
   
   class CloudFormationTemplate < JSONable 
-    attr_setter :AWSTemplateFormatVersion, :Description
-    content_object :Parameter, :Output, :Resource, :Mapping
+    ##
+    # Handles the overall template object
+    dsl_attr_setter :AWSTemplateFormatVersion, :Description
+    dsl_content_object :Parameter, :Output, :Resource, :Mapping
     
     def initialize
       @AWSTemplateFormatVersion = "2010-09-09"
@@ -241,21 +391,64 @@ module CfnDsl
     def generateOutput() 
       puts self.to_json  # uncomment for pretty printing # {:space => ' ', :indent => '  ', :object_nl => "\n", :array_nl => "\n" }
     end
-    
-    def dsl(&block) 
-      self.instance_eval &block
+
+    @@globalRefs = { "AWS::Region" => 1 }
+
+    def isValidRef( ref, origin=nil)
+      ref = ref.to_s
+      origin = origin.to_s if origin
+
+      return true if @@globalRefs.has_key?( ref )
+
+      return true if @Parameters && @Parameters.has_key?( ref )
+      
+      if( @Resources.has_key?( ref ) ) then
+          return !origin || !@_ResourceRefs || !@_ResourceRefs[ref] || !@_ResourceRefs[ref].has_key?(origin)             
+      end
+
+      return false
+    end
+
+    def checkRefs() 
+      invalids = []
+      @_ResourceRefs = {}
+      if(@Resources)  then
+        @Resources.keys.each do |resource|
+          @_ResourceRefs[resource.to_s] = @Resources[resource].references({})
+        end
+        @_ResourceRefs.keys.each do |origin|
+          @_ResourceRefs[origin].keys.each do |ref|
+            invalids.push "Invalid Reference: Resource #{origin} refers to #{ref}" unless isValidRef(ref,origin)
+          end
+        end
+      end
+      outputRefs = {}
+      if(@Outputs) then
+        @Outputs.keys.each do |resource|
+          outputRefs[resource.to_s] = @Outputs[resource].references({})
+        end
+        outputRefs.keys.each do |origin|
+          outputRefs[origin].keys.each do |ref|
+            invalids.push "Invalid Reference: Output #{origin} refers to #{ref}" unless isValidRef(ref,nil)
+          end
+        end
+      end
+      return invalids.length>0 ? invalids : nil 
     end
 
   end
-  
-  
 end
 
 def CloudFormation(&block)
   x = CfnDsl::CloudFormationTemplate.new
-  x.dsl(&block)
-  x.generateOutput
-
+  x.declare(&block)
+  invalid_references = x.checkRefs()
+  if( invalid_references ) then
+    puts invalid_references.join("\n");
+    exit(-1)
+  else
+    x.generateOutput
+  end
 end
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cfndsl
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-15 00:00:00.000000000 Z
+date: 2012-12-16 00:00:00.000000000 Z
 dependencies: []
 description: DSL for creating AWS Cloudformation templates
 email: chris@howeville.com