jets 4.0.12 → 5.0.0.beta1

data/lib/jets/job/dsl/rule_event.rb

@@ -27,16 +27,19 @@ module Jets::Job::Dsl
     end
 
     def schedule_job(expression, props={})
-      props = props.merge(schedule_expression: expression)
+      props = props.merge(ScheduleExpression: expression)
       rule_event(props)
     end
 
     def rule_event(props={})
+      # detail should all be lowercase: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-rule.html
+      # source should also all be lowercase
       if props.key?(:detail)
+        # :description should be lowercased. It's a convenience property, and belongs at a higher level
         description = props.key?(:description) ? props.delete(:description) : rule_description
-        rule_props = { event_pattern: props, description: description }
+        rule_props = { EventPattern: props, Description: description }
       else # if props.key?(:event_pattern)
-        props[:description] ||= rule_description
+        props[:Description] ||= rule_description
         rule_props = props
       end
 
@@ -52,7 +55,7 @@ module Jets::Job::Dsl
     end
 
     def events_rule_definition
-      resource = Jets::Resource::Events::Rule.new(associated_properties)
+      resource = Jets::Cfn::Resource::Events::Rule.new(associated_properties)
       resource.definition # returns a definition to be added by associated_resources
     end
 

data/lib/jets/job/dsl/s3_event.rb

@@ -2,7 +2,7 @@ module Jets::Job::Dsl
   module S3Event
     def s3_event(bucket_name, props={})
       stack_name = declare_s3_bucket_resources(bucket_name) # only set up once per bucket
-      declare_sns_subscription(topic_arn: "!Ref #{stack_name}SnsTopic") # set up subscription every time
+      declare_sns_subscription(TopicArn: "!Ref #{stack_name}SnsTopic") # set up subscription every time
     end
 
     # Returns stack_name

data/lib/jets/job/dsl/sns_event.rb

@@ -4,22 +4,22 @@ module Jets::Job::Dsl
       if topic_name.to_s =~ /generate/
         declare_sns_topic(props.delete(:topic_properties))
         topic_arn = "!Ref {namespace}SnsTopic"
-        props.merge!(topic_arn: topic_arn)
+        props.merge!(TopicArn: topic_arn)
         declare_sns_subscription(props)
       elsif topic_name.include?('!Ref') # reference shared resource
         topic_arn = topic_name # contains !Ref
-        props.merge!(topic_arn: topic_arn)
+        props.merge!(TopicArn: topic_arn)
         declare_sns_subscription(props)
       else # existing topic: short name or full arn
         topic_arn = full_sns_topic_arn(topic_name)
-        props.merge!(topic_arn: topic_arn)
+        props.merge!(TopicArn: topic_arn)
         declare_sns_subscription(props)
       end
     end
 
     def declare_sns_topic(props={})
       props ||= {} # props.delete(:topic_properties) can be nil
-      r = Jets::Resource::Sns::Topic.new(props)
+      r = Jets::Cfn::Resource::Sns::Topic.new(props)
       with_fresh_properties do
         resource(r.definition) # add associated resource immediately
       end
@@ -27,14 +27,14 @@ module Jets::Job::Dsl
 
     def declare_sns_topic_policy(props={})
       props ||= {} # options.delete(:topic_policy_properties) can be nil
-      r = Jets::Resource::Sns::TopicPolicy.new(props)
+      r = Jets::Cfn::Resource::Sns::TopicPolicy.new(props)
       with_fresh_properties do
         resource(r.definition) # add associated resource immediately
       end
     end
 
     def declare_sns_subscription(props={})
-      r = Jets::Resource::Sns::Subscription.new(props)
+      r = Jets::Cfn::Resource::Sns::Subscription.new(props)
       with_fresh_properties do
         resource(r.definition) # add associated resource immediately
       end

data/lib/jets/job/dsl/sqs_event.rb

@@ -20,14 +20,14 @@
 #   class_timeout 30 # must be less than or equal to the SQS queue default timeout
 #
 #   event_source_mapping(
-#     event_source_arn: "arn:aws:sqs:us-west-2:112233445566:hello-queue",
+#     EventSourceArn: "arn:aws:sqs:us-west-2:112233445566:hello-queue",
 #   )
 #   iam_policy(
