jets 0.7.1 → 0.8.0

data/lib/jets/job.rb

@@ -1,5 +1,4 @@
 class Jets::Job
   autoload :Dsl, "jets/job/dsl"
   autoload :Base, "jets/job/base"
-  autoload :Task, "jets/job/task"
 end

data/lib/jets/job/dsl.rb

@@ -1,57 +1,75 @@
 # Jets::Job::Base < Jets::Lambda::Functions
 # Both Jets::Job::Base and Jets::Lambda::Functions have Dsl modules included.
 # So the Jets::Job::Dsl overrides some of the Jets::Lambda::Functions behavior.
+#
+# Implements:
+#   default_associated_resource: must return @resources
 module Jets::Job::Dsl
   extend ActiveSupport::Concern
 
   included do
     class << self
       def rate(expression)
-        @rate = expression
+        update_properties(schedule_expression: "rate(#{expression})")
       end
 
       def cron(expression)
-        @cron = expression
+        update_properties(schedule_expression: "cron(#{expression}")
       end
 
-      # Explicitly disable scheduling for the function
-      def disable(value)
-        @disable = value
+      def event_pattern(details={})
+        event_rule(event_pattern: details)
+        add_descriptions # useful: generic description in the Event Rule console
       end
 
-      # This is a property of the AWS::Events::Rule not the Lambda function
-      def state(value)
-        @state = value
+      def add_descriptions
+        numbered_resources = []
+        n = 1
+        @resources.map do |definition|
+          logical_id = definition.keys.first
+          attributes = definition.values.first
+          attributes[:properties][:description] = "#{self.name} Event Rule #{n}"
+          numbered_resources << { "#{logical_id}" => attributes }
+          n += 1
+        end
+        @resources = numbered_resources
       end
 
-      # Override register_task.
-      # A Job::Task is a Lambda::Task with some added DSL methods like
-      # rate and cron.
-      def register_task(meth, lang=:ruby)
-        if @rate || @cron || @disable
-          # Job lambda function.
-          all_tasks[meth] = Jets::Job::Task.new(self.name, meth,
-            rate: @rate,
-            cron: @cron,
-            state: @state,
-            properties: @properties,
-            lang: lang)
-          true
-        else
-          task_name = "#{name}##{meth}" # IE: HardJob#dig
-          puts "[WARNING] #{task_name} created without a rate or cron expression. " \
-            "Add a rate or cron expression above the method definition if you want this method to be scheduled. " \
-            "If #{task_name} is not meant to be a scheduled lambda function, you can put the method under after a private keyword to get rid of this warning. " \
-            "#{task_name} defined at #{caller[1].inspect}."
-          false
-        end
-        # Done storing options, clear out for the next added method.
-        clear_properties
+      def default_associated_resource
+        event_rule
+        @resources # must return @resoures for update_properties
       end
 
-      def clear_properties
-        super
-        @rate, @cron, @state, @disable = nil, nil, nil, nil
+      def event_rule(props={})
+        default_props = {
+          state: "ENABLED",
+          targets: [{
+            arn: "!GetAtt {namespace}LambdaFunction.Arn",
+            id: "{namespace}RuleTarget"
+          }]
+        }
+        properties = default_props.deep_merge(props)
+
+        resource("{namespace}EventsRule" => {
+          type: "AWS::Events::Rule",
+          properties: properties
+        })
+
+        add_logical_id_counter if @resources.size > 1
+      end
+
+      # Loop back through the resources and add a counter to the end of the id
+      # to handle multiple events.
+      # Then replace @resources entirely
+      def add_logical_id_counter
+        numbered_resources = []
+        n = 1
+        @resources.map do |definition|
+          logical_id = definition.keys.first
+          numbered_resources << { "#{logical_id}#{n}" => definition.values.first }
+          n += 1
+        end
+        @resources = numbered_resources
       end
     end
   end

data/lib/jets/lambda/dsl.rb

@@ -1,3 +1,5 @@
+# Other dsl that rely on this must implement
+#   default_associated_resource: must return @resources
 module Jets::Lambda::Dsl
   extend ActiveSupport::Concern
 
@@ -120,6 +122,44 @@ module Jets::Lambda::Dsl
         !!(class_iam_policy || class_managed_iam_policy)
       end
 
