convection 0.0.1 → 0.2.1

data/lib/convection/dsl/helpers.rb

@@ -1,15 +1,73 @@
+require 'forwardable'
+require_relative './intrinsic_functions'
+
 module Convection
   module DSL
     ##
-    # Template DSL
+    # Methods for defining DSL/Models
+    ##
+    module ClassHelpers
+      def attribute(attribute_name)
+        attr_writer attribute_name
+        define_method(attribute_name) do |value = nil|
+          instance_variable_set("@#{ attribute_name }", value) unless value.nil?
+          instance_variable_get("@#{ attribute_name }")
+        end
+      end
+
+      def list(attribute_name)
+        define_method(attribute_name) do |value = nil|
+          collection = instance_variable_get("@#{ attribute_name }")
+          collection << value unless value.nil?
+          collection
+        end
+      end
+    end
+
+    ##
+    # Helper methods for creating templates
     ##
     module Helpers
-      def attribute(name)
-        define_method(name) do |value = nil|
-          instance_variable_set("@#{ name }", value) unless value.nil?
-          instance_variable_get("@#{ name }")
+      extend Forwardable
+      include DSL::IntrinsicFunctions
+
+      def_delegators :@template, :stack, :parameters, :mappings, :resources, :outputs
+
+      class << self
+        def included(mod)
+          mod.extend(DSL::ClassHelpers)
+        end
+
+        def method_name(cf_type)
+          nodes = cf_type.split('::')
+          nodes.shift # Remove AWS::
+
+          ## Cammel-case to snake-case
+          nodes.map! do |n|
+            n.split(/([A-Z0-9])(?![A-Z0-9])(?<!$)/)
+              .reject(&:empty?)
+              .reduce('') { |a, e| (e.length == 1 && !a.empty?) ? a + "_#{e}" : a + e }
+              .downcase
+          end
+
+          nodes.join('_').downcase
         end
       end
+
+      ## Convert various casings to CamelCase
+      def camel_case(str)
+        str.downcase.split(/[\.\-_]/).map(&:capitalize).join
+      end
+
+      ## Convert various casings to snake_case
+      def snake_case(str)
+        str.downcase.split(/[\.\-_]/).join('_')
+      end
+
+      ## Convert various casings to SCREAMING_SNAKE_CASE
+      def screaming_snake_case(str)
+        str.upcase.split(/[\.\-_]/).join('_')
+      end
     end
   end
 end

data/lib/convection/model/attributes.rb

@@ -0,0 +1,60 @@
+module Convection
+  module Model
+    ##
+    # Manage parameters and attributes across stacks
+    ##
+    class Attributes
+      class Stack
+        attr_accessor :resources
+        attr_accessor :outputs
+        attr_reader :parameters
+
+        def initialize
+          @resources = {}
+          @outputs = {}
+          @parameters = {}
+        end
+
+        def include?(key)
+          @parameters.include?(key) || @outputs.include?(key) || @resources.include?(key)
+        end
+
+        def [](key)
+          @parameters[key.to_s] || @outputs[key.to_s] || @resources[key.to_s]
+        end
+
+        def []=(key, value)
+          @parameters[key.to_s] = value
+        end
+      end
+
+      attr_reader :stacks
+
+      def initialize
+        @stacks = Hash.new do |hash, key|
+          hash[key] = Stack.new
+        end
+      end
+
+      def include?(stack, key)
+        @stacks.include?(stack) && @stacks[stack].include?(key)
+      end
+
+      def get(stack, key, default = nil)
+        include?(stack, key) ? @stacks[stack.to_s][key.to_s] : default
+      end
+
+      def set(stack, key, value)
+        @stacks[stack.to_s][key.to_s] = value
+      end
+
+      def load_outputs(stack)
+        @stacks[stack.name.to_s].outputs = stack.outputs
+      end
+
+      def load_resources(stack)
+        @stacks[stack.name.to_s].resources = stack.attribute_mapping_values
+      end
+    end
+  end
+end

data/lib/convection/model/cloudfile.rb

