RubyGems - jets - Versions diffs - 1.0.18 → 1.1.0 - Mend

jets 1.0.18 → 1.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (59) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +4 -0
data/Gemfile.lock +10 -10
data/README/testing.md +5 -2
data/lib/jets.rb +2 -2
data/lib/jets/application.rb +69 -40
data/lib/jets/booter.rb +17 -20
data/lib/jets/builders/code_builder.rb +7 -8
data/lib/jets/cfn/ship.rb +0 -6
data/lib/jets/commands/build.rb +0 -5
data/lib/jets/commands/deploy.rb +0 -4
data/lib/jets/commands/main.rb +31 -4
data/lib/jets/commands/templates/skeleton/{.env → .env.tt} +1 -0
data/lib/jets/commands/templates/skeleton/config.ru +1 -0
data/lib/jets/commands/upgrade/v1.rb +12 -0
data/lib/jets/controller.rb +5 -0
data/lib/jets/controller/base.rb +43 -21
data/lib/jets/controller/cookies.rb +40 -0
data/lib/jets/controller/cookies/jar.rb +269 -0
data/lib/jets/controller/middleware.rb +4 -0
data/lib/jets/controller/middleware/local.rb +119 -0
data/lib/jets/{server/lambda_aws_proxy.rb → controller/middleware/local/api_gateway.rb} +11 -49
data/lib/jets/controller/middleware/local/mimic_aws_call.rb +38 -0
data/lib/jets/{server → controller/middleware/local}/route_matcher.rb +4 -4
data/lib/jets/controller/middleware/main.rb +46 -0
data/lib/jets/{server → controller/middleware}/webpacker_setup.rb +0 -1
data/lib/jets/controller/params.rb +2 -1
data/lib/jets/controller/rack.rb +5 -0
data/lib/jets/controller/rack/adapter.rb +60 -0
data/lib/jets/controller/rack/env.rb +96 -0
data/lib/jets/controller/redirection.rb +1 -1
data/lib/jets/controller/renderers.rb +1 -1
data/lib/jets/controller/renderers/base_renderer.rb +0 -4
data/lib/jets/controller/renderers/{aws_proxy_renderer.rb → rack_renderer.rb} +7 -19
data/lib/jets/controller/renderers/template_renderer.rb +1 -1
data/lib/jets/controller/request.rb +14 -44
data/lib/jets/controller/response.rb +55 -7
data/lib/jets/internal/app/controllers/jets/rack_controller.rb +13 -3
data/lib/jets/mega.rb +7 -0
data/lib/jets/{rack → mega}/hash_converter.rb +1 -1
data/lib/jets/{rack → mega}/request.rb +17 -4
data/lib/jets/middleware.rb +38 -0
data/lib/jets/middleware/configurator.rb +84 -0
data/lib/jets/middleware/default_stack.rb +44 -0
data/lib/jets/middleware/layer.rb +34 -0
data/lib/jets/middleware/stack.rb +77 -0
data/lib/jets/resource/function.rb +1 -1
data/lib/jets/ruby_server.rb +1 -1
data/lib/jets/server.rb +48 -13
data/lib/jets/version.rb +1 -1
metadata +24 -17
data/lib/jets/application/middleware.rb +0 -23
data/lib/jets/default/application.rb +0 -23
data/lib/jets/rack.rb +0 -7
data/lib/jets/rack/server.rb +0 -47
data/lib/jets/server/api_gateway.rb +0 -39
data/lib/jets/server/timing_middleware.rb +0 -33
data/lib/jets/timing.rb +0 -65
data/lib/jets/timing/report.rb +0 -82

data/lib/jets/controller/middleware.rb ADDED

@@ -0,0 +1,4 @@
+module Jets::Controller::Middleware
+  autoload :Local, "jets/controller/middleware/local"
+  autoload :Main, "jets/controller/middleware/main"
+end

data/lib/jets/controller/middleware/local.rb ADDED

