cfndsl 0.0.5 → 0.0.6

data/lib/cfndsl/CloudFormationTemplate.rb

@@ -0,0 +1,151 @@
+require 'cfndsl/JSONable'
+
+module CfnDsl  
+  class CloudFormationTemplate < JSONable 
+    ##
+    # Handles the overall template object
+    dsl_attr_setter :AWSTemplateFormatVersion, :Description
+    dsl_content_object :Parameter, :Output, :Resource, :Mapping
+    
+    def initialize
+      @AWSTemplateFormatVersion = "2010-09-09"
+    end
+    
+    def generateOutput() 
+      puts self.to_json  # uncomment for pretty printing # {:space => ' ', :indent => '  ', :object_nl => "\n", :array_nl => "\n" }
+    end
+
+    @@globalRefs = { 
+       "AWS::NotificationARNs" => 1, 
+       "AWS::Region" => 1,
+       "AWS::StackId" => 1,
+       "AWS::StackName" => 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
+
+    
+    names = {}
+    nametypes = {}
+    CfnDsl::Types::AWS_Types["Resources"].each_pair do |name, type|
+      # Subclass ResourceDefintion and generate property methods
+      klass = Class.new(CfnDsl::ResourceDefinition)
+      klassname = name.split("::").join("_")
+      CfnDsl::Types.const_set( klassname, klass )
+      type["Properties"].each_pair do |pname, ptype|
+        if( ptype.instance_of? String )
+          create_klass = CfnDsl::Types.const_get( ptype );
+          klass.class_eval do 
+            define_method(pname) do |*values, &block|
+              if( values.length <1 ) then
+                values.push create_klass.new 
+              end
+              @Properties ||= {}
+              @Properties[pname] ||= CfnDsl::PropertyDefinition.new( *values )
+              @Properties[pname].value.instance_eval &block if block
+              @Properties[pname].value
+            end
+          end
+        else
+          #Array version
+          sing_name = CfnDsl::Plurals.singularize( pname )
+          create_klass = CfnDsl::Types.const_get( ptype[0] )
+          klass.class_eval do
+            define_method(pname) do |*values, &block|
+              if( values.length < 1 ) then
+                values.push []
+              end
+              @Properties ||= {}
+              @Properties[pname] ||= PropertyDefinition.new( *values )
+              @Properties[pname].value.instance_eval &block if block
+              @Properties[pname].value
+            end
+
+            define_method(sing_name) do |value=nil, &block|
+              @Properties ||= {}
+              @Properties[pname] ||= PropertyDefinition.new( [] )
+              if( !value ) then
+                value = create_klass.new
+              end
+              @Properties[pname].value.push value
+              value.instance_eval &block if block
+              value
+            end
+
+          end
+        end
+
+      end
+      parts = name.split "::"
+      while( parts.length > 0) 
+        abreve_name = parts.join "_"
+        if( names.has_key? abreve_name ) then
+          # this only happens if there is an ambiguity
+          names[abreve_name] = nil
+        else
+          names[abreve_name] = CfnDsl::Types.const_get(klassname)
+          nametypes[abreve_name] = name
+        end
+        parts.shift
+      end
+
+
+    end
+    
+    #Define property setter methods for each of the unambiguous type names
+    names.each_pair do |typename,type|
+      if(type) then
+        class_eval do
+          define_method( typename) do |name,*values,&block|
+            name = name.to_s
+            @Resources ||= {}
+            resource = @Resources[name] ||= type.new(*values)
+            resource.instance_eval &block if block
+            resource.instance_variable_set( "@Type", nametypes[typename] )
+            resource
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cfndsl/Errors.rb

@@ -0,0 +1,33 @@
+module CfnDsl
+  module Errors
+    @@errors = []
+    
+    def self.error( err, idx=nil ) 
+      if(idx.nil?) then
+        @@errors.push ( err + "\n" + caller.join("\n") + "\n" )
+      else
+        if( m = caller[idx].match(/^.*?:\d+:/ ) ) then
+          err_loc = m[0];
+        else
+          err_loc = caller[idx]
+        end
+        
+        @@errors.push ( err_loc + " " + err + "\n" )
+      end
+    end
+    
+    def self.clear()
+      @@errors = []
+    end
+
+    def self.report() 
+      @@errors.each do |err|
+        puts err
+      end
+    end
+
+    def self.errors?()
+      return @@errors.length > 0
+    end
+  end
+end

data/lib/cfndsl/JSONable.rb

@@ -0,0 +1,161 @@
+require 'cfndsl/Errors'
+require 'cfndsl/RefCheck'
+
+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)
+      ##
+      # 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]
+        
+        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
+
+    def ref_children
+      return self.instance_variables.map { |var| self.instance_variable_get var }
+    end
+
+    def declare(&block)
+      self.instance_eval &block if block_given?
+    end
+
+    def method_missing(meth,*args,&block) 
+      if(args) then
+        arg = "(" + args.inspect[1..-2] + ")"
+      else 
+        arg = ""
+      end
+      CfnDsl::Errors.error( "Undefined symbol: #{meth}#{arg}", 1 )
+    end
+  end
+
+    
+  class Fn < JSONable
+    ##
+    # Handles all of the Fn:: objects
+    def initialize( function, argument, refs=[] )
+      @function = function
+      @argument = argument
+      @_refs = refs
+    end
+    
+    def to_json(*a)
+      hash = {}
+      hash["Fn::#{@function}"] = @argument
+      hash.to_json(*a)
+    end
+
+    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()
+      [@Ref]
+    end
+  end
+  
+end

