jets 4.0.12 → 5.0.0.beta1

data/lib/jets/{poly_fun.rb → poly.rb}

@@ -1,5 +1,5 @@
 module Jets
-  class PolyFun
+  class Poly
     extend Memoist
 
     def initialize(app_class, app_meth)
@@ -10,12 +10,12 @@ module Jets
     def run(event, context={})
       check_private_method!
 
-      if task.lang == :ruby
+      if definition.lang == :ruby
         # controller = PostsController.new(event, content)
         # resp = controller.edit
         run_ruby_code(event, context)
       else
-        executor = LambdaExecutor.new(task)
+        executor = LambdaExecutor.new(definition)
         resp = executor.run(event, context)
         if resp["errorMessage"]
           raise_error(resp)
@@ -27,7 +27,7 @@ module Jets
     def run_ruby_code(event, context)
       @app_class.process(event, context, @app_meth)
     rescue Exception => e
-      Jets.on_exception(e)
+      Jets.report_exception(e)
       raise(e)
     end
 
@@ -48,23 +48,23 @@ module Jets
         end
       end
 
-      # IE: Jets::PolyFun::PythonError
-      error_class = "Jets::PolyFun::#{task.lang.to_s.camelize}Error".constantize
+      # IE: Jets::Poly::PythonError
+      error_class = "Jets::Poly::#{definition.lang.to_s.camelize}Error".constantize
       raise error_class.new(resp["errorMessage"], backtrace)
     end
 
-    def task
-      task = @app_class.all_public_tasks[@app_meth]
+    def definition
+      definition = @app_class.all_public_definitions[@app_meth]
       # Provider user a better error message to user than a nil failure.
-      unless task
+      unless definition
         raise "Unable to find #{@app_class}##{@app_meth}"
       end
-      task
+      definition
     end
-    memoize :task
+    memoize :definition
 
     def check_private_method!
-      private_detected = @app_class.all_private_tasks.keys.include?(@app_meth)
+      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"

data/lib/jets/preheat.rb

@@ -24,7 +24,7 @@ module Jets
 
     # Makes remote call to the Lambda function.
     def warm(function_name)
-      Jets::Commands::Call.new(function_name, '{"_prewarm": "1"}', @options).run unless Jets.env.test?
+      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.
@@ -32,7 +32,6 @@ module Jets
       threads = []
       all_functions.each do |function_name|
         next if function_name.include?('jets-public_controller') # handled by warm_public_controller_more
-        next if function_name.include?('jets-rack_controller') # handled by warm_rack_controller_more
         threads << Thread.new do
           warm(function_name)
         end
@@ -41,7 +40,6 @@ module Jets
 
       # Warm the these controllers more since they can be hit more often
       warm_public_controller_more
-      warm_rack_controller_more
 
       # return the funciton names so we can see in the Lambda console
       # the functions being prewarmed
@@ -66,29 +64,18 @@ module Jets
       threads.each { |t| t.join }
     end
 
-    def warm_rack_controller_more
-      return unless Jets.rack?
-      function_name = 'jets-rack_controller-process' # key function name
-      return unless all_functions.include?(function_name)
-
-      rack_ratio = Jets.config.prewarm.rack_ratio
-      return if rack_ratio == 0
-
-      puts "Prewarming the rack controller extra at a ratio of #{rack_ratio}" unless @options[:mute]
-
-      threads = []
-      rack_ratio.times do
-        threads << Thread.new do
-          warm(function_name)
-        end
-      end
-      threads.each { |t| t.join }
-    end
-
     # Returns:
     #   [
-    #     "posts_controller-index",
-    #     "posts_controller-show",
+    #     "demo-posts_controller-index",
+    #     "demo-posts_controller-show",
+    #     ...
+    #   ]
+    #
+    #   or (for one lambda per controller)
+    #
+    #   [
+    #     "demo-posts_controller",
+    #     "demo-up_controller",
     #     ...
     #   ]
     def all_functions
@@ -109,7 +96,7 @@ module Jets
     memoize :all_functions
 
     def classes
-      Jets::Commands::Build.app_files.map do |path|
+      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
 

data/lib/jets/processors/deducer.rb

@@ -13,8 +13,8 @@ class Jets::Processors::Deducer
   end
 
   def code
-    # code: "PostsController.process(event, context, meth: "show")"
-    # code: "HardJob.process(event, context, meth: "dig")"
+    # code: "PostsController.process(event, context, "show")"
+    # code: "HardJob.process(event, context, "dig")"
     %|#{class_name}.process(event, context, "#{@handler_method}")|
   end
 

data/lib/jets/processors/main_processor.rb

@@ -42,20 +42,13 @@ class Jets::Processors::MainProcessor
       end
 
       result
-    rescue Exception => e
-      unless Jets.env.test?
-        # Customize error message slightly so nodejs shim can process the
-        # returned error message.
-        # The "RubyError: " is a marker that the javascript shim scans for.
-        $stderr.puts("RubyError: #{e.class}: #{e.message}") # js needs this as the first line
-        backtrace = e.backtrace.map {|l| "  #{l}" }
-        $stderr.puts(backtrace)
-        # No need to having error in stderr above anymore because errors are handled in memory
-        # at ruby_server.rb but keeping around for posterity.
-      end
 
-      Jets.on_exception(e)
-      raise(e) # raise error to ruby_server.rb to rescue and handle
+    # 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

@@ -0,0 +1,77 @@
+# 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

@@ -0,0 +1,177 @@
+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,13 +1,47 @@
 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(klass, at:)
-      options = {to: "jets/mount#call", mount_class: klass}
-      at = at[1..-1] if at.starts_with?('/') # be more forgiving if / accidentally included
-      at_wildcard = at.blank? ? "*path" : "#{at}/*path"
+    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
 
-      any at, options
-      any at_wildcard, options
+    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