jets.benforeva 3.0.17.pre.mount.pre.fix

data/lib/jets/lambda/dsl.rb

@@ -0,0 +1,404 @@
+# Other dsl that rely on this must implement
+#
+#   default_associated_resource_definition
+#
+module Jets::Lambda::Dsl
+  extend ActiveSupport::Concern
+
+  def lambda_functions
+    self.class.lambda_functions
+  end
+
+  included do
+    class << self
+      extend Memoist
+
+      def class_properties(options=nil)
+        if options
+          @class_properties ||= {}
+          @class_properties.deep_merge!(options)
+        else
+          @class_properties || {}
+        end
+      end
+      alias_method :class_props, :class_properties
+
+      def properties(options={})
+        @properties ||= {}
+        @properties.deep_merge!(options)
+      end
+      alias_method :props, :properties
+
+      def class_environment(hash)
+        environment = standardize_env(hash)
+        class_properties(environment: environment)
+      end
+      alias_method :class_env, :class_environment
+
+      def environment(hash)
+        environment = standardize_env(hash)
+        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)
+
+        environment = {}
+        environment[:variables] ||= {}
+        environment[:variables].merge!(hash)
+        environment
+      end
+
+      # Convenience method that set properties. List based on https://amzn.to/2oSph1P
+      # Not all properites are included because some properties are not meant to be set
+      # directly. For example, function_name is a calculated setting by Jets.
+      PROPERTIES = %W[
+        dead_letter_config
+        description
+        handler
+        kms_key_arn
+        memory_size
+        reserved_concurrent_executions
+        role
+        runtime
+        timeout
+        tracing_config
+        vpc_config
+        tags
+      ]
+      PROPERTIES.each do |property|
+        # Example:
+        #   def timeout(value)
+        #     properties(timeout: value)
+        #   end
+        #
+        #   def class_timeout(value)
+        #     class_properties(timeout: value)
+        #   end
+        class_eval <<~CODE
+          def #{property}(value)
+            properties(#{property}: value)
+          end
+
+          def class_#{property}(value)
+            class_properties(#{property}: value)
+          end
+        CODE
+      end
+      # More convenience aliases
+      alias_method :memory, :memory_size
+      alias_method :class_memory, :class_memory_size
+      alias_method :desc, :description
+      alias_method :class_desc, :class_description
+
+      # definitions: one or more definitions
+      def iam_policy(*definitions)
+        if definitions.empty?
+          @iam_policy
+        else
+          @iam_policy = definitions.flatten
+        end
+      end
+
+      # definitions: one or more definitions
+      def class_iam_policy(*definitions)
+        if definitions.empty?
+          @class_iam_policy
+        else
+          @class_iam_policy = definitions.flatten
+        end
+      end
+
+      # definitions: one or more definitions
+      def managed_iam_policy(*definitions)
+        if definitions.empty?
+          @managed_iam_policy
+        else
+          @managed_iam_policy = definitions.flatten
+        end
+      end
+
+      # definitions: one or more definitions
+      def class_managed_iam_policy(*definitions)
+        if definitions.empty?
+          @class_managed_iam_policy
+        else
+          @class_managed_iam_policy = definitions.flatten
+        end
+      end
+
+      def build_class_iam?
+        !!(class_iam_policy || class_managed_iam_policy)
+      end
+
+      #############################
+      # Main method that registers resources associated with the Lambda function.
+      # All resources methods lead here.
+      def associated_resources(*definitions)
+        if definitions == [nil] # when associated_resources called with no arguments
+          @associated_resources || []
+        else
+          @associated_resources ||= []
+          associated_resource = Jets::Resource::Associated.new(definitions)
+          associated_resource.multiple_resources = @multiple_resources
+          @associated_resources << associated_resource
+          @associated_resources.flatten!
+        end
+      end
+      # User-friendly short resource method. Users will use this.
+      alias_method :resource, :associated_resources
+
+      # Using this odd way of setting these properties so we can keep the
+      # resource(*definitions) signature simple. Using keyword arguments at the end
+      # interfere with being able to pass in any keys for the properties hash at the end.
+      #
+      # TODO: If there's a cleaner way of doing this, let me know.
+      def with_fresh_properties(fresh_properties: true, multiple_resources: true)
+        @associated_properties = nil if fresh_properties # dont use any current associated_properties
+        @multiple_resources = multiple_resources
+
+        yield
+
+        @multiple_resources = false
+        @associated_properties = nil if fresh_properties # reset for next definition, since we're defining eagerly
+      end
+
+      # Properties belonging to the associated resource
+      def associated_properties(options={})
+        @associated_properties ||= {}
+        @associated_properties.deep_merge!(options)
+      end
+      alias_method :associated_props, :associated_properties
+
+      # meta definition
+      def self.define_associated_properties(associated_properties)
+        associated_properties.each do |property|
+          # Example:
+          #   def config_rule_name(value)
+          #     associated_properties(config_rule_name: value)
+          #   end
+          class_eval <<~CODE
+            def #{property}(value)
+              associated_properties(#{property}: value)
+            end
+          CODE
+        end
+      end
+
+      def add_logical_id_counter?
+        return false unless @associated_resources
+        # Only takes one associated resource with multiple set to true to return false of this check
+        return false if @associated_resources.detect { |associated| associated.multiple_resources }
+        # Otherwise check if there is more than 1 @associated_resources
+        @associated_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 @associated_resources entirely
+      def add_logical_id_counter
+        numbered_resources = []
+        n = 1
+        @associated_resources.map do |associated|
+          logical_id = associated.logical_id
+          attributes = associated.attributes
+
+          logical_id = logical_id.to_s.sub(/\d+$/,'')
+          new_definition = { "#{logical_id}#{n}" => attributes }
+          numbered_resources << Jets::Resource::Associated.new(new_definition)
+          n += 1
+        end
+        @associated_resources = numbered_resources
+      end
+
+      # Examples:
+      #
+      #   depends_on :custom
+      #   depends_on :custom, :alert
+      #   depends_on :custom, class_prefix: true
+      #   depends_on :custom, :alert, class_prefix: true
+      #
+      def depends_on(*stacks)
+        if stacks == []
+          @depends_on
+        else
+          @depends_on ||= []
+          options = stacks.last.is_a?(Hash) ? stacks.pop : {}
+          stacks.each do |stack|
+            @depends_on << Jets::Stack::Depends::Item.new(stack, options)
+          end
+        end
+      end
+
+      def ref(name)
+        "!Ref #{name.to_s.camelize}"
+      end
+
+      # meth is a Symbol
+      def method_added(meth)
+        return if %w[initialize method_missing].include?(meth.to_s)
+        return unless public_method_defined?(meth)
+
+        register_task(meth)
+      end
+
+      def register_task(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.
+
+        # At this point we can use the current associated_properties and defined the
+        # associated resource with the Lambda function.
+        unless associated_properties.empty?
+          associated_resources(default_associated_resource_definition(meth))
+        end
+
+        # Unsure why but we have to use @associated_resources vs associated_resources
+        # associated_resources is always nil
+        if add_logical_id_counter?
+          add_logical_id_counter
+        end
+
+        all_tasks[meth] = Jets::Lambda::Task.new(self.name, meth,
+          properties: @properties, # lambda function properties
+          iam_policy: @iam_policy,
+          managed_iam_policy: @managed_iam_policy,
+          associated_resources: @associated_resources,
+          lang: lang,
+          replacements: replacements(meth))
+
+        # 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
+        #
+        #   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::Dsl behavior.
+
+        true
+      end
+
+      # Meant to be overridden to add more custom replacements based on the app class type
+      def replacements(meth)
+        {}
+      end
+
+      def clear_properties
+        @properties = nil
+        @iam_policy = nil
+        @managed_iam_policy = nil
+        @associated_resources = nil
+        @associated_properties = nil
+      end
+
+      # Returns the all tasks for this class with their method names as keys.
+      #
+      # ==== Returns
+      # OrderedHash:: An ordered hash with tasks names as keys and Task
+      #               objects as values.
+      #
+      def all_tasks
+        @all_tasks ||= ActiveSupport::OrderedHash.new
+      end
+      # Do not call all tasks outside this class, instead use: tasks or lambda functions
+      private :all_tasks
+
+      # Goes up the class inheritance chain to build the tasks.
+      #
+      # Example heirarchy:
+      #
+      #   Jets::Lambda::Functions > Jets::Controller::Base > ApplicationController ...
+      #     > PostsController > ChildPostsController
+      #
+      # Do not include tasks from the direct subclasses of Jets::Lambda::Functions
+      # because those classes are abstract.  Dont want those methods to be included.
+      def find_all_tasks(public: true)
+        klass = self
+        direct_subclasses = Jets::Lambda::Functions.subclasses
+        lookup = []
+
+        # 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
+          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)
+        end
+
+        # The cfn builders required the right final child class to build the lambda functions correctly.
+        merged_tasks.each do |meth, task|
+          # 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
+        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|
+          if public
+            tasks[meth] = task if task.public_meth?
+          else
+            tasks[meth] = task unless task.public_meth?
+          end
+        end
+        tasks
+      end
+      memoize :find_all_tasks
+
+      def all_public_tasks
+        find_all_tasks(public: true)
+      end
+
+      def all_private_tasks
+        find_all_tasks(public: false)
+      end
+
+      # Returns the tasks for this class in Array form.
+      #
+      # ==== Returns
+      # Array of task objects
+      #
+      def tasks
+        all_public_tasks.values
+      end
+
+      # The public methods defined in the project app class ulimately become
+      # lambda functions.
+      #
+      # Example return value:
+      #   [:index, :new, :create, :show]
+      def lambda_functions
+        all_public_tasks.keys
+      end
+
+      # Used in Jets::Cfn::Builders::Interface#build
+      # Overridden in rule/dsl.rb
+      def build?
+        !tasks.empty?
+      end
+
+      # Polymorphic support
+      def defpoly(lang, meth)
+        register_task(meth, lang)
+      end
+
+      def python(meth)
+        defpoly(:python, meth)
+      end
+
+      def node(meth)
+        defpoly(:node, meth)
+      end
+    end # end of class << self
+  end # end of included
+end

data/lib/jets/lambda/function.rb

@@ -0,0 +1,29 @@
+module Jets::Lambda
+  class Function < Functions
+    # Override and change the signature so we do not have to provide info at
+    # initialization. So:
+    #
+    #   hello_function = HelloFunction.new
+    #   hello_function.lambda_handler(event, context)
+    #
+    # Normally controller and job functions initialize like this:
+    #
+    #   controller = PostController.new(event, context, "handler_handler")
+    def initialize
+    end
+
+    def self.handler
+      handler_task.meth
+    end
+
+    def self.handler_task
+      tasks.first
+    end
+
+    # Used by main_processor.rb.  Same interface as controllers and jobs.
+    def self.process(event, context, meth)
+      function = new
+      function.send(handler, event, context)
+    end
+  end
+end

data/lib/jets/lambda/function_constructor.rb

@@ -0,0 +1,55 @@
+# Builds an anonymous class that represents a single Lambda function from code
+# in app/functions.
+#
+# The build method returns an anonymous class using Class.new that contains
+# the methods defined in the app/functions/hello.rb code.
+#
+# Ruby Class.new docs:
+#
+# Creates a new anonymous (unnamed) class with the given superclass (or
+# Object if no parameter is given). You can give a class a name by
+# assigning the class object to a constant.
+# http://ruby-doc.org/core-2.1.1/Class.html#method-c-new
+#
+# So assigning the result of build to a constant makes for a prettier
+# class name. Example:
+#
+#   constructor = FunctionConstructor.new(code_path)
+#   HelloFunction = constructor.build
+#
+# The class name will be HelloFunction instead of (anonymous). Then usage would
+# be:
+#
+#   hello_function = HelloFunction.new
+#   hello_function(hello_function.handler, event, context)
+#
+# Or call with the process class method:
+#
+#   HelloFunction.process(event, context, "world")
+module Jets::Lambda
+  class FunctionConstructor
+    def initialize(code_path)
+      @code_path = "#{Jets.root}/#{code_path}"
+    end
+
+    def build
+      code = IO.read(@code_path)
+      function_klass = Class.new(Jets::Lambda::Function)
+      function_klass.module_eval(code, @code_path)
+      adjust_tasks(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 the class name.  We adjust it here.
+    def adjust_tasks(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"
+      end
+    end
+  end
+end
+

data/lib/jets/lambda/functions.rb

@@ -0,0 +1,39 @@
+require 'json'
+
+# Jets::Lambda::Functions represents a collection of Lambda functions.
+#
+# Jets::Lambda::Functions is the superclass of:
+#   Jets::Controller::Base
+#   Jets::Job::Base
+module Jets::Lambda
+  class Functions
+    attr_reader :event, :context, :meth
+    def initialize(event, context, meth)
+      @event = HashWithIndifferentAccess.new(event) # Hash, JSON.parse(event) ran BaseProcessor
+      @context = context # Hash. JSON.parse(context) ran in BaseProcessor
+      @meth = meth
+      # store meth because it is useful to for identifying the which template
+      # to use later.
+    end
+
+    include Dsl # At the end so methods like event, context and method
+      # do not trigger method_added
+
+    class << self
+      # Tracking subclasses because it helps with Lambda::Dsl#find_all_tasks
+      def subclasses
+        @subclasses ||= []
+      end
+
+      def inherited(base)
+        super
+        self.subclasses << base if base.name
+      end
+
+      # Needed for depends_on. Got added due to stagger logic.
+      def output_keys
+        []
+      end
+    end
+  end
+end

data/lib/jets/lambda/task.rb

@@ -0,0 +1,111 @@
+class Jets::Lambda::Task
+  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 = 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.
+    baseline_replacements.merge(@replacements)
+  end
+
+  def baseline_replacements
+    {
+      # camelized because used in not just keys but common used in values
+      namespace: @meth.to_s.camelize,
+    }
+  end
+end

data/lib/jets/logger.rb

@@ -0,0 +1,21 @@
+require 'logger'
+
+module Jets
+  class Logger < ::Logger
+    # Only need to override the add method as the other calls all lead to it.
+    def add(severity, message = nil, progname = nil)
+      # Taken from Logger#add source
+      # https://ruby-doc.org/stdlib-2.5.1/libdoc/logger/rdoc/Logger.html#method-i-add
+      if message.nil?
+        if block_given?
+          message = yield
+        else
+          message = progname
+          progname = @progname
+        end
+      end
+
+      super # original logical
+    end
+  end
+end

data/lib/jets/mega/hash_converter.rb

@@ -0,0 +1,25 @@
+# Thanks https://mensfeld.pl/2012/01/converting-nested-hash-into-http-url-params-hash-version-in-ruby/
+module Jets::Mega
+  module HashConverter
+    def self.encode(value, key = nil, out_hash = {})
+      case value
+      when Hash  then
+        value.each { |k,v| encode(v, append_key(key,k), out_hash) }
+        out_hash
+      when Array then
+        value.each { |v| encode(v, "#{key}[]", out_hash) }
+        out_hash
+      when nil   then ''
+      else
+        out_hash[key] = value
+        out_hash
+      end
+    end
+
+    private
+
+    def self.append_key(root_key, key)
+      root_key.nil? ? :"#{key}" : :"#{root_key}[#{key.to_s}]"
+    end
+  end
+end