data/lib/cfndsl/Mappings.rb

@@ -0,0 +1,25 @@
+require 'cfndsl/JSONable'
+
+module CfnDsl    
+  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
+    
+    def to_json(*a)
+      @value.to_json(*a)
+    end
+  end
+end

data/lib/cfndsl/Metadata.rb

@@ -0,0 +1,10 @@
+require 'cfndsl/JSONable'
+
+module CfnDsl  
+  
+  class MetadataDefinition < JSONable
+    ## 
+    # Handles Metadata objects
+  end
+
+end

data/lib/cfndsl/Outputs.rb

@@ -0,0 +1,13 @@
+require 'cfndsl/JSONable'
+
+module CfnDsl  
+  class OutputDefinition < JSONable
+    ##
+    # Handles Output objects
+    dsl_attr_setter :Value, :Description
+    
+    def initialize( value=nil)
+      @Value = value if value
+    end
+  end
+end

data/lib/cfndsl/Parameters.rb

@@ -0,0 +1,32 @@
+require 'cfndsl/JSONable'
+
+module CfnDsl  
+  
+  class ParameterDefinition < JSONable
+    ##
+    # Handles input parameter objects
+    dsl_attr_setter :Type, :Default, :NoEcho, :AllowedValues, :AllowedPattern, :MaxLength, :MinLength, :MaxValue, :MinValue, :Description, :ConstraintDescription
+    def initialize
+      @Type = :String
+    end
+    
+    def String
+      @Type = :String
+    end
+    
+    def Number
+      @Type = :Number
+    end
+    
+    def CommaDelimitedList
+      @Type = :CommaDelimitedList
+    end
+   
+    def to_hash()
+      h = {}
+      h[:Type] = @Type;
+      h[:Default] = @Default if @Default
+    end
+  end
+  
+end

data/lib/cfndsl/Plurals.rb

@@ -0,0 +1,28 @@
+module CfnDsl
+  module Plurals
+    ##
+    # Plural names for lists of content objects
+    #
+    
+    @@plurals = { 
+      "Metadata" => "Metadata", 
+      "Property" => "Properties",
+      "Policy" => "Policies"
+    }
+
+    @@singles = {}
+    @@plurals.each_pair { |key,val| @@singles[val] = key }
+
+    def self.pluralize(name)
+      name = name.to_s
+      return @@plurals[name] if( @@plurals.has_key? name )
+      return "#{name}s"
+    end
+
+    def self.singularize(name)
+      name = name.to_s
+      return @@singles[name] if( @@singles.has_key? name )
+      return name[0..-2]
+    end
+  end
+end