@@ -0,0 +1,119 @@
+require 'kramdown'
+# Handles mimicking of API Gateway to Lambda function call locally
+module Jets::Controller::Middleware
+  class Local
+    extend Memoist
+    autoload :ApiGateway, 'jets/controller/middleware/local/api_gateway'
+    autoload :MimicAwsCall, 'jets/controller/middleware/local/mimic_aws_call'
+    autoload :RouteMatcher, 'jets/controller/middleware/local/route_matcher'
+    def initialize(app)
+      @app = app
+    end
+    def call(env)
+      route = RouteMatcher.new(env).find_route
+      unless route
+        return [404, {'Content-Type' => 'text/html'}, not_found(env)]
+      end
+      mimic = MimicAwsCall.new(route, env)
+      # Make @controller and @meth instance available so we dont not have to pass it around.
+      @controller, @meth, @event = mimic.controller, mimic.meth, mimic.event
+      if route.to == 'jets/rack#process' # megamode
+        # Bypass the Jets middlewares since it could interfere with the Rack
+        # application's middleware stack.
+        #
+        # Rails sends back a transfer-encoding=chunked. Curling Rails directly works,
+        # but passing the Rails response back through this middleware results in errors.
+        # Disable chunking responses by deleting the transfer-encoding response header.
+        # Would like to understand why this happens this better, if someone can explain please let me know.
+        status, headers, body = @controller.dispatch! # jets/rack_controller
+        headers.delete "transfer-encoding"
+        [status, headers, body]
+      elsif polymorphic_function?
+        # Will never hit when calling polymorphic function on AWS Lambda.
+        # This can only really get called with the local server.
+        run_polymophic_function
+      else # Normal Jets request
+        mimick_aws_lambda!(env, mimic.vars) unless on_aws?(env)
+        @app.call(env)
+      end
+    end
+    def polymorphic_function?
+      polymorphic_function.task.lang != :ruby
+    end
+    def polymorphic_function
+      # Abusing PolyFun to run polymorphic code, should call LambdaExecutor directly
+      # after reworking LambdaExecutor so it has a better interface.
+      Jets::PolyFun.new(@controller.class, @meth)
+    end
+    memoize :polymorphic_function
+    def run_polymophic_function
+      resp = polymorphic_function.run(@event, @meth) # polymorphic code
+      status = resp['statusCode']
+      headers = resp['headers']
+      body = StringIO.new(resp['body'])
+      [status, headers, body] # triplet
+    end
+    # Modifies env the in the same way real call from AWS lambda would modify env
+    def mimick_aws_lambda!(env, vars)
+      env.merge!(vars)
+      env
+    end
+    def on_aws?(env)
+      return false if ENV['TEST'] # usually with test we're passing in full API Gateway fixtures with the HTTP_X_AMZN_TRACE_ID
+      !!env['HTTP_X_AMZN_TRACE_ID']
+    end
+    def routes_error_message(env)
+      message = "<h2>404 Error: Route #{env['PATH_INFO'].sub('/','')} not found</h2>"
+      if Jets.env != "production"
+        message << "<p>Here are the routes defined in your application:</p>"
+        message << "#{routes_table}"
+      end
+      message
+    end
+    def not_found(env)
+      message = routes_error_message(env)
+      body = <<~HTML
+        <!DOCTYPE html>
+        <html>
+            <head>
+                <meta charset="utf-8">
+                <title>Route not found</title>
+            </head>
+            <body>
+              #{message}
+            </body>
+        </html>
+      HTML
+      StringIO.new(body)
+    end
+    # Show pretty route table for user to help with debugging in non-production mode
+    def routes_table
+      routes = Jets::Router.routes
+      return "Your routes table is empty." if routes.empty?
+      text = "Verb | Path | Controller#action\n"
+      text << "--- | --- | ---\n"
+      routes.each do |route|
+        text << "#{route.method} | #{route.path} | #{route.to}\n"
+      end
+      html = Kramdown::Document.new(text).to_html
+      puts html
+      html
+    end
+  end
+end

data/lib/jets/{server/lambda_aws_proxy.rb → controller/middleware/local/api_gateway.rb} RENAMED

