jackal-cfn 0.1.4 → 0.1.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4082d5d4a5132d52521ed5904e2f94aa18602848
+  data.tar.gz: d04357c2f76bf711546f6013dac469f2961842f9
+SHA512:
+  metadata.gz: 9b2206efcf53158bc40e26ab9ddb86152d815c2981f6a3fbed99a4b0ed5df2b965879652d0f069dec0b2b1c7dfa1f2b1fa6acf08e552a673599981957f952bb8
+  data.tar.gz: c209041a994159fa81d27be044178fa6ee90b2dc52de92d808652bf1670fcebb8cdb1a258dd2a38769793c04bf2c8819940c722bebdf41e97d74b6f570731e31

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# v0.1.6
+* Isolate event and resource to simple handle format and forward
+* Move builtin custom resources within new module `CfnTools`
+* Update `Resource` and `Event` to subclass gracefully
+
 # v0.1.4
 * Include ami manager resource (handle deletion of amis only for now)
 

data/lib/jackal-cfn/event.rb

@@ -5,15 +5,58 @@ module Jackal
     # Callback for event types
     class Event < Jackal::Callback
 
+      module InheritedValidity
+        # Determine message validity
+        #
+        # @param message [Carnivore::Message]
+        # @return [TrueClass, FalseClass]
+        def valid?(message)
+          super do |payload|
+            data = payload.fetch(:data, :cfn_event, Smash.new)
+            result = data[:origin_type] == 'Notification' &&
+              data[:origin_subject].to_s.downcase.include?('cloudformation notification')
+            if(result && block_given?)
+              yield payload
+            else
+              result
+            end
+          end
+        end
+
+      end
+
+      include Jackal::Cfn::Utils
+      include Jackal::Cfn::Utils::Http
+
+      # Update validity checks in subclasses
+      #
+      # @param klass [Class]
+      def self.inherited(klass)
+        klass.class_eval do
+          include InheritedValidity
+        end
+      end
+
       # Unpack message and create payload
       #
       # @param message [Carnivore::Message]
       # @return [Smash]
       def unpack(message)
         payload = super
-        payload = format_event(payload.fetch('Body', 'Message', payload))
-        payload[:origin_type] = message[:message].get('Body', 'Type')
-        payload[:origin_subject] = message[:message].get('Body', 'Subject')
+        if(self.class == Jackal::Cfn::Event)
+          begin
+            unless(payload.get(:data, :cfn_event))
+              payload = format_event(payload.fetch('Body', 'Message', payload))
+              payload[:origin_type] = message[:message].get('Body', 'Type')
+              payload[:origin_subject] = message[:message].get('Body', 'Subject')
+            end
+            payload
+          rescue
+            Smash.new
+          end
+        else
+          payload.to_smash.fetch('Body', payload.to_smash)
+        end
       end
 
       # Determine message validity
@@ -22,12 +65,11 @@ module Jackal
       # @return [TrueClass, FalseClass]
       def valid?(message)
         super do |payload|
-          result = payload[:origin_type] == 'Notification' &&
-            payload[:origin_subject].downcase.include?('cloudformation notification')
-          if(result && block_given?)
+          if(block_given?)
             yield payload
           else
-            result
+            payload[:origin_type] == 'Notification' &&
+              payload[:origin_subject].downcase.include?('cloudformation notification')
           end
         end
       end
@@ -39,8 +81,8 @@ module Jackal
       def format_event(evt)
         parts = evt.split("\n").map do |entry|
           chunks = entry.split('=')
-          key = parts.unshift.strip
-          value = parts.join.strip.sub(/^'/, '').sub(/'$/, '').strip
+          key = chunks.shift.strip
+          value = chunks.join.strip.sub(/^'/, '').sub(/'$/, '').strip
           [key, value]
         end
         event = Smash[parts]
@@ -61,13 +103,18 @@ module Jackal
       #
       # @param message [Carnivore::Message]
       def execute(message)
