cfndsl 0.1.3 → 0.1.4

data/bin/cfndsl

@@ -1,4 +1,67 @@
-#!/usr/bin/env ruby 
+#!/usr/bin/env ruby
+
 require 'cfndsl'
-model = eval File.read ARGV[0]
-puts model.to_json
+require 'optparse'
+
+options = {}
+
+optparse = OptionParser.new do|opts|
+  opts.banner = "Usage: cfndsl [options] FILE"
+
+  # Define the options, and what they do
+  options[:output] = '-'
+  opts.on( '-o', '--output FILE', 'Write output to file' ) do |file|
+    options[:output] = file
+  end
+
+  options[:extras] = []
+  opts.on( '-y', '--yaml FILE', 'Import yaml file as local variables' ) do |file|
+    options[:extras].push([:yaml,File.expand_path(file)])
+  end
+
+  opts.on( '-r', '--ruby FILE', 'Evaluate ruby file before template' ) do |file|
+    options[:extras].push([:ruby,File.expand_path(file)])
+  end
+
+  opts.on( '-j', '--json FILE', 'Import json file as local variables' ) do |file|
+    options[:extras].push([:json,File.expand_path(file)])
+  end
+
+
+  opts.on( '-D', '--define "VARIABLE=VALUE"', 'Directly set local VARIABLE as VALUE' ) do |file|
+    options[:extras].push([:raw,file])
+  end
+
+  options[:verbose] = false
+  opts.on('-v', '--verbose', "Turn on verbose ouptut") do
+    options[:verbose] = true
+  end
+
+  # This displays the help screen, all programs are
+  # assumed to have this option.
+  opts.on( '-h', '--help', 'Display this screen' ) do
+    puts opts
+    exit
+  end
+end
+
+optparse.parse!
+unless ARGV[0] then
+  puts optparse.help
+  exit(1)
+end
+
+filename = File.expand_path(ARGV[0])
+verbose = options[:verbose] && STDERR
+
+model = CfnDsl::eval_file_with_extras(filename, options[:extras], verbose)
+
+output = STDOUT
+if options[:output] != '-' then
+  verbose.puts("Writing to #{options[:output]}") if verbose
+  output = File.open( File.expand_path(options[:output]), "w")
+else
+  verbose.puts("Writing to STDOUT") if verbose
+end
+
+output.puts model.to_json

data/lib/cfndsl.rb

@@ -15,6 +15,75 @@ require 'cfndsl/Parameters'
 require 'cfndsl/Outputs'
 require 'cfndsl/CloudFormationTemplate'
 
+module CfnDsl
+  def self.eval_file_with_extras(filename, extras = [], logstream = nil)
+    # This function handles the eval of the template file and returns the
+    # results. It does this with a ruby "eval", but it builds up a customized
+    # binding environment before it calls eval. The environment can be
+    # customized by passing a list of customizations in the extras parameter.
+    #
+    # These customizations are expressed as an array of pairs of
+    # (type,filename). They are evaluated in the order they appear in the
+    # extras array. The types are as follows
+    #
+    # :yaml - the second element is treated as a file name, which is loaded
+    #         as a yaml file. The yaml file should contain a top level
+    #         dictionary. Each of the keys of the top level dictionary is
+    #         used as a local variable in the evalation context.
+    #
+    # :json - the second element is treated as a file name, which is loaded
+    #         as a json file. The yaml file should contain a top level
+    #         dictionary. Each of the keys of the top level dictionary is
+    #         used as a local variable in the evalation context.
+    #
+    # :ruby - the second element is treated as a file name which is evaluated
+    #         as a ruby file. Any assigments (or other binding affecting
+    #         side effects) will persist into the context where the template
+    #         is evaluated
+    #
+    # :raw  - the seccond elements is treated as a ruby statement and is
+    #         evaluated in the binding context, similar to the contents of
+    #         a ruby file.
+    #
+    # Note that the order is important, as later extra sections can overwrite
+    # or even undo things that were done by earlier sections.
+
+    b = binding
+    extras.each do |pair|
+      type,file = pair
+      case type
+      when :yaml
+        logstream.puts("Loading YAML file #{file}") if logstream
+        parameters = YAML.load(File.read(file))
+        parameters.each do |k,v|
+          logstream.puts("Setting local variable #{k} to #{v}") if logstream
+          b.eval("#{k} = #{v.inspect}")
+        end
+
+      when :json
+        logstream.puts("Loading YAML file #{file}") if logstream
+        parameters = JSON.load(File.read(file))
+        parameters.each do |k,v|
+          logstream.puts("Setting local variable #{k} to #{v}") if logstream
+          b.eval("#{k} = #{v.inspect}")
+        end
+
+      when :ruby
+        logstream("Runnning ruby file #{file}") if logstream
+        b.eval(File.read(file), file)
+
+      when :raw
+        logstrame("Running raw ruby code #{file}") if logstream
+        b.eval(file, "raw code")
+      end
+    end
+
+    logstream.puts("Loading template file #{filename}") if logstream
+    model = b.eval(File.read(filename), filename)
+    return model
+  end
+end
+
 def CloudFormation(&block)
   x = CfnDsl::CloudFormationTemplate.new
   x.declare(&block)