+      #############################
+      # Generic method that registers a resource to be associated with the Lambda function.
+      # In the future all DSL methods can lead here.
+      def resources(*definitions)
+        if definitions == [nil] # when resources called with no arguments
+          @resources || []
+        else
+          @resources ||= []
+          @resources += definitions
+          @resources.flatten!
+        end
+      end
+      alias_method :resource, :resources
+
+      # Main method that the convenience methods call for to create resources associated
+      # with the Lambda function. References the first resource and updates it inplace.
+      # Useful for associated resources that are meant to be declare and associated
+      # with only one Lambda function. Example:
+      #
+      #   Config Rule <=> Lambda function is 1-to-1
+      #
+      # Note: This methods calls default_associated_resource. The inheriting DSL class
+      # must implement default_associated_resource. The default_associated_resource should
+      # wrap another method that is nicely name so that the nicely name method is
+      # available in the DSL. Example:
+      #
+      #   def default_associated_resource
+      #     config_rule
+      #   end
+      #
+      def update_properties(values={})
+        @resources ||= default_associated_resource
+        definition = @resources.first # singleton
+        attributes = definition.values.first
+        attributes[:properties].merge!(values)
+        @resources
+      end
+
       # meth is a Symbol
       def method_added(meth)
         return if %w[initialize method_missing].include?(meth.to_s)
@@ -133,7 +173,8 @@ module Jets::Lambda::Dsl
         # We adjust the class name when we build the functions later in
         # FunctionContstructor#adjust_tasks.
         all_tasks[meth] = Jets::Lambda::Task.new(self.name, meth,
-          properties: @properties,
+          resources: @resources, # associated resources
+          properties: @properties, # lambda function properties
           iam_policy: @iam_policy,
           managed_iam_policy: @managed_iam_policy,
           lang: lang)
@@ -152,6 +193,7 @@ module Jets::Lambda::Dsl
       end
 
       def clear_properties
+        @resources = nil
         @properties = nil
         @iam_policy = nil
         @managed_iam_policy = nil

data/lib/jets/lambda/task.rb

@@ -1,11 +1,12 @@
 class Jets::Lambda::Task
   attr_accessor :class_name, :type
-  attr_reader :meth, :properties, :iam_policy, :managed_iam_policy, :lang
+  attr_reader :meth, :resources, :properties, :iam_policy, :managed_iam_policy, :lang
   def initialize(class_name, meth, options={})
     @class_name = class_name.to_s # use at EventsRuleMapper#full_task_name
     @meth = meth
     @options = options
     @type = options[:type] || get_type  # controller, job, or function
+    @resources = options[:resources] || {}
     @properties = options[:properties] || {}
     @iam_policy = options[:iam_policy]
     @managed_iam_policy = options[:managed_iam_policy]

data/lib/jets/pascalize.rb

@@ -4,14 +4,14 @@ module Jets
       # Specialized pascalize that will not pascalize keys under the
       # Variables part of the hash structure.
       # Based on: https://stackoverflow.com/questions/8706930/converting-nested-hash-keys-from-camelcase-to-snake-case-in-ruby
-      def pascalize(value, parent_key=nil)
+      def pascalize(value, parent_keys=[])
         case value
           when Array
             value.map { |v| pascalize(v) }
           when Hash
             initializer = value.map do |k, v|
-              new_key = pascal_key(k, parent_key)
-              [new_key, pascalize(v, new_key)]
+              new_key = pascal_key(k, parent_keys)
+              [new_key, pascalize(v, parent_keys+[new_key])]
             end
             Hash[initializer]
           else
@@ -19,14 +19,32 @@ module Jets
          end
       end
 
-      def pascal_key(k, parent_key=nil)
-        if parent_key == "Variables" # do not pascalize keys anything under Variables
-          k
+      def pascal_key(k, parent_keys=[])
+        k = k.to_s
+        if parent_keys.include?("Variables") # do not pascalize keys anything under Variables
+          k # pass through untouch
+        elsif parent_keys.include?("ResponseParameters")
+          k # pass through untouch
+        elsif k.include?('-') || k.include?('/')
+          k # pass through untouch
+        elsif parent_keys.last == "EventPattern" # top-level
+          k.dasherize
+        elsif parent_keys.include?("EventPattern")
+          # any keys at 2nd level under EventPattern will be camelize
+          new_k = k.camelize # an earlier pascalize has made the first char upcase
+          # so we need to downcase it again
+          first_char = new_k[0..0].downcase
+          new_k[0] = first_char
+          new_k
         else