-        failure_wrap do |payload|
-          job_completed(
-            new_payload(
-              config[:name],
-              :cfn_event => payload
-            )
-          )
+        data_payload = unpack(message)
+        payload = new_payload(
+          config[:name],
+          :cfn_event => data_payload
+        )
+        if(config[:reprocess])
+          my_input = "#{source_prefix}_input"
+          debug "Reprocessing payload through current source (#{my_input})"
+          Carnivore::Supervisor.supervisor[my_input].transmit(payload)
+          message.confirm!
+        else
+          completed(payload, message)
         end
       end
 

data/lib/jackal-cfn/resource/ami_manager.rb

@@ -1,109 +1,111 @@
 require 'jackal-cfn'
 
 module Jackal
-  module Cfn
-    class Resource
-      # Manage AMI Resources
-      #
-      # Expected resource:
-      #   {
-      #     "Type": "Custom::AmiManager",
-      #     "Properties": {
-      #       "Parameters": {
-      #         "InstanceId": "",
-      #         "AmiId": "",
-      #         "Action": "",
-      #         "Region": ""
-      #       }
-      #     }
-      #   }
-      #
-      # Required configuration:
-      #   {
-      #     "config": {
-      #       "credentials": {
-      #         "compute": {
-      #           FOG_CREDENTIALS
-      #         }
-      #       }
-      #     }
-      #   }
-      class AmiManager < Resource
+  module CfnTools
+    # Manage AMI Resources
+    #
+    # Expected resource:
+    #   {
+    #     "Type": "Custom::AmiManager",
+    #     "Properties": {
+    #       "Parameters": {
+    #         "InstanceId": "",
+    #         "AmiId": "",
+    #         "Action": "",
+    #         "Region": ""
+    #       }
+    #     }
+    #   }
+    #
+    # Required configuration:
+    #   {
+    #     "config": {
+    #       "ami": {
+    #         "credentials": {
+    #           "compute": {
+    #             FOG_CREDENTIALS
+    #           }
+    #         }
+    #       }
+    #     }
+    #   }
+    class AmiManager < Jackal::Cfn::Resource
 
-        PHYSICAL_ID_JOINER = '__-__'
+      PHYSICAL_ID_JOINER = '__-__'
 
-        # Process message, send value back to CFN
-        #
-        # @param message [Carnivore::Message]
-        def execute(message)
-          payload = unpack(message)
-          parameters = transform_parameters(payload[:resource_properties]['Parameters'])
-          debug "Processing payload: #{payload.inspect}"
-          response = build_response(payload)
-          case payload[:request_type]
+      # Process message, send value back to CFN
+      #
+      # @param message [Carnivore::Message]
+      def execute(message)
+        failure_wrap do |payload|
+          cfn_resource = rekey_hash(payload.get(:data, :cfn_resource))
+          properties = rekey_hash(cfn_resource[:resource_properties])
+          parameters = rekey_hash(properties[:parameters])
+          cfn_response = build_response(cfn_resource)
+          case cfn_resource[:request_type]
           when :create
-            ami_response_update(response, parameters)
+            ami_response_update(cfn_response, parameters)
           when :delete
-            destroy_ami(response, payload, parameters)
+            destroy_ami(cfn_response, cfn_resource, parameters)
           when :update
           else
-            error "Unknown request type received: #{payload[:request_type].inspect}"
+            error "Unknown request type received: #{cfn_resource[:request_type].inspect}"
             response['Status'] = 'FAILED'
             response['Reason'] = 'Unknown request type received'
           end
-          respond_to_stack(response, payload[:response_url])
-          completed(
-            new_payload(
-              config.fetch(:name, :ami_manager),
-              :cfn_resource => payload
-            ),
-            message
-          )
-        end
-
-        # Update the physical resource id to include the ami id
-        #
-        # @param response [Hash] cfn response
-        # @param parameters [Hash] resource parameters
-        # @return [Hash] updated response hash
-        def ami_response_update(response, parameters)
-          response['PhysicalResourceId'] = [
-            response['PhysicalResourceId'],
-            parameters[:ami_id]
-          ].join(PHYSICAL_ID_JOINER)
-          response
+          respond_to_stack(cfn_response, cfn_resource[:response_url])
+          completed(payload, message)
         end
