active_aws 0.1.0

data/fixtures/vcr_cassettes/ActiveAws_EC2_client_feature/It_has_regions_.yml

@@ -0,0 +1,92 @@
+---
+http_interactions:
+- request:
+    method: post
+    uri: https://ec2.ap-southeast-1.amazonaws.com/
+    body:
+      encoding: UTF-8
+      string: Action=DescribeRegions&Version=2015-04-15
+    headers:
+      Content-Type:
+      - application/x-www-form-urlencoded; charset=utf-8
+      Accept-Encoding:
+      - ''
+      User-Agent:
+      - aws-sdk-ruby2/2.0.43 ruby/2.2.2 x86_64-darwin14
+      X-Amz-Date:
+      - 20150607T012352Z
+      Host:
+      - ec2.ap-southeast-1.amazonaws.com
+      X-Amz-Content-Sha256:
+      - edf9b7000580977b273a959c1e9a3cd5eb9ca9254b5013800d6b27423d480047
+      Authorization:
+      - AWS4-HMAC-SHA256 Credential=AKIAIO3PFOLM7KKTQZJQ/20150607/ap-southeast-1/ec2/aws4_request,
+        SignedHeaders=content-type;host;user-agent;x-amz-content-sha256;x-amz-date,
+        Signature=5e4c4df11e86b9a5404bbee684d884c890c2be700ed74454573b1581e3e1d853
+      Content-Length:
+      - '41'
+      Accept:
+      - "*/*"
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Content-Type:
+      - text/xml;charset=UTF-8
+      Transfer-Encoding:
+      - chunked
+      Vary:
+      - Accept-Encoding
+      Date:
+      - Sun, 07 Jun 2015 01:23:54 GMT
+      Server:
+      - AmazonEC2
+    body:
+      encoding: UTF-8
+      string: |-
+        <?xml version="1.0" encoding="UTF-8"?>
+        <DescribeRegionsResponse xmlns="http://ec2.amazonaws.com/doc/2015-04-15/">
+            <requestId>83b5ad40-91e1-4fab-9574-eab4a819a8ef</requestId>
+            <regionInfo>
+                <item>
+                    <regionName>eu-central-1</regionName>
+                    <regionEndpoint>ec2.eu-central-1.amazonaws.com</regionEndpoint>
+                </item>
+                <item>
+                    <regionName>sa-east-1</regionName>
+                    <regionEndpoint>ec2.sa-east-1.amazonaws.com</regionEndpoint>
+                </item>
+                <item>
+                    <regionName>ap-northeast-1</regionName>
+                    <regionEndpoint>ec2.ap-northeast-1.amazonaws.com</regionEndpoint>
+                </item>
+                <item>
+                    <regionName>eu-west-1</regionName>
+                    <regionEndpoint>ec2.eu-west-1.amazonaws.com</regionEndpoint>
+                </item>
+                <item>
+                    <regionName>us-east-1</regionName>
+                    <regionEndpoint>ec2.us-east-1.amazonaws.com</regionEndpoint>
+                </item>
+                <item>
+                    <regionName>us-west-1</regionName>
+                    <regionEndpoint>ec2.us-west-1.amazonaws.com</regionEndpoint>
+                </item>
+                <item>
+                    <regionName>us-west-2</regionName>
+                    <regionEndpoint>ec2.us-west-2.amazonaws.com</regionEndpoint>
+                </item>
+                <item>
+                    <regionName>ap-southeast-2</regionName>
+                    <regionEndpoint>ec2.ap-southeast-2.amazonaws.com</regionEndpoint>
+                </item>
+                <item>
+                    <regionName>ap-southeast-1</regionName>
+                    <regionEndpoint>ec2.ap-southeast-1.amazonaws.com</regionEndpoint>
+                </item>
+            </regionInfo>
+        </DescribeRegionsResponse>
+    http_version: 
+  recorded_at: Sun, 07 Jun 2015 01:23:55 GMT
+recorded_with: VCR 2.9.3

data/lib/active_aws.rb