@@ -1,38 +1,13 @@
-require 'cgi'
-require 'stringio'
+# Takes a Rack env and converts to ApiGateway event
+class Jets::Controller::Middleware::Local
+  class ApiGateway
+    extend Memoist
-class Jets::Server
-  # This doesnt really need to be middleware
-  class LambdaAwsProxy
     def initialize(route, env)
-      @route = route
-      @env = env
-      # puts "Rack env:".colorize(:yellow)
-      # @env.each do |k,v|
-      #   puts "#{k}: #{v}"
-      # end
+      @route, @env = route, env
     end
-    def response
-      event = build_event
-      context = {}
-      controller_class = find_controller_class
-      controller_action = find_controller_action
-      fun = Jets::PolyFun.new(controller_class, controller_action)
-      resp = fun.run(event, context) # check the logs for polymorphic function errors
-      # Map lambda proxy response format to rack format
-      status = resp["statusCode"]
-      headers = resp["headers"] || {}
-      headers = {'Content-Type' => 'text/html'}.merge(headers)
-      body = resp["body"]
-      [status, headers, [body]]
-    end
-    def build_event
+    def event
       resource = @route.path(:api_gateway) # posts/{id}/edit
       path = @env['PATH_INFO'].sub('/','') # remove beginning slash
       {
@@ -48,6 +23,7 @@ class Jets::Server
         "isBase64Encoded" => false,
       }
     end
+    memoize :event
     # Annoying. The headers part of the AWS Lambda proxy structure
     # does not consisently use the same casing scheme for the header keys.
@@ -97,12 +73,6 @@ class Jets::Server
         end
       end
-      # Way to fake X-Amzn-Trace-Id which on_aws? helper checks.
-      # This is how we distinguish a request from API gateway vs local.
-      if ENV['JETS_ON_AWS']
-        headers["X-Amzn-Trace-Id"] = "Root=fake-trace-id"
-      end
       headers
     end
@@ -114,21 +84,13 @@ class Jets::Server
     #   rack.input: #<StringIO:0x007f8ccf8db9a0>
     def get_body
       # @env["rack.input"] is always provided by rack and we should make
-      # the test data always have rack.input to mimic rack, but but handling
-      # it this way because it's simpler.
+      # the test data always have rack.input to mimic rack defaulting to
+      # StringIO.new to help make testing easier
       input = @env["rack.input"] || StringIO.new
       body = input.read
-      # return nil for blank string, because thats what Lambda AWS_PROXY does
+      input.rewind # IMPORTANT or else it screws up other middlewares that use the body
+      # return nil for blank string, because Lambda AWS_PROXY does this
       body unless body.empty?
     end
-    def find_controller_class
-      # posts#edit => PostsController
-      @route.controller_name.constantize
-    end
-    def find_controller_action
-      @route.action_name
-    end
   end
 end

data/lib/jets/controller/middleware/local/mimic_aws_call.rb ADDED

@@ -0,0 +1,38 @@
+class Jets::Controller::Middleware::Local
+  class MimicAwsCall
+    extend Memoist
+    def initialize(route, env)
+      @route, @env = route, env
+    end
+    def vars
+      {
+        'jets.controller' => controller,
+        'lambda.context' => context,
+        'lambda.event' => event,
+        'lambda.meth' => meth,
+      }
+    end
+    # Actual controller instance
+    def controller
+      controller_class = @route.controller_name.constantize
+      meth = @route.action_name
+      controller_class.new(event, context, meth)
+    end
+    def meth
+      @route.action_name
+    end
+    def event
+      ApiGateway.new(@route, @env).event
+    end
+    memoize :event
+    def context
+      {}
+    end
+  end
+end

data/lib/jets/{server → controller/middleware/local}/route_matcher.rb RENAMED

@@ -1,4 +1,4 @@
-class Jets::Server
+class Jets::Controller::Middleware::Local
   class RouteMatcher
     def initialize(env)
       @env = env
@@ -12,14 +12,14 @@ class Jets::Server
       # Within these 2 groups we consider the routes with the longest path first
       # since posts/:id and posts/:id/edit can both match.
       routes = router.ordered_routes