+      end
 
-        # Destroy the AMI referenced by the resource
-        #
-        # @param response [Hash] cfn response
-        # @param payload [Hash] message payload
-        # @param parameters [Hash] resource parameters
-        # @return [TrueClass]
-        def destroy_ami(response, payload, parameters)
-          ami_id = payload[:physical_resource_id].split(PHYSICAL_ID_JOINER).last
-          begin
-            compute_api(parameters[:region]).deregister_image(ami_id)
-          rescue Fog::Compute::AWS::Error => e
-            warn "Non-fatal error encountered on AMI removal: #{e.class}: #{e}"
-            response['Reason'] = e.message
-          rescue => e
-            error "Failed to remove AMI: #{e.class}: #{e}"
-            response['Status'] = 'FAILED'
-            response['Reason'] = e.message
-          end
-          true
-        end
+      # Update the physical resource id to include the ami id
+      #
+      # @param response [Hash] cfn response
+      # @param parameters [Hash] resource parameters
+      # @return [Hash] updated response hash
+      def ami_response_update(response, parameters)
+        response['PhysicalResourceId'] = [
+          response['PhysicalResourceId'],
+          parameters[:ami_id]
+        ].join(PHYSICAL_ID_JOINER)
+        response
+      end
 
-        # Build new compute api connection
-        #
-        # @param region [String] AWS region ami exists
-        # @return [Fog::Compute]
-        def compute_api(region)
-          Fog::Compute.new({:provider => :aws}.merge(config.fetch(:credentials, :compute, {}).merge(:region => region)))
+      # Destroy the AMI referenced by the resource
+      #
+      # @param response [Hash] cfn response
+      # @param payload [Hash] message payload
+      # @param parameters [Hash] resource parameters
+      # @return [TrueClass]
+      def destroy_ami(response, payload, parameters)
+        ami_id = payload[:physical_resource_id].split(PHYSICAL_ID_JOINER).last
+        begin
+          compute_api(parameters[:region]).deregister_image(ami_id)
+        rescue Fog::Compute::AWS::Error => e
+          warn "Non-fatal error encountered on AMI removal: #{e.class}: #{e}"
+          response['Reason'] = e.message
+        rescue => e
+          error "Failed to remove AMI: #{e.class}: #{e}"
+          response['Status'] = 'FAILED'
+          response['Reason'] = e.message
         end
+        true
+      end
 
+      # Build new compute api connection
+      #
+      # @param region [String] AWS region ami exists
+      # @return [Fog::Compute]
+      def compute_api(region)
+        Fog::Compute.new(
+          {:provider => :aws}.merge(
+            config.fetch(:ami, :credentials, :compute).merge(
+              :region => region
+            )
+          )
+        )
       end
+
     end
   end
 end

data/lib/jackal-cfn/resource/hash_extractor.rb

@@ -1,52 +1,46 @@
 require 'jackal-cfn'
 
 module Jackal
-  module Cfn
-    class Resource
-      # Extract value from hash
-      #
-      # Expected resource:
-      #   {
-      #     "Type": "Custom::HashExtractor",
-      #     "Properties": {
-      #       "Parameters": {
-      #         "Key": "path.to.value.in.hash",
-      #         "Value": Hash_or_JSON_string
-      #       }
-      #     }
-      #   }
-      class HashExtractor < Resource
+  module CfnTools
+    # Extract value from hash
+    #
+    # Expected resource:
+    #   {
+    #     "Type": "Custom::HashExtractor",
+    #     "Properties": {
+    #       "Parameters": {
+    #         "Key": "path.to.value.in.hash",
+    #         "Value": Hash_or_JSON_string
+    #       }
+    #     }
+    #   }
+    class HashExtractor < Jackal::Cfn::Resource
 
