convection 0.0.1

data/lib/convection.rb

@@ -0,0 +1,18 @@
+##
+# Root module
+##
+module Convection
+  class << self
+    def template(&block)
+      Model::Template.new(&block)
+    end
+
+    def stack(name, template, options = {})
+      Control::Stack.new(name, template, options)
+    end
+  end
+end
+
+require_relative 'convection/version'
+require_relative 'convection/model/template'
+require_relative 'convection/control/stack'

data/lib/convection/control/stack.rb

@@ -0,0 +1,165 @@
+require 'aws-sdk'
+require 'json'
+
+module Convection
+  module Control
+    ##
+    # Instantiation of a template in an account/region
+    ##
+    class Stack
+      attr_reader :name
+      attr_accessor :template
+
+      attr_accessor :region
+      attr_accessor :credentials
+      attr_reader :parameters
+      attr_reader :tags
+      attr_accessor :on_failure
+      attr_reader :capabilities
+      attr_reader :options
+
+      ## Valid Stack Statuses
+      CREATE_IN_PROGRESS = 'CREATE_IN_PROGRESS'
+      CREATE_FAILED = 'CREATE_FAILED'
+      CREATE_COMPLETE = 'CREATE_COMPLETE'
+      ROLLBACK_IN_PROGRESS = 'ROLLBACK_IN_PROGRESS'
+      ROLLBACK_FAILED = 'ROLLBACK_FAILED'
+      ROLLBACK_COMPLETE = 'ROLLBACK_COMPLETE'
+      DELETE_IN_PROGRESS = 'DELETE_IN_PROGRESS'
+      DELETE_FAILED = 'DELETE_FAILED'
+      DELETE_COMPLETE = 'DELETE_COMPLETE'
+      UPDATE_IN_PROGRESS = 'UPDATE_IN_PROGRESS'
+      UPDATE_COMPLETE_CLEANUP_IN_PROGRESS = 'UPDATE_COMPLETE_CLEANUP_IN_PROGRESS'
+      UPDATE_COMPLETE = 'UPDATE_COMPLETE'
+      UPDATE_ROLLBACK_IN_PROGRESS = 'UPDATE_ROLLBACK_IN_PROGRESS'
+      UPDATE_ROLLBACK_FAILED = 'UPDATE_ROLLBACK_FAILED'
+      UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS = 'UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS'
+      UPDATE_ROLLBACK_COMPLETE = 'UPDATE_ROLLBACK_COMPLETE'
+
+      ## Internal status
+      NOT_CREATED = 'NOT_CREATED'
+
+      def initialize(name, template, options = {})
+        @name = name
+        @template = template
+
+        @region = options.delete(:region) { |_| 'us-east-1' }
+        @credentials = options.delete(:credentials)
+        @parameters = options.delete(:parameters) { |_| {} } # Default empty hash
+        @tags = options.delete(:tags) { |_| {} } # Default empty hash
+
+        ## There can be only one...
+        @on_failure = options.delete(:on_failure) { |_| 'DELETE' }
+        options.delete(:disable_rollback)
+
+        @capabilities = options.delete(:capabilities) { |_| ['CAPABILITY_IAM'] }
+        @options = options
+
+        @ec2_client = AWS::EC2::Client.new(:region => region,
+                                           :credentials => @credentials)
+        @cf_client = AWS::CloudFormation::Client.new(:region => region,
+                                                     :credentials => @credentials)
+      end
+
+      def stacks
+        @stacks || cf_get_stacks
+      end
+
+      def status
+        stacks[name].stack_status rescue NOT_CREATED
+      end
+
+      def exist?
+        stacks.include?(name)
+      end
+
+      def complete?
+        [CREATE_COMPLETE, UPDATE_COMPLETE].include?(status)
+      end
+
+      def rollback?
+        [ROLLBACK_IN_PROGRESS, ROLLBACK_FAILED, ROLLBACK_COMPLETE,
+         UPDATE_ROLLBACK_IN_PROGRESS, UPDATE_ROLLBACK_FAILED,
+         UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS,
+         UPDATE_ROLLBACK_COMPLETE].include?(status)
+      end
+
+      def fail?
+        [CREATE_FAILED, ROLLBACK_FAILED, DELETE_FAILED, UPDATE_ROLLBACK_FAILED].include?(status)
+      end
+
+      def render
+        template.render(self)
+      end
+
+      def to_json
+        template.to_json(self)
+      end
+
+      def apply
+        cf_get_stacks ## force-update status
+        request_options = @options.clone.tap do |o|
+          o[:stack_name] = name
+          o[:template_body] = to_json
+          o[:parameters] = cf_parameters
+          o[:capabilities] = capabilities
+        end
+
+        return @cf_client.update_stack(request_options) if exist?
+        @cf_client.create_stack(request_options.tap do |o|
+          o[:tags] = cf_tags
+          o[:on_failure] = @on_failure
+        end)
+      rescue AWS::CloudFormation::Errors::ValidationError => e
+        ## TODO Return something sane
+        ## SDK throws this as an error >.<
+        raise e unless e.message == 'No updates are to be performed.'
+      end
+
+      def delete
+        @cf_client.delete_stack(
+          :stack_name => name
+        )
+      end
+
+      def availability_zones(&block)
+        @availability_zones ||=
+          @ec2_client.describe_availability_zones.availability_zone_info.map(&:zone_name).sort
+
+        @availability_zones.each_with_index(&block) if block
+        @availability_zones
+      end
+
+      private
+
+      def cf_get_stacks
+        @stacks = {}.tap do |col|
+          cf_stacks = @cf_client.list_stacks.stack_summaries rescue []
+          cf_stacks.each do |s|
+            next if s.stack_status == DELETE_COMPLETE
+            col[s.stack_name] = s
+          end
+        end
+      end
+
+      def cf_parameters
+        parameters.map do |p|
+          {
+            :parameter_key => p[0].to_s,
+            :parameter_value => p[1].to_s,
+            :use_previous_value => false
+          }
+        end
+      end
+
+      def cf_tags
+        tags.map do |p|
+          {
+            :key => p[0].to_s,
+            :value => p[1].to_s
+          }
+        end
+      end
+    end
+  end
+end