@@ -0,0 +1,13 @@
+require 'active_support/dependencies/autoload'
+require 'active_support/deprecation'
+require 'active_support/core_ext'
+
+require 'aws-sdk'
+
+module ActiveAws
+
+  autoload :ParameterizedInitializer, 'active_aws/parameterized_initializer'
+  autoload :CloudFormation, 'active_aws/cloud_formation'
+  autoload :EC2, 'active_aws/ec2'
+
+end

data/lib/active_aws/cloud_formation.rb

@@ -0,0 +1,11 @@
+module ActiveAws
+  module CloudFormation
+    autoload :Template, 'active_aws/cloud_formation/template'
+
+    class << self
+      def template(params = {}, &block)
+        Template.new(params, &block)
+      end
+    end
+  end
+end

data/lib/active_aws/cloud_formation/template.rb

@@ -0,0 +1,111 @@
+require 'active_support/concern'
+require 'active_support/json'
+
+require 'active_aws/parameterized_initializer'
+require 'active_aws/cloud_formation/template/properties'
+
+module ActiveAws
+  module CloudFormation
+    class Template
+      include ActiveAws::ParameterizedInitializer
+
+      DEFAULT_AWS_TEMPLATE_FORMAT_VERSION = '2010-09-09'
+
+      autoload :DSLBlock, 'active_aws/cloud_formation/template/dsl_block'
+      autoload :Parameter, 'active_aws/cloud_formation/template/parameter'
+      autoload :Mappings, 'active_aws/cloud_formation/template/mappings'
+      autoload :Resource, 'active_aws/cloud_formation/template/resource'
+
+      module Referrer
+        # You can also just use Ref: 'Name' directly
+        def ref(to)
+          { Ref: to }
+        end
+      end
+
+      attr_reader :aws_template_format_version, :resources, :outputs
+      attr_accessor :description
+
+      def initialize(params = {}, &block)
+        super
+        DSL.new(self).instance_eval(&block) if block_given?
+      end
+
+      def parameters(&block)
+        @parameters ||= Parameter::Collection.new
+        @parameters.instance_eval(&block) if block_given?
+        @parameters
+      end
+
+      def mappings(&block)
+        @mappings ||= Mappings.new
+        @mappings.instance_eval(&block) if block_given?
+        @mappings
+      end
+
+      def resources(&block)
+        @resources ||= Resource::Collection.new
+        @resources.instance_eval(&block) if block_given?
+        @resources
+      end
+
+      require 'delegate'
+
+      # Where the magic inside a Template.new {} block happens
+      class DSL < DelegateClass(Template)
+        attr_accessor :template
+        def initialize(t)
+          super(template = t)
+        end
+        def description(description)
+          self.description = description
+        end
+        def parameter(name, type, options = {})
+          parameters.add(name, type, options)
+        end
+        def mapping(*args)
+          mappings.map(*args)
+        end
+      end
+
+      def to_h
+        {'AWSTemplateFormatVersion' => DEFAULT_AWS_TEMPLATE_FORMAT_VERSION}.tap {|h|
+          h['Description'] = @description unless @description.nil?
+          [:parameters, :mappings, :resources].each {|sym|
+            v = instance_variable_get("@#{sym}")
+            h[sym.to_s.capitalize] = v.to_h unless v.nil? || v.empty?
+          }
+        }
+      end
+
+      def to_json(*args)
+        pretty = args.include?(:pretty)
+        pretty ? JSON.pretty_generate(to_h) : to_h.to_json
+      end
+    end
+  end
+end
+
+# Here we get clever
+module Fn
+  class << self
+    def Base64(s)
+      { 'Fn::Base64' => s }
+    end
+    def FindInMap(map_name, top_level_key, second_level_key)
+      { 'Fn::FindInMap' => [ map_name, top_level_key, second_level_key ] }
+    end
+    def GetAtt(resource_name, attr_name)
+      { 'Fn::GetAtt' => [ resource_name, attr_name ] }
+    end
+    def GetAZs(region)
+      { 'Fn::GetAZs' => region }
+    end
+    def Join(delim, *args)
+      { 'Fn::Join' => [ delim, args ] }
+    end
+    def Select(index, list)
+      { 'Fn::Select' => [ index, list ] }
+    end
+  end
+end

data/lib/active_aws/cloud_formation/template/dsl_block.rb

