jets 5.0.14 → 6.0.0.beta1

data/lib/jets/poly/python_executor.rb

@@ -1,23 +0,0 @@
-class Jets::Poly
-  class PythonExecutor < BaseExecutor
-    # Code for wrapper script that mimics lambda execution. Wrapper script usage:
-    #
-    #   python WRAPPER_SCRIPT EVENT
-    #
-    # Example:
-    #
-    #   python /tmp/jets/demo/executor/20180804-12816-imqb9/lambda_executor.py '{}'
-    def code
-      <<-EOL
-import sys
-import json
-from #{@definition.meth} import #{handler}
-event = json.loads(sys.argv[1])
-context = {}
-resp = #{handler}(event, context)
-result = json.dumps(resp)
-print(result)
-EOL
-    end
-  end
-end

data/lib/jets/poly.rb

@@ -1,73 +0,0 @@
-module Jets
-  class Poly
-    extend Memoist
-
-    def initialize(app_class, app_meth)
-      @app_class = app_class # already a Constant, IE: PostController
-      @app_meth = app_meth.to_sym
-    end
-
-    def run(event, context={})
-      check_private_method!
-
-      if definition.lang == :ruby
-        # controller = PostsController.new(event, content)
-        # resp = controller.edit
-        run_ruby_code(event, context)
-      else
-        executor = LambdaExecutor.new(definition)
-        resp = executor.run(event, context)
-        if resp["errorMessage"]
-          raise_error(resp)
-        end
-        resp
-      end
-    end
-
-    def run_ruby_code(event, context)
-      @app_class.process(event, context, @app_meth)
-    rescue Exception => e
-      Jets.report_exception(e)
-      raise(e)
-    end
-
-    def raise_error(resp)
-      backtrace = resp["stackTrace"] + caller
-      backtrace = backtrace.map { |l| l.sub(/^\s+/,'') }
-      # Adjust the paths from the tmp path to the app path to improve user debugging
-      # experience. Example:
-      # From:
-      #   File "/tmp/jets/lite/executor/20180917-16777-43a9e48/app/controllers/jets/public_controller/python/show.py", line 32
-      # To:
-      #   File "app/controllers/jets/public_controller/python/show.py", line 32      backtrace =
-      backtrace = backtrace.map do |l|
-        if l.include?(Jets.build_root) && !l.include?("lambda_executor.")
-          l.sub(/\/tmp\/jets.*executor\/\d{8}-+.*?\//, '')
-        else
-          l
-        end
-      end
-
-      # IE: Jets::Poly::PythonError
-      error_class = "Jets::Poly::#{definition.lang.to_s.camelize}Error".constantize
-      raise error_class.new(resp["errorMessage"], backtrace)
-    end
-
-    def definition
-      definition = @app_class.all_public_definitions[@app_meth]
-      # Provider user a better error message to user than a nil failure.
-      unless definition
-        raise "Unable to find #{@app_class}##{@app_meth}"
-      end
-      definition
-    end
-    memoize :definition
-
-    def check_private_method!
-      private_detected = @app_class.all_private_definitions.keys.include?(@app_meth)
-      return unless private_detected # Ok to continue
-
-      raise "The #{@app_class}##{@app_meth} is a private method.  Unable to call it unless it is public"
-    end
-  end
-end

data/lib/jets/preheat.rb

@@ -1,110 +0,0 @@
-module Jets
-  class Preheat
-    extend Memoist
-    include Jets::AwsServices
-
-    # Examples:
-    #
-    #   Jets::Preheat.warm("posts_controller-index")
-    #   Jets::Preheat.warm("jets-preheat_job-warm")
-    #
-    def self.warm(function_name, options={})
-      Preheat.new(options).warm(function_name)
-    end
-
-    def self.warm_all(options={})
-      Preheat.new(options).warm_all
-    end
-
-    def initialize(options)
-      @options = options # passed to Call.new options
-      @options[:mute_output] = true if @options[:mute_output].nil?
-      @options[:lambda_proxy] = false # do not transform controller event from {"event": "1"} to {"queryStringParameters":{"_prewarm":"1"}}
-    end
-
-    # Makes remote call to the Lambda function.
-    def warm(function_name)
-      Jets::Commands::Call::Caller.new(function_name, '{"_prewarm": "1"}', @options).run unless Jets.env.test?
-    end
-
-    # Loop through all methods for each class and makes special prewarm call to each method.
-    def warm_all
-      threads = []
-      all_functions.each do |function_name|
-        next if function_name.include?('jets-public_controller') # handled by warm_public_controller_more
-        threads << Thread.new do
-          warm(function_name)
-        end
-      end
-      threads.each { |t| t.join }
-
-      # Warm the these controllers more since they can be hit more often
-      warm_public_controller_more
-
-      # return the funciton names so we can see in the Lambda console
-      # the functions being prewarmed
-      all_functions
-    end
-
-    def warm_public_controller_more
-      function_name = 'jets-public_controller-show' # key function name
-      return unless all_functions.include?(function_name)
-
-      public_ratio = Jets.config.prewarm.public_ratio
-      return if public_ratio == 0
-
-      puts "Prewarming the public controller extra at a ratio of #{public_ratio}" unless @options[:mute]
-
-      threads = []
-      public_ratio.times do
-        threads << Thread.new do
-          warm(function_name)
-        end
-      end
-      threads.each { |t| t.join }
-    end
-
-    # Returns:
-    #   [
-    #     "demo-posts_controller-index",
-    #     "demo-posts_controller-show",
-    #     ...
-    #   ]
-    #
-    #   or (for one lambda per controller)
-    #
-    #   [
-    #     "demo-posts_controller",
-    #     "demo-up_controller",
-    #     ...
-    #   ]
-    def all_functions
-      parent_stack = cfn.describe_stack_resources(stack_name: Jets::Names.parent_stack_name)
-      parent_resources = parent_stack.stack_resources.select do |resource|
-        resource.logical_resource_id =~ /Controller$/ # only controller functions
-      end
-      physical_resource_ids = parent_resources.map(&:physical_resource_id)
-      resources = physical_resource_ids.inject([]) do |acc, physical_resource_id|
-        stack_resources = cfn.describe_stack_resources(stack_name: physical_resource_id).stack_resources
-        stack_resources.each do |stack_resource|
-          acc << stack_resource if stack_resource.logical_resource_id.ends_with?('LambdaFunction') # only functions
-        end
-        acc
-      end
-      resources.map(&:physical_resource_id) # function names
-    end
-    memoize :all_functions
-
-    def classes
-      Jets::Cfn::Builder.app_files.map do |path|
-        next if path.include?("preheat_job.rb") # dont want to cause an infinite loop, just in case
-        next unless path =~ %r{app/controllers} # only prewarm controllers
-
-        class_path = path.sub(%r{.*app/\w+/},'').sub(/\.rb$/,'')
-        class_name = class_path.camelize
-        # IE: PostsController
-        class_name.constantize # load app/**/* class definition
-      end.compact
-    end
-  end
-end

data/lib/jets/processors/deducer.rb

@@ -1,65 +0,0 @@
-# Jets::Processors::Deducer class figures out information that allows the
-# controller or job to be called. Sme key methods for deducer:
-#
-#   code - code to instance eval.  IE: PostsController.new(event, context).index
-#   path - full path to the app code. IE: #{Jets.root}app/controllers/posts_controller.rb
-#
-class Jets::Processors::Deducer
-  def initialize(handler)
-    @handler = handler # handlers/controllers/posts.show
-    # @handler_path: "handlers/controllers/posts"
-    # @handler_method: "show"
-    @handler_path, @handler_method = @handler.split('.')
-  end
-
-  def code
-    # code: "PostsController.process(event, context, "show")"
-    # code: "HardJob.process(event, context, "dig")"
-    %|#{class_name}.process(event, context, "#{@handler_method}")|
-  end
-
-  # Input: @handler_path: handlers/jobs/hard_job.rb
-  # Output: #{Jets.root/app/jobs/hard_job.rb
-  def path
-    @handler_path.sub("handlers", "app") + ".rb"
-  end
-
-  # process_type is key. It can be either "controller" or "job". It is used to
-  # deduce the rest of the methods: code, path.
-  def process_type
-    if shared?
-      "function" # all app/shared/functions are always function process_type
-    else
-      @handler.split('/')[1].singularize # controller, job, rule, etc
-    end
-  end
-
-  def shared?
-    @handler.include?("/shared/functions")
-  end
-
-  # Example underscored_class_name:
-  #   class_name = underscored_class_name
-  #   class_name = class_name # PostsController
-  def class_name
-    regexp = shared? ?
-      Regexp.new(".*handlers/shared/functions/") :
-      Regexp.new(".*handlers/#{process_type.pluralize}/")
-
-    # Example regexp:
-    #   /.*handlers\/controllers\//
-    #   /.*handlers\/jobs\//
-    class_name = @handler_path.sub(regexp, "")
-    # Example class names:
-    #   posts_controller
-    #   hard_job
-    #   hello
-    #   hello_function
-
-    class_name.camelize
-  end
-
-  def load_class
-    Jets::Klass.from_path(path)
-  end
-end

data/lib/jets/processors/main_processor.rb

@@ -1,54 +0,0 @@
-require 'json'
-require 'stringio'
-
-# Node shim calls this class to process both controllers and jobs
-class Jets::Processors::MainProcessor
-  attr_reader :event, :context, :handler
-  def initialize(event, context, handler)
-    @event = event
-    @context = context
-    @handler = handler
-  end
-
-  def run
-    # Use the handler to deduce app code to run.
-    # Example handlers: handlers/controllers/posts.create, handlers/jobs/sleep.perform
-    #
-    #   deducer = Jets::Processors::Deducer.new("handlers/controllers/posts.create")
-    #
-    deducer = Jets::Processors::Deducer.new(handler)
-    begin
-      # Examples:
-      #   deducer.code => PostsController.process(event, context, "show")
-      #   deducer.path => app/controllers/posts_controller.rb
-      #
-      #   deducer.code => HardJob.process(event, context, "dig")
-      #   deducer.path => app/jobs/hard_job.rb
-      #
-      #   deducer.code => HelloFunction.process(event, context, "world")
-      #   deducer.path => app/functions/hello.rb
-      deducer.load_class
-      # result = PostsController.process(event, context, "create")
-      result = instance_eval(deducer.code, deducer.path)
-      result = HashWithIndifferentAccess.new(result) if result.is_a?(Hash)
-
-      Jets.increase_call_count
-
-      if result.is_a?(Hash) && result["headers"]
-        # API Gateway is okay with the header values as Integers but
-        # ELBs are more strict about this and require the header values to be Strings
-        result["headers"]["x-jets-call-count"] = Jets.call_count.to_s
-        result["headers"]["x-jets-prewarm-count"] = Jets.prewarm_count.to_s
-      end
-
-      result
-
-    # Additional rescue Exception as a paranoid measure.  We want to make sure
-    # that we always report the exception.  This is the last line of defense.
-    # Note: This only happens when the code is running in Lambda.
-    rescue => exception
-      Jets.report_exception(exception)
-      raise(exception)
-    end
-  end
-end

data/lib/jets/rack/logger.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/time/conversions"
-require "active_support/core_ext/object/blank"
-require "active_support/log_subscriber"
-require "rack/body_proxy"
-
-module Jets
-  module Rack
-    # Sets log tags, logs the request, calls the app, and flushes the logs.
-    #
-    # Log tags (+taggers+) can be an Array containing: methods that the +request+
-    # object responds to, objects that respond to +to_s+ or Proc objects that accept
-    # an instance of the +request+ object.
-    class Logger < ActiveSupport::LogSubscriber
-      def initialize(app, taggers = nil)
-        @app          = app
-        @taggers      = taggers || []
-      end
-
-      def call(env)
-        request = ActionDispatch::Request.new(env)
-
-        if logger.respond_to?(:tagged)
-          logger.tagged(compute_tags(request)) { call_app(request, env) }
-        else
-          call_app(request, env)
-        end
-      end
-
-      private
-        def call_app(request, env) # :doc:
-          instrumenter = ActiveSupport::Notifications.instrumenter
-          instrumenter_state = instrumenter.start "request.action_dispatch", request: request
-          instrumenter_finish = -> () {
-            instrumenter.finish_with_state(instrumenter_state, "request.action_dispatch", request: request)
-          }
-
-          logger.info { started_request_message(request) }
-          status, headers, body = @app.call(env)
-          body = ::Rack::BodyProxy.new(body, &instrumenter_finish)
-          [status, headers, body]
-        rescue Exception
-          instrumenter_finish.call
-          raise
-        ensure
-          ActiveSupport::LogSubscriber.flush_all!
-        end
-
-        # Started GET "/session/new" for 127.0.0.1 at 2012-09-26 14:51:42 -0700
-        def started_request_message(request) # :doc:
-          'Started %s "%s" for %s at %s' % [
-            request.raw_request_method,
-            request.filtered_path,
-            request.remote_ip,
-            Time.now.to_default_s ]
-        end
-
-        def compute_tags(request) # :doc:
-          @taggers.collect do |tag|
-            case tag
-            when Proc
-              tag.call(request)
-            when Symbol
-              request.send(tag)
-            else
-              tag
-            end
-          end
-        end
-
-        def logger
-          Jets.logger
-        end
-    end
-  end
-end

data/lib/jets/router/compat/route_set.rb

@@ -1,177 +0,0 @@
-require "action_dispatch"
-require "action_dispatch/routing/route_set"
-
-module Jets::Router::Compat
-  # Related:
-  #
-  #   Jets::Controller::Compat::ActionDispatch::Routing::UrlFor
-  #   Jets::Controller::Request::Compat::RouteSet
-  #   Jets::Router::Compat::RouteSet
-  #
-  # Compat::RouteSet makes the Jets::Router::RouteSet "compatible" with the Rails RouteSet.
-  # Importantly, it provides a custom url_for method that mimics the Rails url_for method.
-  #
-  module RouteSet
-    # Original:
-    # RESERVED_OPTIONS = [:host, :protocol, :port, :subdomain, :domain, :tld_length,
-    #   :trailing_slash, :anchor, :params, :only_path, :script_name,
-    #   :original_script_name, :relative_url_root]
-    # UNKNOWN = ->(options) { ActionDispatch::Http::URL.url_for(options) }
-    RESERVED_OPTIONS = ActionDispatch::Routing::RouteSet::RESERVED_OPTIONS
-    UNKNOWN = ActionDispatch::Routing::RouteSet::UNKNOWN
-
-    # This method is a version of the Rails RouteSet#url_for method.
-    # It only resolves simple routes for simple cases:
-    #
-    #   when nil
-    #   when Hash, ActionController::Parameters
-    #
-    # This is because ActionDispatch::Routing::UrlFor#url_for gets called before
-    # and then calls out to this method. Only have to account for 2 cases to
-    # mimic Jets behavior.
-    #
-    # Based on Jets ActionDispatch::Routing::RouteSet#url_for
-    def url_for(options, route_name = nil, url_strategy = UNKNOWN, method_name = nil, reserved = RESERVED_OPTIONS)
-      user = password = nil
-
-      if options[:user] && options[:password]
-        user     = options.delete :user
-        password = options.delete :password
-      end
-
-      # save recall_controller for url_options when controller not specified by user
-      # IE: redirect_to action: :routes
-      recall_controller = options[:_recall][:controller]
-      recall = options.delete(:_recall) { {} }
-
-      original_script_name = options.delete(:original_script_name)
-      # script_name = find_script_name options (original)
-      script_name = options.delete(:script_name)
-
-      if original_script_name
-        script_name = original_script_name + script_name
-      end
-
-      path_options = options.dup
-      reserved.each { |ro| path_options.delete ro }
-      path_options[:controller] ||= recall_controller
-
-      route_with_params = generate(route_name, path_options, recall)
-      path = route_with_params.path(method_name)
-
-      if options[:trailing_slash] && !options[:format] && !path.end_with?("/")
-        path += "/"
-      end
-
-      params = route_with_params.params
-
-      if options.key? :params
-        if options[:params]&.respond_to?(:to_hash)
-          params.merge! options[:params]
-        else
-          params[:params] = options[:params]
-        end
-      end
-
-      options[:path]        = path
-      options[:script_name] = script_name
-      options[:params]      = params
-      options[:user]        = user
-      options[:password]    = password
-
-      url_strategy.call options
-    end
-
-    def generate(route_name, options, recall = {}, method_name = nil)
-      Generator.new(route_name, options, recall, self).generate
-    end
-    private :generate
-
-    # This is only used for Custom resolve polymporphic path support
-    # Stub out. Jets does not currently support this.
-    # interface method
-    def polymorphic_mappings
-      {}
-    end
-
-    # ActionView::Rendering ClassMethods build_view_context_class includes these modues. Something like this:
-    #
-    #   def build_view_context_class(klass, supports_path, routes, helpers)
-    #     ...
-    #     if routes
-    #       include routes.url_helpers(supports_path)
-    #       include routes.mounted_helpers
-    #     end
-    #
-    # interface method
-    # def url_helpers(supports_path=true)
-    #   ActionDispatch::Routing::UrlFor
-    # end
-
-    # interface method
-    def mounted_helpers
-      Module.new
-    end
-
-    # Based on Rails ActionDispatch::Routing::RouteSet::Generator
-    class Generator
-      attr_reader :options, :recall, :set, :named_route
-
-      def initialize(named_route, options, recall, set)
-        @named_route = named_route
-        @options     = options.dup
-        # Fix kaminari pagination links. Looks like Rails can handle nil params
-        @options.delete_if { |_, v| v.to_param.nil? }
-        @recall      = recall
-        @set         = set
-      end
-
-      # Generates a path from routes, returns a RouteWithParams or MissingRoute.
-      # MissingRoute will raise ActionController::UrlGenerationError.
-      def generate
-        RouteWithParams.new(named_route, recall, options)
-      end
-    end
-
-    class RouteWithParams
-      def initialize(route, parameterized_parts, params)
-        @route = route
-        @parameterized_parts = parameterized_parts
-        @params = params
-      end
-
-      def params
-        params = @params.dup
-        # So controller and action do not show up in the query string
-        params.delete(:controller)
-        params.delete(:action)
-        params
-      end
-
-      def path(_)
-        # Match with Jets router instead of Rails router
-        matcher = Jets::Router::Matcher.new
-        route = matcher.find_by_controller_action(@parameterized_parts[:controller], @parameterized_parts[:action])
-        if route
-          path = replace_placeholders(route.path, @parameterized_parts)
-          path.starts_with?('/') ? path : "/#{path}"
-        else
-          # Mimic Rails MissingRoute error
-          constraints = @params
-          missing_keys = []
-          unmatched_keys = []
-          routes = Jets.application.routes
-          name = nil
-          ActionDispatch::Journey::Formatter::MissingRoute.new(constraints, missing_keys, unmatched_keys, routes, name).path(name)
-        end
-      end
-
-      def replace_placeholders(path, params)
-        params.each do |key, value|
-          path = path.gsub(":#{key}", value.to_param)
-        end
-        path
-      end
-    end
-  end
-end

data/lib/jets/router/dsl/mount.rb

@@ -1,47 +0,0 @@
-module Jets::Router::Dsl
-  module Mount
-    # support these notations:
-    #   mount Blorgh::Engine, at: "/blog"
-    #   mount sprockets_env => "/assets"
-    #   mount sprockets_env => "/assets", internal: true
-    def mount(*args)
-      options = args.extract_options!
-
-      if args.empty?
-        mount_option = options.find { |k,v| !k.is_a?(String) && !v.is_a?(Symbol) }
-        mount_class, at = mount_option[0], mount_option[1]
-      else
-        mount_class = args.first
-        at = options[:at]
-      end
-
-      at = "/#{at}" unless at.starts_with?("/")
-      mount_class_at(mount_class, options.merge(at: at))
-    end
-
-    # The mounted class must be a Rack compatiable class
-    def mount_class_at(klass, options={})
-      if klass.is_a?(Class) && klass < Jets::Engine
-        mount_engine(klass, options)
-      else
-        # Handles mount like Sprockets::Environment.new
-        at = options.delete(:at)
-        at = at[1..-1] if at.starts_with?('/') # be more forgiving if / accidentally included
-        at_wildcard = at.blank? ? "*path" : "#{at}/*path"
-        options.merge!(to: "jets/mount#call", mount_class: klass)
-
-        any at, options
-        any at_wildcard, options
-      end
-    end
-
-    mattr_accessor :mounted_engines
-    self.mounted_engines = {}
-    def mount_engine(klass, options={})
-      at = options.delete(:at)
-      options.merge!(engine: klass, path: at)
-      create_route(options)
-      @@mounted_engines[at] = klass
-    end
-  end
-end