-          k = k.to_s.camelize
-          k.slice(0,1).capitalize + k.slice(1..-1) # capitalize first letter only
+          pascalize_string(k)
         end
       end
+
+      def pascalize_string(s)
+        s = s.to_s.camelize
+        s.slice(0,1).capitalize + s.slice(1..-1) # capitalize first letter only
+      end
     end
   end
 end

data/lib/jets/resource.rb

@@ -0,0 +1,7 @@
+module Jets::Resource
+  autoload :Attributes, 'jets/resource/attributes'
+  autoload :Creator, 'jets/resource/creator'
+  autoload :Permission, 'jets/resource/permission'
+  autoload :Replacer, 'jets/resource/replacer'
+  autoload :Route, 'jets/resource/route'
+end

data/lib/jets/resource/attributes.rb

@@ -0,0 +1,46 @@
+module Jets::Resource
+  class Attributes
+    extend Memoist
+
+    def initialize(data, task, replacements={})
+      @data = data
+      @task = task
+      @replacements = replacements
+    end
+
+    def logical_id
+      id = @data.keys.first
+      # replace possible {namespace} in the logical id
+      id = replacer.replace_value(id)
+      Jets::Pascalize.pascalize_string(id)
+    end
+
+    def type
+      attributes['Type']
+    end
+
+    def properties
+      attributes['Properties']
+    end
+
+    def attributes
+      attributes = @data.values.first
+      attributes = replacer.replace_placeholders(attributes, @replacements)
+      Jets::Pascalize.pascalize(attributes)
+    end
+
+    def replacer
+      # Use raw @data to avoid infinite loop from using attributes
+      attributes = Jets::Pascalize.pascalize(@data.values.first)
+      type = attributes['Type']
+      replacer_class = Replacer.lookup(type)
+      replacer_class.new(@task)
+    end
+    memoize :replacer
+
+    def permission
+      Permission.new(@task, self)
+    end
+    memoize :permission
+  end
+end

data/lib/jets/resource/creator.rb

@@ -0,0 +1,17 @@
+module Jets::Resource
+  class Creator
+    extend Memoist
+
+    def initialize(definition, task)
+      @definition = definition
+      @task = task # task that the definition belongs to
+    end
+
+    # Template snippet that gets injected into the CloudFormation template.
+    def attributes
+      Attributes.new(@definition, @task)
+    end
+    alias_method :resource, :attributes
+    memoize :attributes
+  end
+end

data/lib/jets/resource/permission.rb

@@ -0,0 +1,43 @@
+module Jets::Resource
+  class Permission
+    extend Memoist
+
+    def initialize(task, resource)
+      @task = task
+      @resource_attributes = resource
+    end
+
+    def attributes
+      logical_id = "{namespace}Permission"
+      md = @resource_attributes.logical_id.match(/(\d+)/)
+      if md
+        counter = md[1]
+      end
+      logical_id = [logical_id, counter].compact.join('')
+
+      attributes = {
+        logical_id => {
+          type: "AWS::Lambda::Permission",
+          properties: {
+            function_name: "!GetAtt {namespace}LambdaFunction.Arn",
+            action: "lambda:InvokeFunction",
+            principal: principal,
+            source_arn: source_arn,
+          }
+        }
+      }
+      Attributes.new(attributes, @task)
+    end
+    memoize :attributes
+
+    # Auto-detect principal from the associated resources.
+    def principal
+      Replacer.principal_map(@resource_attributes.type)
+    end
+
+    def source_arn
+      default_arn = "!GetAtt #{@resource_attributes.logical_id}.Arn"
+      Replacer.source_arn_map(@resource_attributes.type) || default_arn
+    end
+  end
+end

data/lib/jets/resource/replacer.rb