-        # Process message, send value back to CFN
-        #
-        # @param message [Carnivore::Message]
-        def execute(message)
-          payload = transform_parameters(unpack(message))
-          debug "Processing payload: #{payload.inspect}"
-          properties = transform_parameters(payload[:resource_properties])
-          cfn_response = build_response(payload)
-          parameters = transform_parameters(properties[:parameters])
+      # Process message, send value back to CFN
+      #
+      # @param message [Carnivore::Message]
+      def execute(message)
+        failure_wrap do |payload|
+          cfn_resource = rekey_hash(payload.get(:data, :cfn_resource))
+          properties = rekey_hash(cfn_resource[:resource_properties])
+          parameters = rekey_hash(properties[:parameters])
+          cfn_response = build_response(cfn_resource)
           key = parameters[:key].split('.')
           value = parameters[:value]
-          if(value.is_a?(String))
-            value = MultiJson.load(value).to_smash
+          unless(value.is_a?(String))
+            raise TypeError.new("Expecting `String` value but received `#{value.class}`")
           end
+          value = MultiJson.load(value).to_smash
           return_value = value.get(*key)
           if(return_value.is_a?(Enumerable))
             return_value = MultiJson.dump(return_value)
           end
           cfn_response['Data']['Payload'] = return_value
           respond_to_stack(cfn_response, payload[:response_url])
-          completed(
-            new_payload(
-              config.fetch(:name, :hash_extractor),
-              :cfn_resource => payload
-            ),
-            message
-          )
+          completed(payload, message)
         end
-
       end
+
     end
   end
 end

data/lib/jackal-cfn/resource.rb

@@ -5,10 +5,58 @@ module Jackal
     # Callback for resource types
     class Resource < Jackal::Callback
 
+      # Validity method for subclasses
+      module InheritedValidity
+
+        # Determine message validity
+        #
+        # @param message [Carnivore::Message]
+        # @return [TrueClass, FalseClass]
+        def valid?(message)
+          super do |payload|
+            data = payload.fetch(:data, :cfn_resource, Smash.new)
+            resource_type = data[:resource_type].to_s.split('::').last
+            result = data[:origin_type] == 'Notification' &&
+              data[:origin_subject].to_s.downcase.include?('cloudformation custom resource') &&
+              self.class.to_s.split('::').last == resource_type
+            if(result && block_given?)
+              yield payload
+            else
+              result
+            end
+          end
+        end
+
+      end
+
+      include Jackal::Cfn::Utils
+      include Jackal::Cfn::Utils::Http
+
       VALID_RESOURCE_STATUS = ['SUCCESS', 'FAILED']
 
-      autoload :HashExtractor, 'jackal-cfn/resource/hash_extractor'
-      autoload :AmiManager, 'jackal-cfn/resource/ami_manager'
+      # Update validity checks in subclasses
+      #
+      # @param klass [Class]
+      def self.inherited(klass)
+        klass.class_eval do
+          include InheritedValidity
+        end
+      end
+
+      # Determine message validity
+      #
+      # @param message [Carnivore::Message]
+      # @return [TrueClass, FalseClass]
+      def valid?(message)
+        super do |payload|
+          if(block_given?)
+            yield payload
+          else
+            payload[:origin_type] == 'Notification' &&
+              payload[:origin_subject].to_s.downcase.include?('cloudformation custom resource')
+          end
+        end
+      end
 
       # Setup the dependency requirements for the callback
       def setup(*_)
@@ -21,40 +69,30 @@ module Jackal
       # @note this should be overridden in subclasses when actual
       #   resources are being created
       def physical_resource_id
-        "#{self.class.name}-#{Celluloid.uuid}"
+        "#{self.class.name.split('::').last}-#{Celluloid.uuid}"
       end
 
       # Generate response hash
       #
