jets 5.0.14 → 6.0.0.beta1

data/lib/jets/shim/adapter/base.rb

@@ -0,0 +1,16 @@
+require "active_support/core_ext/hash"
+require "base64"
+
+module Jets::Shim::Adapter
+  class Base
+    extend Memoist
+    include Jets::Util::Logging
+
+    attr_reader :event, :context, :target
+    def initialize(event, context = nil, target = nil)
+      @event = ActiveSupport::HashWithIndifferentAccess.new(event)
+      @context = context
+      @target = target # IE: cool_event.party
+    end
+  end
+end

data/lib/jets/shim/adapter/command.rb

@@ -0,0 +1,21 @@
+require "open3"
+
+module Jets::Shim::Adapter
+  class Command < Base
+    def handle
+      cmd = event[:command]
+      result = {stdout: "", stderr: ""}
+      # splat works for both String and Array
+      Open3.popen3(*cmd) do |stdin, stdout, stderr, wait_thread|
+        result[:stdout] << stdout.read
+        result[:stderr] << stderr.read
+        result[:status] = wait_thread.value.exitstatus
+      end
+      result
+    end
+
+    def handle?
+      event[:command]
+    end
+  end
+end

data/lib/jets/shim/adapter/event.rb

@@ -0,0 +1,27 @@
+module Jets::Shim::Adapter
+  class Event < Base
+    def handle
+      target_class.handle(event, context, target_method)
+    end
+
+    def handle?
+      target && target_class && target_method?
+    end
+
+    def target_class
+      class_name, _ = target.split(".")
+      class_name.camelize.constantize
+    rescue NameError
+    end
+
+    def target_method
+      _, method_name = target.split(".")
+      method_name ||= "perform"
+      method_name.to_sym
+    end
+
+    def target_method?
+      target_class.public_instance_methods.include?(target_method)
+    end
+  end
+end

data/lib/jets/shim/adapter/fallback.rb

@@ -0,0 +1,64 @@
+module Jets::Shim::Adapter
+  class Fallback < Base
+    def handle
+      fallback_handler.handler(event, context, target)
+    end
+
+    def fallback_handler
+      Jets::Shim.config.fallback_handler || self.class
+    end
+    memoize :fallback_handler
+
+    class << self
+      def handler(event, context = nil, target = nil)
+        puts "The default fallback handler is being called because a handler for it could not be found"
+        puts "For debugging, here is the"
+        if ENV["_HANDLER"] # on AWS Lambda
+          puts "event: #{JSON.dump(event)}"
+        else
+          puts "event:"
+          puts JSON.pretty_generate(event)
+        end
+        puts "Please double check the event payload.\n\n"
+
+        if target
+          puts "ERROR: event handler target not found: #{target}".color(:red)
+          target_class, target_method = target.split(".")
+          target_class = target_class.camelize
+          target_method ||= "perform"
+          puts <<~EOL
+            You can configure define an app/events handler in your application. Example:
+
+            app/events/#{target_class.underscore}.rb
+
+                class #{target_class} < ApplicationEvent
+                  def #{target_method}
+                    puts "event #{JSON.dump(event)}"
+                  end
+                end
+          EOL
+
+        else
+          puts <<~EOL
+            You can also configure a custom fallback handler in the config/jets/shim.rb file.
+            Example:
+
+            config/jets/shim.rb
+
+                Jets.shim.configure do |config|
+                  config.fallback_handler = FallbackHandler
+                end
+
+            FallbackHandler should implement handler(event, context)
+
+          EOL
+        end
+        # Custom Jets error message
+        {
+          errorMessage: "event handler not found. Look at logs for details",
+          errorType: "JetsEventHandlerNotFound"
+        }
+      end
+    end
+  end
+end

data/lib/jets/shim/adapter/lambda.rb

@@ -0,0 +1,35 @@
+module Jets::Shim::Adapter
+  class Lambda < Web
+    def env
+      {
+        # Request env keys
+        "HTTP_HOST" => host,
+        "HTTP_PORT" => headers["x-forwarded-port"],
+        "HTTPS" => https,
+        "PATH_INFO" => path_info,
+        "QUERY_STRING" => query_string,
+        "REQUEST_METHOD" => event.dig("requestContext", "http", "method") || "GET", # useful to default to GET when testing with Lambda console
+        "REQUEST_PATH" => path_info,
+        "SCRIPT_NAME" => "",
+        "SERVER_NAME" => host,
+        "SERVER_PORT" => headers["x-forwarded-proto"],
+        "SERVER_PROTOCOL" => event.dig("requestContext", "http", "protocol") || "HTTP/1.1"
+      }
+    end
+
+    def handle?
+      host =~ /lambda-url/ ||
+        event["version"] && event["routeKey"]
+    end
+
+    private
+
+    def path_info
+      event["rawPath"] || "/"
+    end
+
+    def query_string
+      event["rawQueryString"] || ""
+    end
+  end
+end

data/lib/jets/shim/adapter/prewarm.rb

@@ -0,0 +1,27 @@
+module Jets::Shim::Adapter
+  class Prewarm < Base
+    @@prewarm_count = 0
+    @@prewarm_at = nil
+
+    def handle
+      @@prewarm_count += 1
+      @@prewarm_at = Time.now.utc
+      result = self.class.stats
+      log.info "Prewarm request: #{JSON.dump(result)}" if ENV["JETS_PREWARM_LOG"]
+      result
+    end
+
+    def handle?
+      event["_prewarm"]
+    end
+
+    def self.stats
+      {
+        boot_at: Jets::Core::Booter.boot_at,
+        gid: Jets::Core::Booter.gid,
+        prewarm_at: @@prewarm_at,
+        prewarm_count: @@prewarm_count
+      }
+    end
+  end
+end

data/lib/jets/shim/adapter/web.rb

@@ -0,0 +1,145 @@
+require "rack"
+require "uri"
+
+module Jets::Shim::Adapter
+  # Not named Rack to avoid confusion with the Rack gem
+  class Web < Base
+    def handle
+      env = to_rack_env
+      app = Jets::Shim.config.app
+      triplet = app.call(env)
+      translate_response(triplet)
+    end
+
+    def to_rack_env
+      rack_env = base_env.merge(env).merge(headers_env)
+      rack_env.delete_if { |k, v| v.nil? }
+      rack_env
+    end
+
+    # Translate rack triplet to compatible response for the service
+    def translate_response(triplet)
+      adapter_name = self.class.name.split("::").last
+      response_class = Jets::Shim::Response.const_get(adapter_name)
+      response = response_class.new(triplet)
+      response.translate
+    end
+
+    # env should be implemented by subclass
+    def env
+      {}
+    end
+    private :env
+
+    def headers_env
+      env = {}
+      headers.each do |k, v|
+        key = k.tr("-", "_").upcase
+        http_key = "HTTP_#{key}" # IE: User-Agent => HTTP_USER_AGENT
+
+        # specially handle host since it can be overridden with JETS_SHIM_HOST
+        next if http_key == "HTTP_HOST"
+
+        if special_headers.include?(key)
+          env[special_headers[key]] = v
+        else
+          env[http_key] ||= v
+        end
+      end
+      env
+    end
+
+    def special_headers
+      # Note: apigw does not have content-length in headers.
+      # See: https://stackoverflow.com/questions/56693981/how-do-i-get-http-header-content-length-in-api-gateway-lambda-proxy-integratio
+      #
+      # Instead content-length must be calculated from body. Done in base_env.
+      # Adding content-length here for other adapters.
+      # Headers have highest precedence since they get merged last.
+      {
+        "CONTENT_TYPE" => "CONTENT_TYPE",
+        "CONTENT_LENGTH" => "CONTENT_LENGTH"
+      }
+    end
+
+    def base_env
+      # 'rack.input' - Even if not set, Rack always assigns an StringIO.
+      {
+        "CONTENT_LENGTH" => content_length,
+        "HTTP_COOKIE" => http_cookie,
+        "lambda.context" => context,
+        "lambda.event" => event,
+        "rack.input" => StringIO.new(body || ""),
+        "REMOTE_ADDR" => remote_addr,
+        "REMOTE_HOST" => host,
+        "REQUEST_URI" => request_uri
+      }
+    end
+
+    # https://docs.aws.amazon.com/lambda/latest/dg/urls-invocation.html
+    # https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html#http-api-develop-integrations-lambda.proxy-format
+    def http_cookie
+      event["cookies"]&.join("; ")
+    end
+
+    def remote_addr
+      # X-Forwarded-For: client, proxy1, proxy2
+      # X-Forwarded-For:
+      #   The originating IP address of the client connecting to the ALB.
+      #   This is used to capture the client IP address for requests that are sent to a proxy chain or a load balancer
+      #   before they reach your server.
+      #   If the X-Forwarded-For header is not present in the request, the remote IP address from the transport layer,
+      #   such as the TCP connection, is used instead.
+      #   https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-access-logs.html#access-log-entry-format
+      addr = headers["X-Forwarded-For"] || headers["x-forwarded-for"] || headers["REMOTE_ADDR"]
+      addr.split(",").first.strip if addr
+    end
+
+    def content_length
+      bytesize = body.bytesize.to_s if body
+      headers["Content-Length"] || bytesize
+    end
+
+    def request_uri
+      # IE: /foo?bar=1
+      "#{path_info}?#{query_string}"
+    end
+
+    # Decoding base64 from API Gateaway if necessary
+    # Rack will be none the wiser
+    def body
+      if event["isBase64Encoded"]
+        Base64.decode64(event["body"])
+      else
+        event["body"]
+      end
+    end
+
+    def headers
+      event["headers"] || {}
+    end
+
+    def host
+      # Host: apigw
+      # host: lambda and alb
+      ENV["JETS_SHIM_HOST"] ||
+        shim_host ||
+        headers["Host"] ||
+        headers["host"]
+    end
+
+    # Can be added by CloudFront function
+    # Also, POST requests have an origin header. IE: Updating a record with CRUD.
+    def shim_host
+      return unless headers["jets-shim-host"]
+      URI.parse(headers["jets-shim-host"]).host
+    end
+
+    def https
+      # X-Forwarded-Proto: apigw
+      # x-forwarded-proto: lambda and alb
+      proto = headers["X-Forwarded-Proto"] || headers["x-forwarded-proto"]
+      (proto == "https") ? "on" : "off"
+    end
+  end
+end

data/lib/jets/shim/config.rb

@@ -0,0 +1,71 @@
+require "singleton"
+
+module Jets::Shim
+  class Config
+    extend Memoist
+    include Singleton
+
+    attr_reader :boot_path
+    attr_accessor :fallback_handler, :adapter
+    attr_writer :rack_app
+
+    def boot_path=(value)
+      @boot_path = value # dont include ./ in @boot_path. @boot_path can be used to infer the rack_app class name
+      # Immediately require the boot_path so that rack_app is available for reference
+      require_boot_path(value)
+    end
+
+    def rack_app
+      if Maintenance.enabled?
+        Maintenance.app
+      elsif @rack_app
+        @rack_app
+      else
+        boot_path = @boot_path || infer_boot_path
+        # Possible that boot_path is nil.
+        # Case: Jets events app only.
+        if boot_path
+          require_boot_path(boot_path) if boot_path # in case boot_path is not set
+          infer_rack_app(boot_path) # IE: Rails.application or App
+        end
+      end
+    end
+    alias_method :app, :rack_app
+    alias_method :app=, :rack_app=
+
+    def infer_boot_path
+      if rails?
+        "config/environment"
+      elsif File.exist?("app.rb")
+        "app"
+      end
+    end
+
+    def require_boot_path(path)
+      path = path.starts_with?(".") ? path : "./#{path}"
+      path = path.ends_with?(".rb") ? path : "#{path}.rb"
+      require path # IE: config/environment.rb (Rails) or app.rb (generic rack app)
+    end
+
+    def infer_rack_app(boot_path)
+      if rails?
+        Rails.application
+      else
+        boot_path.sub!(/\.rb$/, "") # remove .rb extension
+        boot_path.camelize.constantize
+      end
+    end
+
+    def rails?
+      framework?(:rails)
+    end
+
+    def framework?(name)
+      if File.exist?("config.ru")
+        # IE: Jets.application or Rails.application
+        IO.readlines("config.ru").any? { |l| l.include?("#{name.to_s.camelize}.application") }
+      end
+    end
+    memoize :framework?
+  end
+end

data/lib/jets/shim/handler.rb

@@ -0,0 +1,60 @@
+module Jets::Shim
+  class Handler
+    include Jets::Util::Logging
+
+    attr_reader :event, :context, :target
+    def initialize(event, context = nil, target = nil)
+      @event = event.deep_stringify_keys
+      @context = context
+      @target = target # IE: cool_event.party
+    end
+
+    def handle
+      show_debug_shim_event
+      adapter.handle
+    end
+
+    def adapter
+      adapter_class = Adapter.const_get(adapter_name.to_s.camelize)
+      log.info "jets shim adapter: #{adapter_name}" if ENV["JETS_DEBUG_SHIM"]
+      adapter_class.new(event, context, target) # IE: Adapter::Apigw
+    end
+
+    protected
+
+    def adapter_name
+      Jets::Shim.config.adapter || infer_adapter
+    end
+
+    def infer_adapter
+      adapters = %w[lambda apigw alb prewarm command event]
+      adapters.each do |adapter_name|
+        adapter_class = Adapter.const_get(adapter_name.to_s.camelize)
+        return adapter_name if adapter_class.new(event, context, target).handle?
+      end
+      :fallback
+    end
+
+    def show_debug_shim_event
+      self.class.show_debug_shim("jets shim event:", event)
+    end
+
+    class << self
+      include Jets::Util::Logging
+
+      # interface method used by Shim::Response::Base
+      def show_debug_shim(message, payload)
+        return unless ENV["JETS_DEBUG_SHIM"]
+
+        log.info message
+        # pretty mode is not useful on CloudWatch since it strips the surrounding spaces on each line
+        # It's only useful for testing handlers locally
+        if ENV["JETS_DEBUG_SHIM"] == "pretty"
+          log.info JSON.pretty_generate(payload)
+        else
+          log.info JSON.dump(payload) # json one line
+        end
+      end
+    end
+  end
+end

data/lib/jets/shim/maintenance/maintenance.html

@@ -0,0 +1,45 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Maintenance Page</title>
+  <style>
+    body {
+      font-family: Arial, sans-serif;
+      background-color: #f4f4f9;
+      color: #333;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      height: 100vh;
+      margin: 0;
+    }
+
+    .container {
+      text-align: center;
+      padding: 20px;
+      border-radius: 10px;
+      background: white;
+      box-shadow: 0 0 15px rgba(0, 0, 0, 0.1);
+    }
+
+    h1 {
+      color: #2c3e50;
+    }
+
+    p {
+      color: #34495e;
+    }
+  </style>
+</head>
+
+<body>
+  <div class="container">
+    <h1>We'll be back soon!</h1>
+    <p>We're currently undergoing some maintenance. Thank you for your patience. Please check back later!</p>
+  </div>
+</body>
+
+</html>

data/lib/jets/shim/maintenance.rb

@@ -0,0 +1,37 @@
+module Jets::Shim
+  class Maintenance
+    class << self
+      extend Memoist
+      include Jets::Util::Truthy
+
+      def app
+        self
+      end
+
+      def call(env)
+        [503, {"Content-Type" => content_type}, [body]]
+      end
+
+      # IE: application/json; charset=utf-8
+      # IE: text/html
+      def content_type
+        maintenance_file.end_with?("json") ? "application/json" : "text/html"
+      end
+
+      def body
+        IO.read(maintenance_file)
+      end
+
+      def maintenance_file
+        default_path = "#{__dir__}/maintenance/maintenance.html"
+        paths = %w[public/maintenance.html public/maintenance.json]
+        paths.find { |path| File.exist?(path) } || default_path
+      end
+      memoize :maintenance_file
+
+      def enabled?
+        truthy?(ENV["JETS_MAINTENANCE"])
+      end
+    end
+  end
+end

data/lib/jets/shim/response/alb.rb

@@ -0,0 +1,10 @@
+module Jets::Shim::Response
+  class Alb < Apigw
+    def translate
+      hash = super
+      desc = Rack::Utils::HTTP_STATUS_CODES[hash[:statusCode]]
+      hash[:statusDescription] = "#{hash[:statusCode]} #{desc}"
+      hash
+    end
+  end
+end

data/lib/jets/shim/response/apigw.rb

@@ -0,0 +1,4 @@
+module Jets::Shim::Response
+  class Apigw < Base
+  end
+end

data/lib/jets/shim/response/base.rb

@@ -0,0 +1,124 @@
+require "active_support"
+require "active_support/core_ext/string"
+require "base64"
+require "json"
+require "mime/types"
+require "rack"
+
+module Jets::Shim::Response
+  class Base
+    include Jets::Util::Logging
+    include Jets::Util::Truthy
+
+    def initialize(triplet)
+      @triplet = triplet
+    end
+
+    # AWS Lambda proxy integrations 2.0
+    # https://docs.aws.amazon.com/lambda/latest/dg/urls-invocation.html
+    # https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html#http-api-develop-integrations-lambda.proxy-format
+    def translate
+      status, headers, rack_body = @triplet
+      headers.merge!(prewarm_headers)
+      cookies = handle_set_cookie!(headers)
+      stringify_values!(headers)
+      body = translate_body(rack_body)
+      base64 = base64_encode?(headers)
+      if base64
+        body = Base64.strict_encode64(body)
+      end
+      resp = {
+        statusCode: status,
+        headers: headers, # response headers
+        body: body,
+        cookies: cookies,
+        isBase64Encoded: base64
+      }.delete_if { |k, v| v.nil? }
+      show_debug_shim_resp(resp)
+      resp
+    end
+
+    private
+
+    # Example headers:
+    # {
+    #   "x-jets-prewarm-count"=>1,
+    #   "x-jets-prewarm-at"=>"2024-04-18 12:11:37 UTC",
+    #   "x-jets-gid"=>"1bd5d993"
+    # }
+    def prewarm_headers
+      Jets::Shim::Adapter::Prewarm.stats.transform_keys { |k| "x-jets-#{k.to_s.dasherize}" }
+    end
+
+    def handle_set_cookie!(headers)
+      # Interesting: Both headers['Set-Cookie'] and headers['set-cookie'] work.
+      # Rack is smart enough to handle both. Also, Rack either returns a String
+      # for a single cookie or Array for multiple cookies.
+      # Must handle both Set-Cookie and set-cookie Rails seems to be inconsistent
+      # Locally: Set-Cookie
+      # AWS Lambda: set-cookie
+      set_cookie = headers.delete("Set-Cookie") || headers.delete("set-cookie")
+      return unless set_cookie
+
+      # AWS Lambda proxy integrations 2.0 requires cookies to be an array
+      # https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html#http-api-develop-integrations-lambda.proxy-format
+      if set_cookie.is_a?(String)
+        # set_cookie is a single cookie String
+        # IE: "yummy_cookie=choco"
+        set_cookie.split("\n").map(&:strip)
+      else
+        # set_cookie is already cookies Array
+        # IE: ["yummy_cookie=choco", "tasty_cookie=strawberry"]
+        set_cookie
+      end
+    end
+
+    def stringify_values!(headers)
+      headers.each do |k, v|
+        headers[k] = v.to_s
+      end
+      headers
+    end
+
+    # Rack middleware handles Array or BodyProxy normally, but APIGW require String
+    def translate_body(rack_body)
+      case rack_body
+      when Rack::Files::Iterator
+        # Sinatra does not always send the right content-type header so we check the file extension
+        # ActiveStorage does not always have file extensions so will have to check the content-type header also
+        @encode_binary = binary?(rack_body.path) # set flag for base64_encode?
+        File.read(rack_body.path)
+      else # Rack::BodyProxy or Array
+        body = "" # String
+        rack_body.each { |part| body << part.to_s }
+        body
+      end
+    end
+
+    def binary?(file_path)
+      mime_type = MIME::Types.type_for(file_path).first
+      mime_type&.binary?
+    end
+
+    # Headers or @encode_binary flag is determine if body should be base64 encoded.
+    # Note: mime_type.binary? is not always accurate.
+    # Example: render json: {ok: true} is not binary but mime_type.binary? is true
+    def base64_encode?(headers)
+      return @encode_binary if @encode_binary
+      if headers.key?("x-jets-base64")
+        return truthy?(headers["x-jets-base64"])
+      end
+      return true if Jets.project.config.base64_encode
+
+      content_type = headers["content-type"]
+      if content_type
+        mime_type = MIME::Types[content_type].first
+        mime_type.encoding == "base64"
+      end
+    end
+
+    def show_debug_shim_resp(resp)
+      Jets::Shim::Handler.show_debug_shim("jets shim response:", resp)
+    end
+  end
+end