data/lib/convection/dsl/helpers.rb

@@ -0,0 +1,15 @@
+module Convection
+  module DSL
+    ##
+    # Template DSL
+    ##
+    module Helpers
+      def attribute(name)
+        define_method(name) do |value = nil|
+          instance_variable_set("@#{ name }", value) unless value.nil?
+          instance_variable_get("@#{ name }")
+        end
+      end
+    end
+  end
+end

data/lib/convection/dsl/intrinsic_functions.rb

@@ -0,0 +1,79 @@
+module Convection
+  module DSL
+    ##
+    # Formatting helpers for Intrinsic Functions
+    module IntrinsicFunctions
+      def base64(content)
+        {
+          'Fn::Base64' => content
+        }
+      end
+
+      def fn_and(*conditions)
+        {
+          'Fn::And' => conditions
+        }
+      end
+
+      def fn_equals(value_1, value_2)
+        {
+          'Fn::Equals' => [value_1, value_2]
+        }
+      end
+
+      def fn_if(condition, value_true, value_false)
+        {
+          'Fn::If' => [condition, value_true, value_false]
+        }
+      end
+
+      def fn_not(condition)
+        {
+          'Fn::Not' => [condition]
+        }
+      end
+
+      def fn_or(*conditions)
+        {
+          'Fn::Or' => conditions
+        }
+      end
+
+      def find_in_map(map_name, key_1, key_2)
+        {
+          'Fn::FindInMap' => [map_name, key_1, key_2]
+        }
+      end
+
+      def get_att(resource, attr_name)
+        {
+          'Fn::GetAtt' => [resource, attr_name]
+        }
+      end
+
+      def get_azs(region)
+        {
+          'Fn::GetAZs' => region
+        }
+      end
+
+      def join(delimiter, *values)
+        {
+          'Fn::Join' => [delimiter, values]
+        }
+      end
+
+      def select(index, *objects)
+        {
+          'Fn::Select' => [index, objects]
+        }
+      end
+
+      def fn_ref(resource)
+        {
+          'Ref' => resource
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'netaddr'
+
+module Convection
+  module Model
+    module Mixin
+      ##
+      # Add condition helpers
+      ##
+      module CIDRBlock
+        def network(*args)
+          @network = NetAddr::CIDR.create(*args) unless args.empty?
+          property('CidrBlock', @network.to_s)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Convection
+  module Model
+    module Mixin
+      ##
+      # Add condition helpers
+      ##
+      module Conditional
+        def condition(setter = nil)
+          @condition = setter unless setter.nil?
+          @condition
+        end
+
+        def render_condition(resource)
+          resource.tap do |r|
+            r['Condition'] = condition unless condition.nil?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+require 'json'
+
+module Convection
+  module Model
+    ##
+    # CloudFormation ResourceTag set
+    ##
+    class Tags < Hash
+      def render
+        map do |t|
+          {
+            :Key => t[0].to_s,
+            :Value => t[1]
+          }
+        end
+      end
+    end
+
+    module Mixin
+      ##
+      # Add tag helpers to taddable resources
+      ##
+      module Taggable
+        def tags
+          @tags ||= Tags.new
+        end
+
+        def tag(key, value)
+          tags[key] = value
+        end
+
+        ## Helper for Asgard
+        def immutable_metadata(purpose, target = '')
+          tag('immutable_metadata', JSON.generate(
+            :purpose => purpose,
+            :target => target
+          ))
+        end
+
+        def render_tags(resource)
+          resource.tap do |r|
+            r['Properties']['Tags'] = tags.render unless tags.empty?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convection/model/template.rb

@@ -0,0 +1,127 @@
+require_relative '../dsl/helpers'
+require_relative '../dsl/intrinsic_functions'
+require 'json'
+
+module Convection
+  module DSL
+    ##
+    # Template DSL
+    ##
+    module Template
+      def parameter(name, &block)
+        pa = Model::Template::Parameter.new(name, self)
+
+        pa.instance_exec(&block) if block
+        parameters[name] = pa
+      end
+
+      def mapping(name, &block)
+        m = Model::Template::Mapping.new(name, self)
+
+        m.instance_exec(&block) if block
+        mappings[name] = m
+      end
+
+      # def condition(name, &block)
+      #   c = Model::Template::Condition.new
+      #   c.instance_exec(&block) if block
+      #
+      #   conditions[name] = c
+      # end
+
+      def resource(name, &block)
+        r = Model::Template::Resource.new(name, self)
+
+        r.instance_exec(&block) if block
+        resources[name] = r
+      end
+
+      def output(name, &block)
+        o = Model::Template::Output.new(name, self)
+
+        o.instance_exec(&block) if block
+        outputs[name] = o
+      end
+    end
+  end
+
+  module Model
+    ##
+    # Mapable hash
+    ##
+    class Collection < Hash
+      def map(&block)
+        result = {}
+
+        each do |key, value|
+          result[key] = block.call(value)
+        end
+
+        result
+      end
+    end
+
+    ##
+    # Template container class
+    ##
+    class Template
+      extend DSL::Helpers
+
+      include DSL::IntrinsicFunctions
+      include DSL::Template
+
+      DEFAULT_VERSION = '2010-09-09'
+
+      attribute :version
+      attribute :description
+      attribute :region
+
+      attr_reader :stack
+      attr_reader :parameters
+      attr_reader :mappings
+      attr_reader :conditions
+      attr_reader :resources
+      attr_reader :outputs
+
+      def initialize(stack = Control::Stack.new('default', self), &block)
+        @definition = block
+        @stack = stack
+
+        @version = DEFAULT_VERSION
+        @description = ''
+
+        @parameters = Collection.new
+        @mappings = Collection.new
+        @conditions = Collection.new
+        @resources = Collection.new
+        @outputs = Collection.new
+      end
+
+      def render(stack = nil)
+        ## Instantiate a new template with the definition block and an other stack
+        return Template.new(stack, &@definition).render unless stack.nil?
+
+        instance_exec(&@definition)
+        {
+          'AWSTemplateFormatVersion' => version,
+          'Description' => description,
+          'Parameters' => parameters.map(&:render),
+          'Mappings' => mappings.map(&:render),
+          'Conditions' => conditions.map(&:render),
+          'Resources' => resources.map(&:render),
+          'Outputs' => outputs.map(&:render)
+        }
+      end
+
+      def to_json(stack = nil)
+        JSON.pretty_generate(render(stack))
+      end
+    end
+  end
+end
+
+require_relative 'template/parameter'
+require_relative 'template/mapping'
+# require_relative 'template/condition'
+require_relative 'template/resource'
+require_relative 'template/output'