@@ -0,0 +1,48 @@
+require 'ostruct'
+
+module ActiveAws
+  module CloudFormation
+    class Template
+
+      # Returns a block that acts as a facade for the given target, allowing
+      # calls of the form
+      #
+      #    attribute 'value'
+      #
+      # and transforms them into the equivalent
+      #
+      #    @target.attribute = 'value'
+      class DSLBlock
+        include Referrer
+
+        attr_reader :target
+        def initialize(target)
+          @target = target
+        end
+
+        def method_missing(method_name, *args)
+          if args.size == 0 && (target.is_a?(OpenStruct) || @target.respond_to?(method_name))
+            return @target.send(method_name)
+          elsif args.size == 1
+            if @target.is_a?(Hash)
+              return @target.store(method_name, args.first)
+            else
+              setter = "#{method_name}=".to_sym
+              if @target.is_a?(OpenStruct) || @target.respond_to?(setter)
+                return @target.send(setter, args.first)
+              end
+            end
+          end
+          # fall back to super
+          super
+        end
+
+        class << self
+          def eval_using(target, block)
+            DSLBlock.new(target).instance_eval(&block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_aws/cloud_formation/template/mappings.rb

@@ -0,0 +1,22 @@
+module ActiveAws
+  module CloudFormation
+    class Template
+      class Mappings < DelegateClass(Hash)
+        def initialize
+          super(@mappings = {})
+        end
+
+        def map(name, mapping = {}, &block)
+          raise 'Mappings only accepts a Hash as values' unless mapping.is_a? Hash
+          @mappings[name] = mapping
+          yield mapping if block_given?
+          mapping
+        end
+
+        def to_h
+          {'Mappings' => @mappings}
+        end
+      end
+    end
+  end
+end

data/lib/active_aws/cloud_formation/template/parameter.rb

@@ -0,0 +1,50 @@
+module ActiveAws
+  module CloudFormation
+    class Template
+      class Parameter
+        include ActiveAws::ParameterizedInitializer
+
+        TYPES = [:string, :number, :list]
+        TYPES_MAP = {string: 'String', number: 'Number', list: 'CommaDelimitedList'}
+
+        attr_accessor :name, :type
+
+        FIELDS_MAP = [:description, :default, :no_echo, :allowed_values, :allowed_pattern,
+          :min_length, :max_length, :min_value, :max_value, :constraint_description].each_with_object({}) {|s, h|
+            attr_accessor s
+            h[s] = s.to_s.camelize
+        }
+
+        def to_h
+          FIELDS_MAP.each_with_object('Type' => TYPES_MAP[type]) do |(method, key), h|
+            if v = self.send(method)
+              h[key] = v
+            end
+          end
+        end
+
+        class Collection < Array
+          def add(name, type, options = {})
+            Parameter.new(options.merge({name: name, type: type})).tap { |parameter| push parameter }
+          end
+
+          # define helper methods 'string()', 'number()', 'list()'
+          Parameter::TYPES.each {|type|
+            module_eval <<-EOF
+              def #{type}(name, options = {}, &block)
+                parameter = add(name, :#{type}, options)
+                DSLBlock.eval_using(parameter, block) if block_given?
+                parameter
+              end
+            EOF
+          }
+
+          def to_h
+            each_with_object({}) {|parameter, h| h[parameter.name] = parameter.to_h }
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/active_aws/cloud_formation/template/properties.rb

@@ -0,0 +1,80 @@
+require 'active_support/concern'
+
+module ActiveAws
+  module CloudFormation
+    class Template
+
+      class Properties < Hash
+        def add(name, value)
+          store(name, value)
+        end
+        def method_missing(method_name, *args, &block)
+          if has_key?(method_name)
+            fetch(method_name)
+          else
+            super
+          end
+        end
+      end
+
+      # See http://ruby-doc.org/core-2.2.0/Struct.html
+      PropertyDefinition = Struct.new :name, :type
+      class PropertyDefinition
+        class Collection < Array
+          def add(name, type)
+            puts "PropertyDefinition::Collection.add(#{name},#{type})"
+            self.push(PropertyDefinition.new(name,type))
+          end
+        end
+      end
+
+      # The basis of almost all CloudFormation resources and embedded properties
+      module HasProperties
+        extend ActiveSupport::Concern
+
+        PRIMITIVE_PROPERTY_TYPES = %i(string boolean integer)
+
+        included do
+        end
+
+        class_methods do
+          def properties(*args, &block)
+            puts("properties(#{args})")
+            if args.empty?
+              @@properties ||= PropertyDefinition::Collection.new
+              puts("@@properties => #{@@properties || 'nil'}")
+            else
+              if args.first.is_a?(Hash)
+
+              end
+            end
+            if block_given?
+              DSL.new(self).instance_eval(&block)
+            end
+            @@properties
+          end
+        end
+
+        private
+
+        class DSL
+          def initialize(base_class)
+            puts("DSL.initialize(#{base_class})")
+            @base_class = base_class
+          end
+          def string(name)
+            puts("DSL.string(#{name})")
+            @base_class.properties.add name, :string
+            @base_class.send(:define_method, "#{name}=") { |value| instance_variable_set("@#{name}", value)}
+            @base_class.send(:define_method, name) { instance_variable_get("@#{name}")}
+          end
+        end
+      end
+
+      class OpenStructWithProperties < OpenStruct
+        include HasProperties
+      end
+
+    end
+  end
+end

data/lib/active_aws/cloud_formation/template/resource.rb

@@ -0,0 +1,218 @@
+require 'active_support/core_ext' # for Hash#except
+
+require 'active_aws/cloud_formation/template/properties'
+
+module ActiveAws
+  module CloudFormation
+    class Template
+      class Resource
+        include Referrer
+
+        # These helpers have to come before the autoload below, otherwise they won't be seen by subclasses  
+        class << self
+
+          def type(type)
+          end
+          
+          # Allows us to do:
+          #
+          #    class LoadBalancer < Resource
+          #      array_attr :availability_zones
+          #
+          # Then to go:
+          #
+          #    load_balancer 'LoadBalancer' do
+          #      availability_zones 'ap-southeast-1a', 'ap-southeast-1b'
+          #
+          # Or, alternatively
+          #
+          #    load_balancer 'LoadBalancer' do
+          #      availability_zone 'ap-southeast-1a'
+          #      availability_zone 'ap-southeast-1b'          
+          def array_attr(*names)
+            names.each {|name|
+              define_method(name) do |*args|
+                if properties.key?(name)
+                  properties.store(name, properties.fetch(name).concat(args))
+                else
+                  properties.store(name, args)
+                end
+              end
+              define_method(name.to_s.singularize) do |arg|
+                if properties.key?(name)
+                  properties.fetch(name) << arg
+                else
+                  properties.store(name, [arg])
+                end
+              end
+            }
+          end
+        end
+
+        # auto-autoload, duh
+        Dir[File.expand_path('resource/*.rb', File.dirname(__FILE__))].each {|f|
+          basename = File.basename(f).chomp('.rb')
+          autoload basename.classify.to_sym, "active_aws/cloud_formation/template/resource/#{basename}"
+        }
+
+        attr_accessor :name, :type
+
+        METHOD_TYPES_MAP = {
+          auto_scaling_group: ['AWS::AutoScaling::AutoScalingGroup', AutoScalingGroup],
+          launch_config: ['AWS::AutoScaling::LaunchConfiguration', LaunchConfig],
+          ec2_instance: ['AWS::EC2::Instance', Ec2Instance ],
+          ec2_security_group: 'AWS::EC2::SecurityGroup',
+          load_balancer: ['AWS::ElasticLoadBalancing::LoadBalancer', LoadBalancer],
+          route53_record_set: 'AWS::Route53::RecordSet',
+          sqs_queue: 'AWS::SQS::Queue'
+        }
+        TYPES = METHOD_TYPES_MAP.map {|k, v|
+          [v].flatten.first # short for v.is_a?(Array) ? v[0] : v
+        }
+
+        private_class_method :new
+        
+        class << self
+
+          def build(params = {})
+            name = params[:name]
+            type = params[:type]
+            raise 'Resource name cannot be blank or empty' if name.blank?
+            raise "Resource name '#{name}' is non alphanumeric" unless name =~ /^[[:alnum:]]+$/
+            raise 'Resource type cannot be black or empty' if type.blank?
+            raise "Resource type '#{type}' unknown or not yet handled" unless TYPES.include?(type)
+            if arr = METHOD_TYPES_MAP.select {|k, v| v.is_a? Array }.find {|k, (type_name, class_ref)| type_name == type }
+              method_name, (type_name, class_ref) = arr
+              # At this point, LoadBalancer.new is also private
+              class_ref.send(:new, params)
+            else
+              # We can call new instead of Resource.send(:new, params) since we *are* Resource
+              new(params)
+            end
+          end
+
+        end
+
+        def initialize(params = {})
+          @name = params[:name] if params[:name]
+          @type = params[:type] if params[:type]
+          raise 'Resource name cannot be blank or empty' if @name.blank?
+          raise "Resource name '#{@name}' is non alphanumeric" unless @name =~ /^[[:alnum:]]+$/
+          raise 'Resource type cannot be black or empty' if @type.blank?
+          raise "Resource type '#{@type}' unknown or not yet handled" unless TYPES.include?(@type)
+          props = params.except(:name, :type)
+          unless props.empty?
+            @properties = Properties.new
+            @properties.merge!(props)
+          end
+          add_validations_based_on_type
+        end
+
+        def properties(&block)
+          @properties ||= Properties.new
+          @properties.instance_eval(&block) if block_given?
+          @properties
+        end
+
+        def to_h
+          h = { 'Type' => self.type }
+          h['Properties'] = camelize_keys(@properties) unless @properties.nil? || @properties.empty?
+          h
+        end
+
+        def camelize_keys(hash)
+          hash.each_with_object({}) {|(k, v), h|
+            key = k.is_a?(Symbol) ? k.to_s.camelize : k
+            h[key] = case 
+            when v.is_a?(Hash)
+              camelize_keys(v)
+            when v.is_a?(Array)
+              v.map {|e| e.is_a?(Hash) ? camelize_keys(e) : e }
+            else
+              v
+            end
+          }
+        end
+        
+        def method_missing(method_name, *args, &block)
+          if args.size == 1
+            properties.store(method_name, args.first)
+          elsif block_given?
+            DSLBlock.eval_using(properties, block) if block_given?
+          else
+            super
+          end
+            
+        end
+
+        # A Resource::Collection provides some convenience methods over a standard Array
+        class Collection < Array
+          def add(name, type, props = {}, &block)
+            Resource.build(name: name, type: type).tap { |resource|
+              resource.properties.merge! props
+              DSLBlock.eval_using(resource.properties, block) if block_given?
+              push resource
+            }
+          end
+          alias_method :resource, :add
+
+          # Handle this DSL method specifically
+          def load_balancer(name, options = {}, &block)
+            resource = add(name, 'AWS::ElasticLoadBalancing::LoadBalancer', options)
+            resource.instance_eval(&block) if block_given?
+            resource
+          end
+
+          METHOD_TYPES_MAP.each {|method, v|
+            unless instance_methods.include?(method)
+              if v.is_a?(Array)
+                type = [v].flatten.first # short for v.is_a?(Array) ? v[0] : v
+                module_eval <<-EOF
+                  def #{method}(name, options = {}, &block)
+                    resource = add(name, '#{type}', options)
+                    resource.instance_eval(&block) if block_given?
+                    resource
+                  end
+                EOF
+              else
+                type = v
+                # We can't use define_method because it doesn't support blocks
+                module_eval <<-EOF
+                  def #{method}(name, options = {}, &block)
+                    resource = add(name, '#{type}', options)
+                    DSLBlock.eval_using(resource.properties, block) if block_given?
+                    resource
+                  end
+                EOF
+              end
+            end
+          }
+
+          def to_h
+            each_with_object({}) {|parameter, h| h[parameter.name] = parameter.to_h }
+          end
+        end # Collection
+
+        # Resource
+        private
+
+        def validations
+          @validations ||= Hash.new
+        end
+
+        def validate(property, &block)
+          validations[:property] = block
+        end
+
+        def add_validations_based_on_type
+          case @type
+          when 'AWS::ElasticLoadBalancing::LoadBalancer'
+            validate :listeners do
+              raise "Resource '#{@name}' (AWS::ElasticLoadBalancing::LoadBalancer) Listeners cannot be empty" if listeners.empty?
+            end
+          end
+        end
+      end
+    end
+  end
+end