@@ -0,0 +1,40 @@
+module Jets::Resource
+  module Replacer
+    autoload :Base, 'jets/resource/replacer/base'
+    autoload :ConfigRule, 'jets/resource/replacer/config_rule'
+    # TODO: handle autoloading for plugins
+
+    class << self
+      def lookup(type)
+        klass = replacer_map[type] || "Jets::Resource::Replacer::Base"
+        klass.constantize
+      end
+
+      # Maps
+      # TODO: get rid of this map, and use a convention
+      # * connect a plugin to figure out interface.
+      # * add ability to explicitly override principal and source_arn.
+      def replacer_map
+        {
+          "AWS::Config::ConfigRule" => "Jets::Resource::Replacer::ConfigRule"
+        }
+      end
+
+      # Examples:
+      #   "AWS::Events::Rule" => "events.amazonaws.com",
+      #   "AWS::Config::ConfigRule" => "config.amazonaws.com",
+      #   "AWS::ApiGateway::Method" => "apigateway.amazonaws.com"
+      def principal_map(type)
+        service = type.split('::')[1].downcase
+        "#{service}.amazonaws.com"
+      end
+
+      def source_arn_map(type)
+        map = {
+          "AWS::ApiGateway::Method" => "!Sub arn:aws:execute-api:${AWS::Region}:${AWS::AccountId}:${RestApi}/*/*",
+        }
+        map[type]
+      end
+    end
+  end
+end

data/lib/jets/resource/replacer/base.rb

@@ -0,0 +1,98 @@
+module Jets::Resource::Replacer
+  class Base
+    extend Memoist
+
+    def initialize(task)
+      @task = task
+      @app_class = task.class_name.to_s
+    end
+
+    # Replace placeholder hash values with replacements.  This does a deep replacement
+    # to the hash values.  The replacement "key" is the string value within the value.
+    #
+    # Example:
+    #
+    #   attributes = {whatever: "foo REPLACE_KEY bar" }
+    #   replace_placeholders(attributes, REPLACE_KEY: "blah:arn")
+    #   => {whatever: "foo blah:arn bar" }
+    #
+    # Also, we always replace the special {namespace} value in the hash values. Example:
+    #
+    #   attributes = {whatever: "{namespace}LambdaFunction" }
+    #   replace_placeholders(attributes, {})
+    #   => {whatever: "foo PostsControllerIndexLambdaFunction bar" }
+    #
+    def replace_placeholders(attributes, replacements={})
+      update_values(attributes, replacements)
+    end
+
+    def update_values(original, replacements={})
+      case original
+      when Array
+        original.map { |v| update_values(v, replacements) }
+      when Hash
+        initializer = original.map do |k, v|
+          [k, update_values(v, replacements)]
+        end
+        Hash[initializer]
+      else
+        replace_value(original, replacements)
+      end
+    end
+
+    def replace_value(text, replacements={})
+      text = text.to_s # normalize to String
+      # custom replacements
+      replacements.each do |k,v|
+        text = text.gsub(k.to_s, v)
+      end
+      # Values to always replace
+      text = replace_core_values(text)
+      text
+    end
+
+    # Values to always replace.
+    def replace_core_values(text)
+      text = text.gsub('{namespace}', namespace) # always replace namespace
+      core_replacements.each do |k,v|
+        text = text.gsub("{#{k}}", v)
+      end
+      text
+    end
+
+    # Meant to beoverriden by different resource types in the child class.
+    # These values replace the variables in the resource template.
+    #
+    # Example:
+    #
+    # In child class:
+    #
+    #   def core_replacements
+    #     { config_rule_name: "my-config-rule" }
+    #   end
+    #
+    # And we declare these properties in the resource:
+    #
+    #   properties: {
+    #     config_rule_name: "{config_rule_name}",
+    #   ...
+    #
+    # The replacements result in:
+    #
+    #   properties: {
+    #     config_rule_name: "my-config-rule",
+    #   ...
+    #
+    def core_replacements
+      {}
+    end
+
+    # Full camelized namespace
+    # Example: HardJobDig, PostsControllerIndex, SleepJobPerform
+    def namespace
+      class_name = @task.class_name.gsub('::','')
+      function_name = @task.meth.to_s.camelize
+      "#{class_name}#{function_name}"
+    end
+  end
+end