@@ -28,3 +97,16 @@ def CloudFormation(&block)
   end
 end
 
+def Heat(&block)
+  x = CfnDsl::HeatTemplate.new
+  x.declare(&block)
+  invalid_references = x.checkRefs()
+  if( invalid_references ) then
+    abort invalid_references.join("\n")
+  elsif( CfnDsl::Errors.errors? ) then
+    abort CfnDsl::Errors.errors.join("\n")
+  else
+    return x
+  end
+end
+

data/lib/cfndsl/CloudFormationTemplate.rb

@@ -2,7 +2,7 @@ require 'cfndsl/JSONable'
 require 'cfndsl/names'
 
 module CfnDsl
-  class CloudFormationTemplate < JSONable
+  class OrchestrationTemplate < JSONable
     ##
     # Handles the overall template object
     dsl_attr_setter :AWSTemplateFormatVersion, :Description
@@ -62,18 +62,26 @@ module CfnDsl
       end
       return invalids.length>0 ? invalids : nil
     end
+  end
 
+  class CloudFormationTemplate < OrchestrationTemplate
+    def self.template_types
+      CfnDsl::AWSTypes::AWS_Types
+    end
+    def self.type_module
+      CfnDsl::AWSTypes
+    end
 
     names = {}
     nametypes = {}
-    CfnDsl::Types::AWS_Types["Resources"].each_pair do |name, type|
+    self.template_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_module.const_set( klassname, klass )
       type["Properties"].each_pair do |pname, ptype|
         if( ptype.instance_of? String )
-          create_klass = CfnDsl::Types.const_get( ptype );
+          create_klass = type_module.const_get( ptype );
 
           klass.class_eval do
             CfnDsl::methodNames(pname) do |method|
@@ -91,7 +99,7 @@ module CfnDsl
         else
           #Array version
           sing_name = CfnDsl::Plurals.singularize( pname )
-          create_klass = CfnDsl::Types.const_get( ptype[0] )
+          create_klass = type_module.const_get( ptype[0] )
           klass.class_eval do
             CfnDsl::methodNames(pname) do |method|
               define_method(method) do |*values, &block|
@@ -128,7 +136,7 @@ module CfnDsl
           # this only happens if there is an ambiguity
           names[abreve_name] = nil
         else
-          names[abreve_name] = CfnDsl::Types.const_get(klassname)
+          names[abreve_name] = self.type_module.const_get(klassname)
           nametypes[abreve_name] = name
         end
         parts.shift
@@ -154,5 +162,106 @@ module CfnDsl
         end
       end
     end