-      # @param payload [Hash]
+      # @param cfn_resource [Hash]
+      # @option cfn_resource [String] :logical_resource_id
+      # @option cfn_resource [String] :physical_resource_id
+      # @option cfn_resource [String] :stack_id
+      # @option cfn_resource [String] :request_id
       # @return [Hash] default response content
-      def build_response(payload)
-        args = transform_parameters(payload)
+      def build_response(cfn_resource)
         Smash.new(
-          'LogicalResourceId' => args[:logical_resource_id],
-          'PhysicalResourceId' => args.fetch(:physical_resource_id, physical_resource_id),
-          'StackId' => args[:stack_id],
-          'RequestId' => args[:request_id],
+          'LogicalResourceId' => cfn_resource[:logical_resource_id],
+          'PhysicalResourceId' => cfn_resource.fetch(:physical_resource_id, physical_resource_id),
+          'StackId' => cfn_resource[:stack_id],
+          'RequestId' => cfn_resource[:request_id],
           'Status' => 'SUCCESS',
-          'Reason' => 'Not provided',
-          'Data' => Smash.new
+          'Data' => Smash.new(
+            'Reason' => 'None'
+          )
         )
       end
 
-      # Provide remote endpoint session for sending response
-      #
-      # @param host [String] end point host
-      # @param scheme [String] end point scheme
-      # @return [Patron::Session]
-      def response_endpoint(host, scheme)
-        session = Patron::Session.new
-        session.timeout = config.fetch(:response_timeout, 20)
-        session.connect_timeout = config.fetch(:connection_timeout, 10)
-        session.base_url = "#{scheme}://#{host}"
-        session.headers['User-Agent'] = "JackalCfn/#{Jackal::Cfn::VERSION.version}"
-        session
-      end
-
       # Send response to the waiting stack
       #
       # @param response [Hash]
@@ -93,33 +131,26 @@ module Jackal
       # @return [Smash]
       def unpack(message)
         payload = super
-        payload = Smash.new(
-          MultiJson.load(
-            payload.fetch('Body', 'Message', payload)
-          )
-        )
-        payload = transform_parameters(payload)
-        payload[:origin_type] = message[:message].get('Body', 'Type')
-        payload[:origin_subject] = message[:message].get('Body', 'Subject')
-        payload[:request_type] = snakecase(payload[:request_type])
-        payload
-      end
-
-      # Determine message validity
-      #
-      # @param message [Carnivore::Message]
-      # @return [TrueClass, FalseClass]
-      def valid?(message)
-        super do |payload|
-          resource_type = payload[:resource_type].split('::').last
-          result = payload[:origin_type] == 'Notification' &&
-            payload[:origin_subject].downcase.include?('cloudformation custom resource') &&
-            resource_type == self.class.name.split('::').last
-          if(result && block_given?)
-            yield payload
-          else
-            result
+        if(self.class == Jackal::Cfn::Resource)
+          begin
+            if(payload['Body'])
+              payload = Smash.new(
+                MultiJson.load(
+                  payload.fetch('Body', 'Message', payload)
+                )
+              )
+              payload = transform_parameters(payload)
+              payload[:origin_type] = message[:message].get('Body', 'Type')
+              payload[:origin_subject] = message[:message].get('Body', 'Subject')
+              payload[:request_type] = snakecase(payload[:request_type])
+            end
+            payload
+          rescue MultiJson::ParseError
+            # Not our expected format so return empty payload
+            Smash.new
           end
+        else
+          payload.to_smash.fetch('Body', payload.to_smash)
         end
       end
 
@@ -127,36 +158,20 @@ module Jackal
       #
       # @param message [Carnivore::Message]
       def execute(message)