-      route = routes.find do |route|
-        route_found?(route)
+      route = routes.find do |r|
+        route_found?(r)
       end
       route
     end
     def route_found?(route)
-      request_method = @env["REQUEST_METHOD"]
+      request_method = @env["REQUEST_METHOD"] || "GET"
       actual_path = @env["PATH_INFO"].sub(/^\//,'') # remove beginning slash
       # Immediately stop checking when the request method: GET, POST, ANY, etc

data/lib/jets/controller/middleware/main.rb ADDED

@@ -0,0 +1,46 @@
+# All roads lead here
+#
+# 1. AWS Lambda: PostsController - Rack::Adapter - Jets.application.call
+# 2. Local server:  config.ru - run Jet.application - Jets.application.call
+#
+# Then eventually:
+#
+#   Jets.application.call - Middleware stack - Jets::Controller::Middleware::Main
+#
+module Jets::Controller::Middleware
+  class Main
+    def initialize(env)
+      @env = env
+      @controller = env['jets.controller']
+      @event = env['lambda.event']
+      @context = env['lambda.context']
+      @meth = env['lambda.meth']
+    end
+    def call
+      dup.call!
+    end
+    def call!
+      setup
+      @controller.dispatch! # Returns triplet
+    end
+    # Common setup logical at this point of middleware processing right before
+    # calling any controller actions.
+    def setup
+      # We already recreated a mimicke rack env earlier as part of the very first
+      # middleware layer. However, by the time the rack env reaches the main middleware
+      # it could had been updated by other middlewares. We update the env here again.
+      @controller.request.set_env!(@env)
+      # This allows sesison helpers to work. Sessions are managed by
+      # the Rack::Session::Cookie middleware by default.
+      @controller.session = @env['rack.session'] || {}
+    end
+    def self.call(env)
+      instance = new(env)
+      instance.call
+    end
+  end
+end

data/lib/jets/{server → controller/middleware}/webpacker_setup.rb RENAMED

@@ -4,4 +4,3 @@ require "webpacker"
 require "webpacker/dev_server_proxy"
 Webpacker.bootstrap # whenever jets server is runs should Webpacker.bootstrap

data/lib/jets/controller/params.rb CHANGED

@@ -1,4 +1,5 @@
 require "action_controller/metal/strong_parameters"
+require "rack"
 class Jets::Controller
   module Params
@@ -39,7 +40,7 @@ class Jets::Controller
       # API Gateway seems to use either: content-type or Content-Type
       content_type = headers["content-type"]
       if content_type.to_s.include?("application/x-www-form-urlencoded")
-        return Rack::Utils.parse_nested_query(body)
+        return ::Rack::Utils.parse_nested_query(body)
       end
       {} # fallback to empty Hash

data/lib/jets/controller/rack.rb ADDED

@@ -0,0 +1,5 @@
+module Jets::Controller::Rack
+  autoload :Adapter, "jets/controller/rack/adapter"
+  autoload :Env, "jets/controller/rack/env"
+  autoload :Middleware, "jets/controller/rack/middleware"
+end

data/lib/jets/controller/rack/adapter.rb ADDED

@@ -0,0 +1,60 @@
+module Jets::Controller::Rack
+  class Adapter
+    extend Memoist
+    # Returns back API Gateway response hash structure
+    def self.process(event, context, meth)
+      adapter = new(event, context, meth)
+      adapter.process
+    end
+    def initialize(event, context, meth)
+      @event, @context, @meth = event, context, meth
+    end
+    # 1. Convert API Gateway event event to Rack env
+    # 2. Process using full Rack middleware stack
+    # 3. Convert back to API gateway response structure payload
+    def process
+      status, headers, body = Jets.application.call(env)
+      convert_to_api_gateway(status, headers, body)
+    end
+    def env
+      Env.new(@event, @context).convert # convert to Rack env
+    end
+    memoize :env
+    # Transform the structure to AWS_PROXY compatiable structure
+    # http://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-output-format
+    def convert_to_api_gateway(status, headers, body)
+      base64 = headers["x-jets-base64"] == 'true'
+      body = body.respond_to?(:read) ? body.read : body
+      {
+        "statusCode" => status,
+        "headers" => headers,
+        "body" => body,
+        "isBase64Encoded" => base64,
+      }
+    end
+    # Called from Jets::Controller::Base.process. Example:
+    #
+    #   adapter.rack_vars(
+    #     'jets.controller' => self,
+    #     'lambda.context' => context,
+    #     'lambda.event' => event,
+    #     'lambda.meth' => meth,
+    #   )
+    #
+    # Passes a these special variables so we have access to them in the middleware.
+    # The controller instance is called in the Main middleware.
+    # The lambda.* info is used by the Rack::Local middleware to create a mimicked
+    # controller for the local server.
+    #
+    def rack_vars(vars)
+      env.merge!(vars)
+    end
+  end
+end

data/lib/jets/controller/rack/env.rb ADDED

@@ -0,0 +1,96 @@
+require 'rack'
+# Takes an ApiGateway event and converts it to an Rack env that can be used for
+# rack.call(env).
+module Jets::Controller::Rack
+  class Env
+    def initialize(event, context)
+      @event, @context = event, context
+    end
+    def convert
+      options = {}
+      options = add_top_level(options)
+      options = add_http_headers(options)
+      path = @event['path'] || '/' # always set by API Gateway but might not be when testing shim, so setting it to make testing easier
+      Rack::MockRequest.env_for(path, options)
+    end
+  private
+    def add_top_level(options)
+      map = {
+        'CONTENT_TYPE' => content_type,
+        'QUERY_STRING' => query_string,
+        'REMOTE_ADDR' => headers['X-Forwarded-For'],
+        'REMOTE_HOST' => headers['Host'],
+        'REQUEST_METHOD' => @event['httpMethod'],
+        'REQUEST_PATH' => @event['path'],
+        'REQUEST_URI' => request_uri,
+        'SCRIPT_NAME' => "",
+        'SERVER_NAME' => headers['Host'],
+        'SERVER_PORT' => headers['X-Forwarded-Port'],
+        'SERVER_PROTOCOL' => "HTTP/1.1",  # unsure if this should be set
+        'SERVER_SOFTWARE' => "WEBrick/1.3.1 (Ruby/2.2.2/2015-04-13)",
+      }
+      map['CONTENT_LENGTH'] = content_length if content_length
+      # Even if not set, Rack always assigns an StringIO to "rack.input"
+      map[:input] = StringIO.new(body) if body
+      # TODO: handle decoding base64 encoded body from API Gateaway
+      # Will need to make sure that pass the base64 info via a request header
+      options.merge(map)
+    end
+    def content_type
+      headers['Content-Type'] || Jets::Controller::DEFAULT_CONTENT_TYPE
+    end
+    def content_length
+      bytesize = body.bytesize.to_s if body
+      headers['Content-Length'] || bytesize
+    end
+    def body
+      @event['body']
+    end
+    def add_http_headers(options)
+      headers.each do |k,v|
+        # content-type => HTTP_CONTENT_TYPE
+        key = k.gsub('-','_').upcase
+        key = "HTTP_#{key}"
+        options[key] = v
+      end
+      options
+    end
+    def request_uri
+      # IE: "http://localhost:8888/posts/tung/edit?foo=bar"
+      proto = headers['X-Forwarded-Proto']
+      host = headers['Host']
+      port = headers['X-Forwarded-Port']
+      # Add port if needed
+      if proto == 'https' && port != '443' or
+         proto == 'http'  && port != '80'
+        host = "#{host}:#{port}"
+      end
+      path = @event['path']
+      qs = "?#{query_string}" unless query_string.empty?
+      "#{proto}://#{host}#{path}#{qs}"
+    end
+    def query_string
+      qs_params = @event["queryStringParameters"] || {} # always set with API Gateway but when testing node shim might not be
+      hash = Jets::Mega::HashConverter.encode(qs_params)
+      hash.to_query
+    end
+    def headers
+      @event['headers'] || {}
+    end
+  end
+end