-#     action: ["sqs:ReceiveMessage",
-#             "sqs:DeleteMessage",
-#             "sqs:GetQueueAttributes"],
-#     effect: "Allow",
-#     resource: "arn:aws:sqs:us-west-2:112233445566:hello-queue",
+#     Action: ["sqs:ReceiveMessage",
+#              "sqs:DeleteMessage",
+#              "sqs:GetQueueAttributes"],
+#     Effect: "Allow",
+#     Resource: "arn:aws:sqs:us-west-2:112233445566:hello-queue",
 #   )
 #   def dig
 #     puts "dig event #{JSON.dump(event)}"
@@ -57,7 +57,7 @@ module Jets::Job::Dsl
 
       props = options # by this time options only has EventSourceMapping properties
       default = {
-        event_source_arn: queue_arn
+        EventSourceArn: queue_arn
       }
       props = default.merge(props)
 
@@ -66,7 +66,7 @@ module Jets::Job::Dsl
 
     def declare_sqs_queue(props)
       props ||= {} # since options.delete(:queue_properties) can be nil
-      r = Jets::Resource::Sqs::Queue.new(props)
+      r = Jets::Cfn::Resource::Sqs::Queue.new(props)
       with_fresh_properties do
         resource(r.definition) # add associated resource immediately
       end