-        failure_wrap(message) do |payload|
-          job_completed(
-            new_payload(
-              config[:name],
-              :cfn_resource => payload
-            )
-          )
-        end
-      end
-
-      # Snake case top level keys in hash
-      #
-      # @param params [Hash]
-      # @return [Hash] new hash with snake cased toplevel keys
-      def transform_parameters(params)
-        Smash.new.tap do |new_hash|
-          params.each do |key, value|
-            new_hash[snakecase(key)] = value
-          end
+        data_payload = unpack(message)
+        payload = new_payload(
+          config[:name],
+          :cfn_resource => data_payload
+        )
+        if(config[:reprocess])
+          my_input = "#{source_prefix}_input"
+          Carnivore::Supervisor.supervisor[my_input].transmit(payload)
+          message.confirm!
+        else
+          completed(payload, message)
         end
       end
 
-      # Snake case string
-      #
-      # @param v [String]
-      # @return [Symbol]
-      def snakecase(v)
-        v.to_s.gsub(/(?<![A-Z])([A-Z])/, '_\1').sub(/^_/, '').downcase.to_sym
-      end
-
     end
   end
 end

data/lib/jackal-cfn/utils/fog.rb

@@ -0,0 +1,78 @@
+require 'jackal-cfn'
+
+module Jackal
+  module Cfn
+    module Utils
+      # Helper module for loading Fog APIs
+      module Fog
+
+        include Utils
+
+        # Provide API for given type
+        #
+        # @param type [Symbol] Fog API (compute, orchestration, etc)
+        # @return [Fog::Service]
+        # @note extracts credentials from confg at :api -> [type | :default]
+        def api_for(type)
+          klass = Fog.constants.detect do |const|
+            snakecase(const).to_s == type.to_s
+          end
+          if(klass)
+            credentials = config.fetch(
+              :api, type, config.get(
+                :api, :default
+              )
+            )
+            if(credentials)
+              key = credentials.to_a.flatten.push(klass).sort.hash
+              Thread.current[:cfn_apis] ||= Smash.new
+              unless(Thread.current[:cfn_apis][key])
+                Thread.current[:cfn_apis][key] = Fog.const_get(klass).new(credentials)
+              end
+              Thread.current[:cfn_apis][key]
+            else
+              ArgumentError.new 'No credentials provided in configuration!'
+            end
+          else
+            raise TypeError.new "Unknown API type requested (#{type})"
+          end
+        end
+
+        # Assume the role for the API connection
+        #
+        # @param api [Fog::Service]
+        # @param role [String] name of role to assume
+        # @return [Fog::Service] assumed service
+        # @note this is AWS specific
+        def api_assume_for(api, role)
+          Thread.current[:cfn_assume_apis] ||= Smash.new
+          key = api.to_yaml_properties.group_by do |item|
+            item.to_s.split('_').first
+          end.values.sort_by(&:size).last.map do |var|
+            [var, api.instance_variable_get(var)]
+          end.flatten.compact.map(&:to_s).push(api.service_name).sort.hash
+          if(Thread.current[:cfn_assume_apis].get(key, :expires).to_i < Time.now.to_i + 5)
+            sts = Fog::AWS::STS.new(
+              config.fetch(
+                :api, :sts, config.get(
+                  :api, :default
+                )
+              )
+            )
+            result = sts.assume_role("jackal-cfn-#{Celluloid.uuid}", role).body
+            Thread.current[:cfn_assume_apis][key] = Smash.new(
+              :expires => Time.parse(result['Expiration']).to_i,
+              :api => api.class.new(
+                :aws_access_key_id => result['AccessKeyId'],
+                :aws_secret_access_key => result['SecretAccessKey'],
+                :aws_session_token => result['SessionToken']
+              )
+            )
+          end
+          Thread.current[:cfn_assume_apis].get(key, :api)
+        end
+
+      end
+    end
+  end
+end

data/lib/jackal-cfn/utils/http.rb