@@ -0,0 +1,58 @@
+require_relative '../control/stack'
+require_relative '../dsl/helpers'
+require_relative '../model/attributes'
+require_relative '../model/template'
+
+module Convection
+  module DSL
+    ##
+    # DSL for Cloudfile
+    ##
+    module Cloudfile
+      include DSL::Helpers
+
+      attribute :name
+      attribute :region
+      attribute :splay
+
+      ## Helper to define a template in-line
+      def template(*args, &block)
+        Model::Template.new(*args, &block)
+      end
+
+      def attribute(stack, key, value)
+        @attributes.set(stack, key, value)
+      end
+
+      def stack(stack_name, template, options = {})
+        options[:region] ||= region
+        options[:cloud] = name
+        options[:attributes] = attributes
+
+        @stacks[stack_name] = Control::Stack.new(stack_name, template, options)
+        @deck << @stacks[stack_name]
+      end
+    end
+  end
+
+  module Model
+    ##
+    # Define your Clouds
+    ##
+    class Cloudfile
+      include DSL::Cloudfile
+
+      attr_reader :attributes
+      attr_reader :stacks
+      attr_reader :deck
+
+      def initialize(cloudfile)
+        @attributes = Model::Attributes.new
+        @stacks = {}
+        @deck = []
+
+        instance_eval(IO.read(cloudfile), cloudfile, 1)
+      end
+    end
+  end
+end

data/lib/convection/model/diff.rb

@@ -0,0 +1,39 @@
+require_relative './mixin/colorize'
+
+module Convection
+  module Model
+    ##
+    # Difference between an item in two templates
+    ##
+    class Diff
+      extend Mixin::Colorize
+
+      attr_reader :key
+      attr_reader :action
+      attr_reader :ours
+      attr_reader :theirs
+      colorize :action, :green => [:create], :yellow => [:update], :red => [:delete]
+
+      def initialize(key, ours, theirs)
+        @key = key
+        @ours = ours
+        @theirs = theirs
+
+        @action = if ours && theirs then :update
+                  elsif ours then :create
+                  else :delete
+                  end
+      end
+
+      def to_thor
+        message = case action
+                  when :create then "#{ key }: #{ ours }"
+                  when :update then "#{ key }: #{ theirs } => #{ ours }"
+                  when :delete then key
+                  end
+
+        [action, message, color]
+      end
+    end
+  end
+end

data/lib/convection/model/event.rb

@@ -0,0 +1,62 @@
+require_relative './mixin/colorize'
+require_relative '../control/stack'
+
+module Convection
+  module Model
+    ##
+    # Wrap events with some smarts
+    ##
+    class Event
+      extend Mixin::Colorize
+
+      attr_accessor :name
+      attr_accessor :message
+      attr_accessor :level
+      attr_accessor :timestamp
+      colorize :level,
+               :green => [:info, :success, Control::Stack::CREATE_COMPLETE, Control::Stack::UPDATE_COMPLETE, Control::Stack::UPDATE_ROLLBACK_COMPLETE],
+               :red => [:error, :fail, Control::Stack::CREATE_FAILED, Control::Stack::ROLLBACK_FAILED,
+                        Control::Stack::DELETE_FAILED, Control::Stack::UPDATE_FAILED,
+                        Control::Stack::UPDATE_ROLLBACK_IN_PROGRESS, Control::Stack::UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS,
+                        Control::Stack::UPDATE_ROLLBACK_FAILED],
+               :default => :yellow
+
+      class << self
+        def from_cf(event)
+          Event.new(event.resource_status.downcase,
+                    "#{ event.logical_resource_id }: (#{ event.resource_type }/"\
+                    "#{ event.physical_resource_id}) #{ event.resource_status_reason }",
+                    event.resource_status,
+                    :event_id => event.event_id,
+                    :logical_resource_id => event.logical_resource_id,
+                    :physical_resource_id => event.physical_resource_id,
+                    :resource_properties => event.resource_properties,
+                    :resource_status_reason => event.resource_status_reason,
+                    :resource_type => event.resource_type,
+                    :stack_id => event.stack_id,
+                    :stack_name => event.stack_name,
+                    :timestamp => event.timestamp)
+        end
+      end
+
+      def initialize(name, message, level = :info, attributes = {})
+        @name = name
+        @message = message
+        @level = level
+        @attributes = attributes
+      end
+
+      def [](attr)
+        @attributes[attr]
+      end
+
+      def []=(attr, value)
+        @attributes[attr] = value
+      end
+
+      def to_thor
+        [name.downcase, message, color]
+      end
+    end
+  end
+end

data/lib/convection/model/exceptions.rb