@@ -85,11 +85,11 @@ module Jets::Job::Dsl
 
     def default_sqs_iam_policy(queue_name_arn='*')
       {
-        action: ["sqs:ReceiveMessage",
+        Action: ["sqs:ReceiveMessage",
                  "sqs:DeleteMessage",
                  "sqs:GetQueueAttributes"],
-        effect: "Allow",
-        resource: queue_name_arn,
+        Effect: "Allow",
+        Resource: queue_name_arn,
       }
     end
   end

data/lib/jets/klass.rb

@@ -17,10 +17,10 @@
 #   Jets::Klass.from_path("app/functions/hello_function.rb")
 #   Jets::Klass.from_path("app/shared/functions/whatever.rb")
 #
-#   Jets::Klass.from_task(task)
+#   Jets::Klass.from_definition(definition)
 #
-# The from_task method takes a Jets::Lambda::Task as an argument and is useful
-# for the CloudFormation child stack generation there the registered task info
+# The from_definition method takes a Jets::Lambda::Definition as an argument and is useful
+# for the CloudFormation child stack generation there the registered definition info
 # is available but the path info is now.
 class Jets::Klass
   class << self
@@ -46,8 +46,8 @@ class Jets::Klass
     end
 
     APP_TYPES = %w[controller job rule authorizer]
-    def from_task(task)
-      class_name = task.class_name
+    def from_definition(definition)
+      class_name = definition.class_name
       filename = class_name.underscore
 
       # Examples of filename: posts_controller, hard_job, security_rule, main_authorizer
@@ -89,7 +89,6 @@ class Jets::Klass
     def modularize(class_name)
       leaves = []
       mods = class_name.split('::')[0..-2] # drop the last word
-      # puts "mods: #{mods}"
       return Object if mods.empty?
 
       leaves = []

data/lib/jets/lambda/definition.rb

@@ -0,0 +1,118 @@
+module Jets::Lambda
+  class Definition
+    include Jets::Util::Camelize
+
+    attr_accessor :class_name, :type
+    attr_reader :meth, :properties, :iam_policy, :managed_iam_policy, :lang, :associated_resources
+    def initialize(class_name, meth, options={})
+      @class_name = class_name.to_s
+      @meth = meth
+      @options = options
+      @type = options[:type] || get_type  # controller, job, or function
+      @properties = camelize(options[:properties]) || {}
+      @iam_policy = options[:iam_policy]
+      @managed_iam_policy = options[:managed_iam_policy]
+      @lang = options[:lang] || :ruby
+      @associated_resources = options[:associated_resources] || {}
+      @replacements = options[:replacements] || {} # added to baseline replacements
+    end
+
+    def name
+      @meth
+    end
+
+    def public_meth?
+      # For anonymous classes (app/functions/hello.rb) the class name will be blank.
+      # These types of classes are treated specially and has only one handler method
+      # that is registered. So we know it is public.
+      return true if @class_name.nil? || @class_name == ''
+
+      # Consider all polymorphic methods public for now
+      return true if @lang != :ruby
+
+      klass = @class_name.constantize
+      public_methods = klass.public_instance_methods
+      public_methods.include?(meth.to_sym)
+    end
+
+    def build_function_iam?
+      !!(@iam_policy || @managed_iam_policy)
+    end
+
+    @@lang_exts = {
+      ruby: '.rb',
+      python: '.py',
+      node: '.js',
+    }
+    def lang_ext
+      @@lang_exts[@lang]
+    end
+
+    # The get_type method works for controller and job classes.
+    #
+    # Usually able to get the type from the class name. Examples:
+    #
+    #   PostsController => controller
+    #   HardJob => job
+    #
+    # However, for function types, we are not able to get the type for multiple of
+    # reasons.  First, function types are allowed to be named with or without
+    # _function.  Examples:
+    #
+    #   path => class => type
+    #   app/functions/hello.rb => Hello => function
+    #   app/functions/hello_function.rb => HelloFunction => function
+    #
+    # The second reason is that functions are not regular ruby classes. Instead they
+    # are anonymous classes created with Class.new.  When classes are created with
+    # Class.new the method_added hook has "" (blank string) as the self class name.
+    # We add the class_type to the task later on as we are constructing the class
+    # as part of the Class.new logic.
+    #
+    # For controller and job standard ruby classes though it can easily be
+    # determinated as part of initialization. So we get the type for convenience then.
+    #
+    # For anonymous function classes, we just set to nil and will later fix in
+    # FunctionConstructor.
+    #
+    # Returns: "controller", "job" or nil
+    def get_type
+      unless @class_name.empty? # when anonymous class is created with Class.new
+        @class_name.underscore.split('_').last # controller, job or rule
+      end
+    end
+
+    def full_handler(handler_function)
+      "#{handler_base}.#{handler_function}"
+    end
+
+    def handler_path
+      "#{handler_base}#{lang_ext}"
+    end
+
+    def handler_base
+      base = "handlers/#{@type.pluralize}/#{@class_name.underscore}"
+      base += "/#{@lang}" if @lang != :ruby
+      base += "/#{@meth}"
+    end
+
+    def poly_src_path
+      handler_path.sub("handlers/", "app/")
+    end
+
+    def replacements
+      # Merge in the custom replacements specific to each app class: ConfigRule, Job, etc.
+      base_replacements.merge(@replacements)
+    end
+
+    def base_replacements
+      { namespace: namespace }
+    end
+
+    def namespace
+      ns = @class_name.gsub('::','').camelize
+      ns += @meth.to_s.camelize if @meth
+      ns
+    end
+  end
+end

data/lib/jets/lambda/dsl/warnings.rb

@@ -0,0 +1,57 @@
+module Jets::Lambda::Dsl
+  module Warnings
+    def iam_policy_unused_warning(managed=false)
+      return unless show_iam_policy_unused_warning?
+
+      managed_prefix = managed ? "managed_" : ""
+      use_instead = case Jets.config.cfn.build.controllers
+                    when "one_lambda_per_contoller"
+                      "class_#{managed_prefix}iam_policy"
+                    when "one_lambda_for_all_controllers"
+                      "class_#{managed_prefix}iam_policy in the ApplicationController"
+                    end
+      puts <<~EOL.color(:yellow)
+        WARNING: #{managed_prefix}iam_policy is not respected when config.cfn.build.controllers is not set to "one_lambda_per_controller"
+        Current setting: config.cfn.build.controllers = "#{Jets.config.cfn.build.controllers}"
+        Please use #{use_instead} instead.
+        Docs: #{iam_docs_url(managed)}
+      EOL
+
+      DslEvaluator.print_code(app_call_line) if app_call_line
+    end
+
+    def class_iam_policy_unused_warning(managed=false)
+      return unless Jets.config.cfn.build.controllers == "one_lambda_for_all_controllers"
+      return if self.to_s == "ApplicationController" # ApplicationController not defined in job mode
+      return if self == Jets::PreheatJob
+
+      managed_prefix = managed ? "managed_" : ""
+      puts <<~EOL.color(:yellow)
+        WARNING: class_#{managed_prefix}iam_policy is not respected when
+        config.cfn.build.controllers is not set to "one_lambda_per_controller" or "one_lambda_per_method"
+        Current setting: config.cfn.build.controllers = "#{Jets.config.cfn.build.controllers}"
+        Please use class_#{managed_prefix}iam_policy in the ApplicationController instead.
+        Docs: #{iam_docs_url(managed)}
+      EOL
+
+      DslEvaluator.print_code(app_call_line) if app_call_line
+    end
+
+    def show_iam_policy_unused_warning?
+      Jets.config.cfn.build.controllers != "one_lambda_per_method" &&
+      self.name.include?("Controller")
+    end
+
+    def iam_docs_url(managed)
+      if managed
+        "http://rubyonjets.com/docs/managed-iam-policies/"
+      else
+        "http://rubyonjets.com/docs/iam-policies/"
+      end
+    end
+
+    def app_call_line
+      caller.find { |l| l.include?('app/controllers') }
+    end
+  end
+end

data/lib/jets/lambda/dsl.rb

@@ -2,6 +2,8 @@
 #
 #   default_associated_resource_definition
 #
+require "dsl_evaluator" # for DslEvaluator.print_code only
+
 module Jets::Lambda::Dsl
   extend ActiveSupport::Concern
 
@@ -12,6 +14,7 @@ module Jets::Lambda::Dsl
   included do
     class << self
       extend Memoist
+      include Warnings
 
       def class_properties(options=nil)
         if options
@@ -31,23 +34,23 @@ module Jets::Lambda::Dsl
 
       def class_environment(hash)
         environment = standardize_env(hash)
-        class_properties(environment: environment)
+        class_properties(Environment: environment)
       end
       alias_method :class_env, :class_environment
 
       def environment(hash)
         environment = standardize_env(hash)
-        properties(environment: environment)
+        properties(Environment: environment)
       end
       alias_method :env, :environment
 
       # Allows user to pass in hash with or without the :variables key.
       def standardize_env(hash)
-        return hash if hash.key?(:variables)
+        return hash if hash.key?(:Variables)
 
         environment = {}
-        environment[:variables] ||= {}
-        environment[:variables].merge!(hash)
+        environment[:Variables] ||= {}
+        environment[:Variables].merge!(hash)
         environment
       end
 
@@ -99,7 +102,9 @@ module Jets::Lambda::Dsl
         if definitions.empty?
           @iam_policy
         else
-          @iam_policy = definitions.flatten
+          iam_policy_unused_warning(managed=false)
+          @iam_policy ||= []
+          @iam_policy += definitions.flatten
         end
       end
 
@@ -108,7 +113,9 @@ module Jets::Lambda::Dsl
         if definitions.empty?
           @class_iam_policy
         else
-          @class_iam_policy = definitions.flatten
+          class_iam_policy_unused_warning(managed=false)
+          @class_iam_policy ||= []
+          @class_iam_policy += definitions.flatten
         end
       end
 
@@ -117,7 +124,9 @@ module Jets::Lambda::Dsl
         if definitions.empty?
           @managed_iam_policy
         else
-          @managed_iam_policy = definitions.flatten
+          iam_policy_unused_warning(managed=true)
+          @managed_iam_policy ||= []
+          @managed_iam_policy += definitions.flatten
         end
       end
 
@@ -126,7 +135,9 @@ module Jets::Lambda::Dsl
         if definitions.empty?
           @class_managed_iam_policy
         else
-          @class_managed_iam_policy = definitions.flatten
+          class_iam_policy_unused_warning(managed=true)
+          @class_managed_iam_policy ||= []
+          @class_managed_iam_policy += definitions.flatten
         end
       end
 
@@ -142,7 +153,7 @@ module Jets::Lambda::Dsl
           @associated_resources || []
         else
           @associated_resources ||= []
-          associated_resource = Jets::Resource::Associated.new(definitions)
+          associated_resource = Jets::Cfn::Resource::Associated.new(definitions)
           associated_resource.multiple_resources = @multiple_resources
           @associated_resources << associated_resource
           @associated_resources.flatten!
@@ -208,7 +219,7 @@ module Jets::Lambda::Dsl
 
           logical_id = logical_id.to_s.sub(/\d+$/,'')
           new_definition = { "#{logical_id}#{n}" => attributes }
-          numbered_resources << Jets::Resource::Associated.new(new_definition)
+          numbered_resources << Jets::Cfn::Resource::Associated.new(new_definition)
           n += 1
         end
         @associated_resources = numbered_resources
@@ -248,13 +259,13 @@ module Jets::Lambda::Dsl
         return if %w[initialize method_missing].include?(meth.to_s)
         return unless public_method_defined?(meth)
 
-        register_task(meth)
+        register_definition(meth)
       end
 
-      def register_task(meth, lang=:ruby)
+      def register_definition(meth, lang=:ruby)
         # Note: for anonymous classes like for app/functions self.name is ""
         # We adjust the class name when we build the functions later in
-        # FunctionContstructor#adjust_tasks.
+        # FunctionContstructor#adjust_definitions.
 
         # At this point we can use the current associated_properties and defined the
         # associated resource with the Lambda function.
@@ -268,7 +279,7 @@ module Jets::Lambda::Dsl
           add_logical_id_counter
         end
 
-        all_tasks[meth] = Jets::Lambda::Task.new(self.name, meth,
+        all_definitions[meth] = Jets::Lambda::Definition.new(self.name, meth,
           properties: @properties, # lambda function properties
           iam_policy: @iam_policy,
           managed_iam_policy: @managed_iam_policy,
@@ -279,7 +290,7 @@ module Jets::Lambda::Dsl
         # Done storing options, clear out for the next added method.
         clear_properties
         # Important to clear @properties at the end of registering outside of
-        # register_task because register_task is overridden in Jets::Job::Dsl
+        # register_definition because register_definition is overridden in Jets::Job::Dsl
         #
         #   Jets::Job::Base < Jets::Lambda::Functions
         #
@@ -302,28 +313,28 @@ module Jets::Lambda::Dsl
         @associated_properties = nil
       end
 
-      # Returns the all tasks for this class with their method names as keys.
+      # Returns the all definitions for this class with their method names as keys.
       #
       # ==== Returns
-      # OrderedHash:: An ordered hash with tasks names as keys and Task
+      # OrderedHash:: An ordered hash with definitions names as keys and definition
       #               objects as values.
       #
-      def all_tasks
-        @all_tasks ||= ActiveSupport::OrderedHash.new
+      def all_definitions
+        @all_definitions ||= ActiveSupport::OrderedHash.new
       end
-      # Do not call all tasks outside this class, instead use: tasks or lambda functions
-      private :all_tasks
+      # Do not call all definitions outside this class, instead use: definitions or lambda functions
+      private :all_definitions
 
-      # Goes up the class inheritance chain to build the tasks.
+      # Goes up the class inheritance chain to build the definitions.
       #
       # Example heirarchy:
       #
       #   Jets::Lambda::Functions > Jets::Controller::Base > ApplicationController ...
       #     > PostsController > ChildPostsController
       #
-      # Do not include tasks from the direct subclasses of Jets::Lambda::Functions
+      # Do not include definitions from the direct subclasses of Jets::Lambda::Functions
       # because those classes are abstract.  Dont want those methods to be included.
-      def find_all_tasks(options={})
+      def find_all_definitions(options={})
         public = options[:public].nil? ? true : options[:public]
         klass = self
         direct_subclasses = Jets::Lambda::Functions.subclasses
@@ -331,53 +342,53 @@ module Jets::Lambda::Dsl
 
         # Go up class inheritance and builds lookup structure in memory
         until direct_subclasses.include?(klass)
-          lookup << klass.send(:all_tasks) # one place we want to call private all_tasks method
+          lookup << klass.send(:all_definitions) # one place we want to call private all_definitions method
           klass = klass.superclass
         end
-        merged_tasks = ActiveSupport::OrderedHash.new
-        # Go back down the class inheritance chain in reverse order and merge the tasks
-        lookup.reverse.each do |tasks_hash|
-          # tasks_hash is a result of all_tasks. Example: PostsController.all_tasks
-          merged_tasks.merge!(tasks_hash)
+        merged_definitions = ActiveSupport::OrderedHash.new
+        # Go back down the class inheritance chain in reverse order and merge the definitions
+        lookup.reverse.each do |definitions_hash|
+          # definitions_hash is a result of all_definitions. Example: PostsController.all_definitions
+          merged_definitions.merge!(definitions_hash)
         end
 
         # The cfn builders required the right final child class to build the lambda functions correctly.
-        merged_tasks.each do |meth, task|
+        merged_definitions.each do |meth, definition|
           # Override the class name for the cfn builders
-          task = task.clone # do not stomp over current tasks since things are usually looked by reference
-          task.instance_variable_set(:@class_name, self.name)
-          merged_tasks[meth] = task
+          definition = definition.clone # do not stomp over current definitions since things are usually looked by reference
+          definition.instance_variable_set(:@class_name, self.name)
+          merged_definitions[meth] = definition
         end
 
         # Methods can be made private with the :private keyword after the method has been defined.
         # To account for this, loop back thorugh all the methods and check if the method is indeed public.
-        tasks = ActiveSupport::OrderedHash.new
-        merged_tasks.each do |meth, task|
+        definitions = ActiveSupport::OrderedHash.new
+        merged_definitions.each do |meth, definition|
           if public
-            tasks[meth] = task if task.public_meth?
+            definitions[meth] = definition if definition.public_meth?
           else
-            tasks[meth] = task unless task.public_meth?
+            definitions[meth] = definition unless definition.public_meth?
           end
         end
-        tasks
+        definitions
       end
-      memoize :find_all_tasks
+      memoize :find_all_definitions
 
-      def all_public_tasks
-        find_all_tasks(public: true)
+      def all_public_definitions
+        find_all_definitions(public: true)
       end
 
-      def all_private_tasks
-        find_all_tasks(public: false)
+      def all_private_definitions
+        find_all_definitions(public: false)
       end
 
-      # Returns the tasks for this class in Array form.
+      # Returns the definitions for this class in Array form.
       #
       # ==== Returns
-      # Array of task objects
+      # Array of definition objects
       #
-      def tasks
-        all_public_tasks.values
+      def definitions
+        all_public_definitions.values
       end
 
       # The public methods defined in the project app class ulimately become
@@ -386,18 +397,18 @@ module Jets::Lambda::Dsl
       # Example return value:
       #   [:index, :new, :create, :show]
       def lambda_functions
-        all_public_tasks.keys
+        all_public_definitions.keys
       end
 
-      # Used in Jets::Cfn::Builders::Interface#build
+      # Used in Jets::Cfn::Builder::Interface#build
       # Overridden in rule/dsl.rb
       def build?
-        !tasks.empty?
+        !definitions.empty?
       end
 
       # Polymorphic support
       def defpoly(lang, meth)
-        register_task(meth, lang)
+        register_definition(meth, lang)
       end
 
       def python(meth)

data/lib/jets/lambda/function.rb

@@ -13,11 +13,11 @@ module Jets::Lambda
     end
 
     def self.handler
-      handler_task.meth
+      handler_definition.meth
     end
 
-    def self.handler_task
-      tasks.first
+    def self.handler_definition
+      definitions.first
     end
 
     # Used by main_processor.rb.  Same interface as controllers and jobs.

data/lib/jets/lambda/function_constructor.rb

@@ -36,18 +36,18 @@ module Jets::Lambda
       code = IO.read(@code_path)
       function_klass = Class.new(Jets::Lambda::Function)
       function_klass.module_eval(code, @code_path)
-      adjust_tasks(function_klass)
+      adjust_definitions(function_klass)
       function_klass # assign this to a Constant for a pretty class name
     end
 
-    # For anonymous classes method_added during task registration contains ""
+    # For anonymous classes method_added during definition registration contains ""
     # for the class name.  We adjust it here.
-    def adjust_tasks(klass)
+    def adjust_definitions(klass)
       class_name = @code_path.to_s.sub(/.*\/functions\//,'').sub(/\.rb$/, '')
       class_name = class_name.camelize
-      klass.tasks.each do |task|
-        task.class_name = class_name
-        task.type = "function"
+      klass.definitions.each do |definition|
+        definition.class_name = class_name
+        definition.type = "function"
       end
     end
   end