@@ -0,0 +1,29 @@
+require 'patron'
+require 'jackal-cfn'
+
+module Jackal
+  module Cfn
+    module Utils
+      # Helper module for HTTP interactions
+      module Http
+
+        # Provide remote endpoint session for sending response
+        #
+        # @param host [String] end point host
+        # @param scheme [String] end point scheme
+        # @return [Patron::Session]
+        def response_endpoint(host, scheme)
+          session = Patron::Session.new
+          session.timeout = config.fetch(:response_timeout, 20)
+          session.connect_timeout = config.fetch(:connection_timeout, 10)
+          session.base_url = "#{scheme}://#{host}"
+          session.headers['User-Agent'] = "JackalCfn/#{Jackal::Cfn::VERSION.version}"
+          session
+        end
+        alias_method :http_endpoint, :response_endpoint
+
+      end
+
+    end
+  end
+end

data/lib/jackal-cfn/utils.rb

@@ -0,0 +1,33 @@
+require 'jackal-cfn'
+
+module Jackal
+  module Cfn
+    module Utils
+
+      autoload :Fog, 'jackal-cfn/utils/fog'
+      autoload :Http, 'jackal-cfn/utils/http'
+
+      # Snake case top level keys in hash
+      #
+      # @param params [Hash]
+      # @return [Hash] new hash with snake cased toplevel keys
+      def transform_parameters(params)
+        Smash.new.tap do |new_hash|
+          params.each do |key, value|
+            new_hash[snakecase(key)] = value
+          end
+        end
+      end
+      alias_method :rekey_hash, :transform_parameters
+
+      # Snake case string
+      #
+      # @param v [String]
+      # @return [Symbol]
+      def snakecase(v)
+        v.to_s.gsub(/(?<![A-Z])([A-Z])/, '_\1').sub(/^_/, '').downcase.to_sym
+      end
+
+    end
+  end
+end

data/lib/jackal-cfn/version.rb

@@ -1,6 +1,6 @@
 module Jackal
   module Cfn
     # Current version
-    VERSION = Gem::Version.new('0.1.4')
+    VERSION = Gem::Version.new('0.1.6')
   end
 end

data/lib/jackal-cfn.rb

@@ -6,5 +6,12 @@ module Jackal
   module Cfn
     autoload :Event, 'jackal-cfn/event'
     autoload :Resource, 'jackal-cfn/resource'
+    autoload :Utils, 'jackal-cfn/utils'
+  end
+
+  # Tools
+  module CfnTools
+    autoload :HashExtractor, 'jackal-cfn/resource/hash_extractor'
+    autoload :AmiManager, 'jackal-cfn/resource/ami_manager'
   end
 end

metadata

@@ -1,46 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: jackal-cfn
 version: !ruby/object:Gem::Version
-  version: 0.1.4
-  prerelease: 
+  version: 0.1.6
 platform: ruby
 authors:
 - Chris Roberts
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-07 00:00:00.000000000 Z
+date: 2014-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jackal
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: patron
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: CFN callback helpers
@@ -49,41 +44,43 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
+- CONTRIBUTING.md
+- LICENSE
+- README.md
+- jackal-cfn.gemspec
 - lib/jackal-cfn.rb
 - lib/jackal-cfn/event.rb
-- lib/jackal-cfn/version.rb
 - lib/jackal-cfn/resource.rb
-- lib/jackal-cfn/resource/hash_extractor.rb
 - lib/jackal-cfn/resource/ami_manager.rb
-- jackal-cfn.gemspec
-- README.md
-- CHANGELOG.md
-- CONTRIBUTING.md
-- LICENSE
+- lib/jackal-cfn/resource/hash_extractor.rb
+- lib/jackal-cfn/utils.rb
+- lib/jackal-cfn/utils/fog.rb
+- lib/jackal-cfn/utils/http.rb
+- lib/jackal-cfn/version.rb
 homepage: https://github.com/carnivore-rb/jackal-cfn
 licenses:
 - Apache 2.0
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Message processing helper
 test_files: []
 has_rdoc: