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

jets 1.0.18 → 1.1.0

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