+
+
+  end
+
+  class HeatTemplate < OrchestrationTemplate 
+    def self.template_types
+      CfnDsl::OSTypes::OS_Types
+    end
+    def self.type_module
+      CfnDsl::OSTypes
+    end
+
+    names = {}
+    nametypes = {}
+    self.template_types["Resources"].each_pair do |name, type|
+      # Subclass ResourceDefintion and generate property methods
+      klass = Class.new(CfnDsl::ResourceDefinition)
+      klassname = name.split("::").join("_")
+      type_module.const_set( klassname, klass )
+      type["Properties"].each_pair do |pname, ptype|
+        if( ptype.instance_of? String )
+          create_klass = type_module.const_get( ptype );
+
+          klass.class_eval do
+            CfnDsl::methodNames(pname) do |method|
+              define_method(method) 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
+          end
+        else
+          #Array version
+          sing_name = CfnDsl::Plurals.singularize( pname )
+          create_klass = type_module.const_get( ptype[0] )
+          klass.class_eval do
+            CfnDsl::methodNames(pname) do |method|
+              define_method(method) 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
+            end
+
+            CfnDsl::methodNames(sing_name) do |method|
+              define_method(method) 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
+
+      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] = self.type_module.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
+          CfnDsl::methodNames(typename) do |method|
+            define_method(method) 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
+
 end

data/lib/cfndsl/Types.rb

@@ -4,15 +4,15 @@ require 'cfndsl/Plurals'
 require 'cfndsl/names'
 
 module CfnDsl
-  module Types
-
+  module AWSTypes
     aws_types = YAML::load( File.open( "#{File.dirname(__FILE__)}/aws_types.yaml") );
-    Types.const_set( "AWS_Types", aws_types);
-    
+    AWSTypes.const_set( "AWS_Types", aws_types);
+   
     # Do a little sanity checking - all of the types referenced in Resources
     # should be represented in Types
     aws_types["Resources"].keys.each do |resource_name|
       #puts resource_name
+      
       resource = aws_types["Resources"][resource_name]
       resource.values.each do |thing|
         thing.values.each do |type|
@@ -36,9 +36,7 @@ module CfnDsl
         end
       end
     end
-    
-    
-  
+      
     # declare classes for all of the types with named methods for setting the values
     class AWSType < JSONable
     end
@@ -47,11 +45,11 @@ module CfnDsl
     
     # Go through and declare all of the types first
     aws_types["Types"].each_key do |typename|
-      if( ! Types.const_defined? typename ) then
-        klass = Types.const_set( typename, Class.new(AWSType ) )
+      if( ! AWSTypes.const_defined? typename ) then
+        klass = AWSTypes.const_set( typename, Class.new(AWSType ) )
         classes[typename] = klass
       else
-        classes[typename] = Types.const_get(typename)
+        classes[typename] = AWSTypes.const_get(typename)
       end 
     end
     
@@ -62,7 +60,157 @@ module CfnDsl
       if( typeval.respond_to? :each_pair ) then
         typeval.each_pair do |attr_name, attr_type|
           if( attr_type.kind_of? Array ) then