@@ -0,0 +1,18 @@
+class ValidationError < StandardError; end
+class ExcessiveResourcesError < ValidationError; end
+class ExcessiveResourceNameError < ValidationError; end
+class ExcessiveMappingsError < ValidationError; end
+class ExcessiveMappingAttributesError < ValidationError; end
+class ExcessiveMappingNameError < ValidationError; end
+class ExcessiveMappingAttributeNameError < ValidationError; end
+class ExcessiveParametersError < ValidationError; end
+class ExcessiveParameterNameError < ValidationError; end
+class ExcessiveParameterBytesizeError < ValidationError; end
+class ExcessiveOutputsError < ValidationError; end
+class ExcessiveOutputNameError < ValidationError; end
+class ExcessiveDescriptionError < ValidationError; end
+class ExcessiveTemplateSizeError < ValidationError; end
+
+def limit_exceeded_error(value, limit, error_class)
+  fail error_class, "Value #{value} exceeds Limit #{limit}"
+end

data/lib/convection/model/mixin/cidr_block.rb

@@ -4,12 +4,12 @@ module Convection
   module Model
     module Mixin
       ##
-      # Add condition helpers
+      # Sanitized CIDR IP notation
       ##
       module CIDRBlock
-        def network(*args)
-          @network = NetAddr::CIDR.create(*args) unless args.empty?
-          property('CidrBlock', @network.to_s)
+        def cidr_property(name = :network, property_name = 'CidrBlock')
+          property(name, property_name,
+                   :transform => proc { |*args| NetAddr::CIDR.create(*args) })
         end
       end
     end

data/lib/convection/model/mixin/colorize.rb

@@ -0,0 +1,20 @@
+module Convection
+  module Model
+    module Mixin
+      module Colorize
+        def colorize(param, options = {})
+          define_method(:color) do
+            case instance_variable_get("@#{ param }")
+            when *options.fetch(:white, [:status]) then :white
+            when *options.fetch(:cyan, [:debug, :trace]) then :cyan
+            when *options.fetch(:green, [:info, :success, :create]) then :green
+            when *options.fetch(:yellow, [:warn, :update]) then :yellow
+            when *options.fetch(:red, [:error, :fail, :delete]) then :red
+            else options.fetch(:default, :green)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convection/model/mixin/conditional.rb

@@ -11,9 +11,7 @@ module Convection
         end
 
         def render_condition(resource)
-          resource.tap do |r|
-            r['Condition'] = condition unless condition.nil?
-          end
+          resource['Condition'] = condition unless condition.nil?
         end
       end
     end

data/lib/convection/model/mixin/policy.rb

@@ -0,0 +1,89 @@
+module Convection
+  module Model
+    module Mixin
+      ##
+      # Add definition helpers for entities with policies
+      ##
+      class Policy
+        include DSL::Helpers
+
+        DEFAULT_VERSION = '2012-10-17'
+
+        attribute :name
+        attribute :id
+        attribute :version
+        list :statement
+
+        def initialize(options = {})
+          @name = options.fetch(:name) { SecureRandom.uuid }
+          @version = DEFAULT_VERSION
+          @statement = []
+
+          @template = options[:template]
+        end
+
+        def allow(sid = nil, &block)
+          add_statement = Statement.new('Allow', @template)
+          add_statement.sid = sid unless sid.nil?
+          add_statement.instance_exec(&block) if block
+
+          statement(add_statement)
+        end
+
+        def document
+          {
+            'Version' => version,
+            'Statement' => statement.map(&:render)
+          }
+        end
+
+        def render(parent = {})
+          parent.tap do |resource|
+            resource['PolicyName'] = name unless name.is_a?(FalseClass)
+            resource['PolicyDocument'] = document
+          end
+        end
+
+        ##
+        # An IAM policy statement
+        ##
+        class Statement
+          include DSL::Helpers
+
+          attribute :sid
+          attribute :effect
+          attribute :principal
+          attribute :condition
+          list :action
+          list :resource
+
+          def s3_resource(bucket, path = nil)
+            return resource "arn:aws:s3:::#{ bucket }/#{ path }" unless path.nil?
+            resource "arn:aws:s3:::#{ bucket }"
+          end
+
+          def initialize(effect = 'Allow', template = nil)
+            @effect = effect
+
+            @action = []
+            @resource = []
+
+            @template = template
+          end
+
+          def render
+            {
+              'Effect' => effect,
+              'Action' => action,
+              'Resource' => resource
+            }.tap do |statemant|
+              statemant['Sid'] = sid unless sid.nil?
+              statemant['Condition'] = condition unless condition.nil?
+              statemant['Principal'] = principal unless principal.nil?
+            end
+          end
+        end
+      end
+    end
+  end
+end