-            klass = CfnDsl::Types.const_get( attr_type[0] )
+            klass = CfnDsl::AWSTypes.const_get( attr_type[0] )
+            variable = "@#{attr_name}".to_sym
+            
+            method = CfnDsl::Plurals::singularize(attr_name)
+            methods = attr_name
+            all_methods = CfnDsl::methodNames(method) +
+              CfnDsl::methodNames(methods)
+            type.class_eval do
+              all_methods.each do |method_name|
+                define_method(method_name) do | value=nil, *rest, &block|
+                  existing = instance_variable_get( variable )                  
+                  # For no-op invocations, get out now
+                  return existing if value.nil? and rest.length == 0 and ! block
+                  
+                  # We are going to modify the value in some
+                  # way, make sure that we have an array to mess
+                  # with if we start with nothing
+                  if( !existing ) then
+                    existing = instance_variable_set( variable, [] )
+                  end
+
+                  # special case for just a block, no args
+                  if( value.nil? and rest.length == 0 and block ) then
+                    val = klass.new
+                    existing.push val
+                    value.instance_eval &block(val)
+                    return existin
+                  end
+                     
+                  # Glue all of our parameters together into
+                  # a giant array - flattening one level deep, if needed
+                  array_params = []
+                  if( value.kind_of? Array) then 
+                    value.each {|x| array_params.push x}
+                  else
+                    array_params.push value
+                  end
+                  if( rest.length > 0) then
+                    rest.each do |v|
+                      if( v.kind_of? Array ) then
+                        array_params += rest
+                      else
+                        array_params.push v
+                      end
+                    end
+                  end
+                  
+                  # Here, if we were given multiple arguments either
+                  # as method [a,b,c], method(a,b,c), or even 
+                  # method( a, [b], c) we end up with 
+                  # array_params = [a,b,c]
+                  #
+                  # array_params will have at least one item
+                  # unless the user did something like pass in
+                  # a bunch of empty arrays.
+                  if block then
+                    array_params.each do |val|
+                      value = klass.new
+                      existing.push value
+                      value.instance_eval &block(val) if block
+                    end
+                  else
+                    # List of parameters with no block -
+                    # hope that the user knows what he is
+                    # doing and stuff them into our existing 
+                    # array
+                    array_params.each do |val|
+                      existing.push value
+                    end
+                  end
+                  return existing
+                end
+              end
+            end
+          else
+            klass = CfnDsl::AWSTypes.const_get( attr_type );
+            variable = "@#{attr_name}".to_sym
+
+            type.class_eval do 
+              CfnDsl::methodNames(attr_name) do |method|
+                define_method(method) do | value=nil, *rest, &block |
+                  value ||= klass.new
+                  instance_variable_set( variable, value )
+                  value.instance_eval &block if block
+                  value
+                end
+              end
+            end  
+          end
+        end
+      end
+    end
+  end
+
+  module OSTypes
+    os_types = YAML::load( File.open( "#{File.dirname(__FILE__)}/os_types.yaml") );
+    OSTypes.const_set( "OS_Types", os_types);
+   
+    # Do a little sanity checking - all of the types referenced in Resources
+    # should be represented in Types
+    os_types["Resources"].keys.each do |resource_name|
+      #puts resource_name
+      
+      resource = os_types["Resources"][resource_name]
+      resource.values.each do |thing|
+        thing.values.each do |type|
+          if( type.kind_of? Array ) then
+            type.each do | type |
+              puts "unknown type #{type}" unless os_types["Types"].has_key? type 
+            end
+          else
+            puts "unknown type #{type}" unless os_types["Types"].has_key? type 
+          end
+        end
+      end
+    end
+    
+    # All of the type values should also be references
+    
+    os_types["Types"].values do |type|
+      if( type.respond_to? :values) then
+        type.values.each do |tv|
+          puts "unknown type #{tv}" unless os_types["Types"].has_key? tv 
+        end
+      end
+    end
+      
+    # declare classes for all of the types with named methods for setting the values
+    class OSType < JSONable
+    end
+  
+    classes = {}
+    
+    # Go through and declare all of the types first
+    os_types["Types"].each_key do |typename|
+      if( ! OSTypes.const_defined? typename ) then
+        klass = OSTypes.const_set( typename, Class.new(OSType ) )
+        classes[typename] = klass
+      else
+        classes[typename] = OSTypes.const_get(typename)
+      end 
+    end
+    
+    # Now go through them again and define attribute setter methods
+    classes.each_pair do |typename,type|
+      #puts typename
+      typeval = os_types["Types"][typename]
+      if( typeval.respond_to? :each_pair ) then
+        typeval.each_pair do |attr_name, attr_type|
+          if( attr_type.kind_of? Array ) then
+            klass = CfnDsl::OSTypes.const_get( attr_type[0] )
             variable = "@#{attr_name}".to_sym
             
             method = CfnDsl::Plurals::singularize(attr_name)
@@ -137,7 +285,7 @@ module CfnDsl
               end
             end
           else
-            klass = CfnDsl::Types.const_get( attr_type );
+            klass = CfnDsl::OSTypes.const_get( attr_type );
             variable = "@#{attr_name}".to_sym
 
             type.class_eval do 
@@ -155,5 +303,7 @@ module CfnDsl
       end
     end
   end  
+
+  
 end