LFA 0.2.0

data/lib/LFA/adapter/lambda_rack_bridge.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'cgi'
+require 'stringio'
+
+module LFA
+  class Adapter
+    module LambdaRackBridge
+      def request_path(env:)
+        env["REQUEST_PATH"]
+      end
+
+      def http_method(env:)
+        env["REQUEST_METHOD"]
+      end
+
+      def lambda_event(env:, path_parameters:)
+        headers, mv_headers = build_headers(env)
+        query_params, mv_query_params = build_query_params(env)
+        {
+          "resource"   => env["REQUEST_PATH"],
+          "path"       => env["REQUEST_PATH"],
+          "httpMethod" => env["REQUEST_METHOD"],
+          "headers"           => headers,
+          "multiValueHeaders" => mv_headers,
+          "queryStringParameters"           => query_params,
+          "multiValueQueryStringParameters" => mv_query_params,
+          "pathParameters" => path_parameters, # set when path parameters are supported
+          "stageVariables" => nil, # LFA will not support deployments on stages
+          "requestContext" => {},  # skipped for now because it seems not useful...
+          "body" => env["rack.input"],
+          "isBase64Encoded" => false, # always false about request? true if the request was binary?
+        }
+      end
+
+      def lambda_context(function_name:)
+        LambdaContext.new(function_name)
+      end
+
+      def convert_to_rack_response(resp)
+        ### Lambda output
+        # {
+        #   statusCode: 200,
+        #   body: records.to_json,
+        #   headers: {"content-type" => "application/json"},
+        # }
+        ### Rack response
+        # [200, {"content-type" => "application/json"}, body]
+        body = StringIO.new(resp[:body])
+        [resp[:statusCode], resp[:headers], body]
+      end
+
+      HEADER_ENV_KEYS = ['CONTENT_TYPE', 'CONTENT_LENGTH']
+
+      def build_headers(env)
+        headers = Headers.new
+        multi_value_headers = Headers.new
+        env.keys.each do |env_key_name|
+          next unless env_key_name =~ /^HTTP_/ || HEADER_ENV_KEYS.include?(env_key_name)
+          next if env_key_name == 'HTTP_VERSION'
+          header_name = header_name_from_env_name(env_key_name)
+          value = env[env_key_name]
+          if value.include?(", ")
+            multi_value_headers[header_name] = value.split(", ").select{|s| !s.empty? }.compact
+            headers[header_name] = value.split(", ").select{|s| !s.empty? }.compact.last
+          else
+            multi_value_headers[header_name] = [value]
+            headers[header_name] = value
+          end
+        end
+        return headers, multi_value_headers
+      end
+
+      def build_query_params(env)
+        query = env["QUERY_STRING"]
+        return nil, nil if !query || query.empty?
+
+        multi_value_query_params = CGI.parse(query)
+        query_params = {}
+        multi_value_query_params.each do |key, value|
+          query_params[key] = value.last
+        end
+        return query_params, multi_value_query_params
+      end
+
+      def header_name_from_env_name(name)
+        name.sub('HTTP_', '').gsub('_', '-').downcase
+      end
+
+      class Headers < Hash
+        def [](key)
+          super(key.downcase)
+        end
+
+        def []=(key, value)
+          super(key.downcase, value)
+        end
+
+        def has_key?(key)
+          super(key.downcase)
+        end
+      end
+
+      class LambdaContext
+        # Lambda Context https://docs.aws.amazon.com/lambda/latest/dg/ruby-context.html
+        # Context methods
+        # # get_remaining_time_in_millis – Returns the number of milliseconds left before the execution times out.
+        # Context properties
+        # # function_name – The name of the Lambda function.
+        # # function_version – The version of the function.
+        # # invoked_function_arn – The Amazon Resource Name (ARN) that's used to invoke the function.
+        # #                        Indicates if the invoker specified a version number or alias.
+        # # memory_limit_in_mb – The amount of memory that's allocated for the function.
+        # # aws_request_id – The identifier of the invocation request.
+        # # log_group_name – The log group for the function.
+        # # log_stream_name – The log stream for the function instance.
+        # # deadline_ms– The date that the execution times out, in Unix time milliseconds.
+        # # identity – (mobile apps) Information about the Amazon Cognito identity that authorized the request.
+        # # client_context– (mobile apps) Client context that's provided to Lambda by the client application.
+
+        attr_reader :function_name, :function_version, :invoked_function_arn, :memory_limit_in_mb
+        attr_reader :aws_request_id, :log_group_name, :log_stream_name, :deadline_ms, :identity, :client_context
+
+        def initialize(function_name)
+          @function_name = function_name
+          @function_version = 1
+          @invoked_function_arn = "arn:tagomoris:lambda:ap-northeast-999:0000000000000:function:#{function_name}"
+          @memory_limit_in_mb = 1024 # TODO: configurable?
+          @aws_request_id = SecureRandom.uuid
+          @log_group_name = "/tagomoris/lambda/#{function_name}"
+          @log_stream_name = "2022/12/15[$LATEST]0000000000000000000000"
+          @deadline_ms = 3600 * 1000
+          @identity = nil
+          @client_context = nil
+        end
+
+        def get_remaining_time_in_millis
+          3600 * 1000
+        end
+      end
+
+      # Rack ENV
+      # {
+      #   "rack.version"=>[1, 6],
+      #   "rack.errors"=>obj,#<Rack::Lint::Wrapper::ErrorWrapper:0x0000000107036620 @error=#<IO:<STDERR>>>,
+      #   "rack.multithread"=>true,
+      #   "rack.multiprocess"=>false,
+      #   "rack.run_once"=>false,
+      #   "rack.url_scheme"=>"http",
+      #   "SCRIPT_NAME"=>"",
+      #   "QUERY_STRING"=>"key=value",
+      #   "SERVER_SOFTWARE"=>"puma 6.0.0 Sunflower",
+      #   "GATEWAY_INTERFACE"=>"CGI/1.2",
+      #   "REQUEST_METHOD"=>"GET",
+      #   "REQUEST_PATH"=>"/api/language",
+      #   "REQUEST_URI"=>"/api/language?key=value",
+      #   "SERVER_PROTOCOL"=>"HTTP/1.1",
+      #   "HTTP_HOST"=>"127.0.0.1:9292",
+      #   "HTTP_USER_AGENT"=>"curl/7.79.1",
+      #   "HTTP_ACCEPT"=>"*/*",
+      #   "HTTP_X_YAY"=>"one, two", # Multi value headers
+      #   "puma.request_body_wait"=>0.010000228881835938,
+      #   "SERVER_NAME"=>"127.0.0.1",
+      #   "SERVER_PORT"=>"9292",
+      #   "PATH_INFO"=>"/api/language",
+      #   "REMOTE_ADDR"=>"127.0.0.1",
+      #   "HTTP_VERSION"=>"HTTP/1.1",
+      #   "puma.socket"=>obj,#<TCPSocket:fd 16, AF_INET, 127.0.0.1, 9292>,
+      #   "rack.hijack?"=>true,
+      #   "rack.hijack"=>obj,#<Proc:0x0000000107036a30 /versions/3.1.0/lib/ruby/gems/3.1.0/gems/rack-3.0.2/lib/rack/lint.rb:556>,
+      #   "rack.input"=>obj,#<Rack::Lint::Wrapper::InputWrapper:0x0000000107036710 @input=#<Puma::NullIO:0x0000000106fb4b48>>,
+      #   "rack.after_reply"=>[],
+      #   "puma.config"=>obj,
+      #   "rack.tempfiles"=>[],
+      # }
+
+      # Lambda Event
+      # {
+      #   "resource"=>"/api/raw_data",
+      #   "path"=>"/api/raw_data",
+      #   "httpMethod"=>"GET",
+      #   "headers"=>{
+      #     "accept"=>"*/*", "Host"=>"1jlbwglsci.execute-api.ap-northeast-1.amazonaws.com",
+      #     "User-Agent"=>"curl/7.77.0", "X-Amzn-Trace-Id"=>"Root=1-61d5681d-2f0156ce0aeee3896ab2cf1f",
+      #     "X-Forwarded-For"=>"138.64.70.55", "X-Forwarded-Port"=>"443", "X-Forwarded-Proto"=>"https",
+      #     "x-pathtraq-apikey"=>"711e31a7-5248-45bc-92b8-c39740842a5f"
+      #   },
+      #   "multiValueHeaders"=>{
+      #     "accept"=>["*/*"], "Host"=>["1jlbwglsci.execute-api.ap-northeast-1.amazonaws.com"],
+      #     "User-Agent"=>["curl/7.77.0"], "X-Amzn-Trace-Id"=>["Root=1-61d5681d-2f0156ce0aeee3896ab2cf1f"],
+      #     "X-Forwarded-For"=>["138.64.70.55"], "X-Forwarded-Port"=>["443"], "X-Forwarded-Proto"=>["https"],
+      #     "x-pathtraq-apikey"=>["711e31a7-5248-45bc-92b8-c39740842a5f"]
+      #   },
+      #   "queryStringParameters"=>nil,
+      #   "multiValueQueryStringParameters"=>nil,
+      #   "pathParameters"=>nil,
+      #   "stageVariables"=>nil,
+      #   "requestContext"=>{
+      #     "resourceId"=>"541ciq", "resourcePath"=>"/api/raw_data",
+      #     "httpMethod"=>"GET", "extendedRequestId"=>"Ld00sEvoNjMF8Zg=",
+      #     "requestTime"=>"05/Jan/2022:09:42:53 +0000",
+      #     "path"=>"/test/api/raw_data", "accountId"=>"752037627773",
+      #     "protocol"=>"HTTP/1.1", "stage"=>"test", "domainPrefix"=>"1jlbwglsci",
+      #     "requestTimeEpoch"=>1641375773896, "requestId"=>"32d4b1da-ba45-4758-a2db-467194ffca11",
+      #     "identity"=>{
+      #       "cognitoIdentityPoolId"=>nil, "accountId"=>nil, "cognitoIdentityId"=>nil, "caller"=>nil,
+      #       "sourceIp"=>"138.64.70.55", "principalOrgId"=>nil, "accessKey"=>nil,
+      #       "cognitoAuthenticationType"=>nil, "cognitoAuthenticationProvider"=>nil, "userArn"=>nil,
+      #       "userAgent"=>"curl/7.77.0", "user"=>nil
+      #     },
+      #     "domainName"=>"1jlbwglsci.execute-api.ap-northeast-1.amazonaws.com",
+      #     "apiId"=>"1jlbwglsci"
+      #   },
+      #   "body"=>nil,
+      #   "isBase64Encoded"=>false
+      # }
+
+      # Lambda Context https://docs.aws.amazon.com/lambda/latest/dg/ruby-context.html
+      # Context methods
+      # # get_remaining_time_in_millis – Returns the number of milliseconds left before the execution times out.
+      # Context properties
+      # # function_name – The name of the Lambda function.
+      # # function_version – The version of the function.
+      # # invoked_function_arn – The Amazon Resource Name (ARN) that's used to invoke the function.
+      # #                        Indicates if the invoker specified a version number or alias.
+      # # memory_limit_in_mb – The amount of memory that's allocated for the function.
+      # # aws_request_id – The identifier of the invocation request.
+      # # log_group_name – The log group for the function.
+      # # log_stream_name – The log stream for the function instance.
+      # # deadline_ms– The date that the execution times out, in Unix time milliseconds.
+      # # identity – (mobile apps) Information about the Amazon Cognito identity that authorized the request.
+      # # client_context– (mobile apps) Client context that's provided to Lambda by the client application.
+    end
+  end
+end

data/lib/LFA/adapter.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative 'adapter/executor'
+require_relative 'adapter/lambda_rack_bridge'
+require_relative 'adapter/environment'
+
+__original_warning_level = $VERBOSE
+begin
+  $VERBOSE = nil
+  ::ENV = LFA::Adapter::EnvMimic.new
+ensure
+  $VERBOSE = __original_warning_level
+end
+
+module LFA
+  class Adapter
+    def initialize(resolver)
+      @resolver = resolver
+      @executors = {}
+    end
+
+    include LambdaRackBridge
+
+    def call(env)
+      begin
+        path = request_path(env: env)
+        method = http_method(env: env)
+
+        matched = @resolver.resolve(path, method)
+        unless matched
+          return [404, {}, ["Resource not found"]]
+        end
+        function = matched.function
+        executor = @executors.fetch(function.name){ Executor.setup(function) }
+        unless @executors.has_key?(function.name)
+          @executors[function.name] = executor
+        end
+
+        event = lambda_event(env: env, path_parameters: matched.path_parameters.dup)
+        context = lambda_context(function_name: function.name)
+
+        result = executor.call(event: event, context: context)
+        return convert_to_rack_response(result) # => [200, {}, ["OK"]]
+      rescue => e
+        p(here: "unexpected error", error_class: e.class, error: e.message)
+        puts e.backtrace
+        return [500, {}, ["Internal Server Error"]]
+      end
+    end
+  end
+end

data/lib/LFA/handler/cors.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module LFA
+  module Handler
+    module Parameterized
+      def stringify(value)
+        case value
+        when Array
+          value.map(&:to_s).join(', ')
+        when String
+          value
+        when nil
+          nil
+        else
+          value.to_s
+        end
+      end
+    end
+
+    class CORSPreflight
+      include Parameterized
+
+      def initialize(params)
+        @allow_origins = stringify(params[:allowOrigins])
+        @mirror_allow_origin = params[:mirrorAllowOrigin]
+
+        @allow_credentials = stringify(params[:allowCredentials])
+        @allow_headers = stringify(params[:allowHeaders])
+        @allow_methods = stringify(params[:allowMethods])
+        @expose_headers = stringify(params[:exposeHeaders])
+        @max_age = stringify(params[:maxAge])
+
+        if @allow_origins && @mirror_allow_origin
+          raise "Configuration error, allowOrigins and mirrorAllowOrigin are exclusive"
+        end
+      end
+
+      def call(event:, context:)
+        unless event.fetch("httpMethod") == 'OPTIONS'
+          raise "CORS handler can respond to OPTIONS only, but the request is '#{event.fetch("httpMethod")}'"
+        end
+
+        # This handler ignores the preflight request headers below:
+        # * Access-Control-Request-Method
+        # * Access-Control-Request-Headers
+        # System administrator should be able to configure this handler without use of those headers, probably.
+        origin = event.dig("headers", "origin")
+        {statusCode: 200, body: '', headers: cors_headers(origin)}
+      end
+
+      def cors_headers(origin)
+        headers = {}
+        if @allow_origins
+          headers['access-control-allow-origin'] = @allow_origins
+        end
+        if @mirror_allow_origin
+          headers['access-control-allow-origin'] = origin
+          headers['vary'] = 'Origin'
+        end
+        if @allow_credentials
+          headers['access-control-allow-credentials'] = @allow_credentials
+        end
+        if @allow_headers
+          headers['access-control-allow-headers'] = @allow_headers
+        end
+        if @allow_methods
+          headers['access-control-allow-methods'] = @allow_methods
+        end
+        if @expose_headers
+          headers['access-control-expose-headers'] = @expose_headers
+        end
+        if @max_age
+          headers['access-control-max-age'] = @max_age
+        end
+
+        headers
+      end
+    end
+  end
+end

data/lib/LFA/router/config.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module LFA
+  module Router
+    RESOURCE_METHODS = [
+      :GET, :POST, :PUT, :OPTIONS, :ANY,
+    ].freeze
+
+    class Config
+      attr_reader :resources, :functions
+
+      def self.parse(yaml_filename)
+        tree = File.open(yaml_filename) do |file|
+          YAML.load(file.read, symbolize_names: true, aliases: true)
+        end
+        dirname = File.dirname(File.absolute_path(yaml_filename))
+        Config.new(tree, dirname)
+      end
+
+      def initialize(tree, dirname)
+        # TODO: path-method-to-function cache
+        raise "functions is not specified" unless tree[:functions]
+        raise "resources is not specified" unless tree[:resources]
+        @functions = Hash[*(tree[:functions].map{|f| Function.new(f, dirname) }.map{|f| [f.name, f] }.flatten)]
+        @resources = tree[:resources].map{|r| Resource.new(r, @functions) }
+      end
+
+      def dig(path, method)
+        raise "invalid path" unless path.start_with?("/")
+        parts = if path == "/"
+                  ["/"]
+                else
+                  path.split("/").filter{|str| str.size > 0 }.map{|part| "/" + part}
+                end
+        resource = self
+        path_parameters = {}
+        parts.each_with_index do |part, index|
+          resource = resource.resources.find{|r| r.is_wildcard? || r.path == part }
+          if resource
+            if resource.is_wildcard? && resource.is_greedy_wildcard?
+              path_parameters[resource.parameter_name] = (parts[index..-1].join)[1..-1] # omit heading '/'
+              break
+            elsif resource.is_wildcard?
+              path_parameters[resource.parameter_name] = part[1..-1] # omit heading '/'
+            end
+          else # resource == nil
+            break
+          end
+        end
+        if resource
+          if resource.is_greedy_wildcard?
+            MatchedFunction.new(
+              function: resource.methods.fetch(:ANY),
+              path_parameters: path_parameters,
+            )
+          else
+            func = resource.methods[method.to_sym]
+            if func
+              MatchedFunction.new(
+                function: func,
+                path_parameters: path_parameters.size > 0 ? path_parameters : nil,
+              )
+            else
+              nil
+            end
+          end
+        else
+          nil # when the resource is not found
+        end
+      end
+    end
+
+    MatchedFunction = Data.define(:function, :path_parameters)
+
+    class Resource
+      attr_reader :path, :parameter_name, :methods, :resources
+
+      def initialize(obj, functions)
+        @path = obj[:path]
+        raise "path must start with '/'" unless @path.start_with?('/')
+        @methods_hash = obj[:methods] || []
+        @resources_array = obj[:resources] || []
+        @methods = {}
+        @methods_hash.each do |method_name, function_name|
+          raise "unsupported method '#{method_name}'" unless RESOURCE_METHODS.include?(method_name)
+          raise "function name missing '#{function_name}'" unless functions.has_key?(function_name)
+          raise "duplicated config on method '#{method_name}'" if @methods[method_name]
+          @methods[method_name] = functions[function_name]
+        end
+        @resources = @resources_array.map{|resource_obj| Resource.new(resource_obj, functions) }
+
+        @parameter_name = nil
+        @greedy_match = nil
+        if @path.start_with?('/{') && @path.end_with?('}')
+          if @path.end_with?('+}')
+            @parameter_name = @path[2..-3]
+            @greedy_match = true
+          else
+            @parameter_name = @path[2..-2]
+            @greedy_match = false
+          end
+        end
+        if @greedy_match.!.! && @methods.keys != [:ANY]
+          raise "resource with a greedy path parameter '{part+}' must respond to only ANY method"
+        end
+      end
+
+      def is_wildcard?
+        @parameter_name != nil
+      end
+
+      def is_greedy_wildcard?
+        @greedy_match.!.!
+      end
+    end
+
+    class Function
+      attr_reader :name, :handler, :env, :params, :dirname
+
+      def initialize(obj, dirname)
+        raise "function name, handler are mandatory" unless obj[:name] && obj[:handler]
+        @name = obj[:name]
+        @handler_name = obj[:handler]
+        @env = obj[:env] || {}
+        @params = obj[:params] || {}
+        @handler = if @handler_name =~ /\A[A-Z0-9_]+\z/
+                     BuiltInHandler.new(@handler_name)
+                   else
+                     Handler.parse(@handler_name, dirname)
+                   end
+      end
+
+      def inspect
+        "<Function name: #{@name}, handler: #{@handler}, env: #{@env}, params: #{@params}>"
+      end
+    end
+
+    class BuiltInHandler
+      attr_reader :name
+
+      def initialize(handler_name)
+        @name = handler_name
+      end
+
+      def builtin?
+        true
+      end
+
+      def inspect
+        "<BuiltInHandler #{@name}>"
+      end
+    end
+
+    class Handler
+      attr_reader :filename, :klass, :method
+
+      def initialize(filename, klass, method, dirname)
+        @filename = filename
+        @klass = klass
+        @method = method
+        @dirname = dirname
+      end
+
+      def self.parse(name, dirname)
+        filename, klass, method = name.split('.', 3)
+        raise "invalid handler format '#{name}'" unless filename && klass && method
+        Handler.new(filename, klass, method, dirname)
+      end
+
+      def builtin?
+        false
+      end
+
+      def inspect
+        "<Handler #{@filename}.#{@klass}.#{@method}>"
+      end
+
+      def path
+        File.join(@dirname, @filename + '.rb')
+      end
+    end
+  end
+end

data/lib/LFA/router.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative './router/config'
+
+module LFA
+  module Router
+    def self.resolver(config_filename)
+      config = Config.parse(config_filename)
+      return Resolver.new(config)
+    end
+
+    class Resolver
+      def initialize(config)
+        @config = config
+        @cache = {}
+      end
+
+      def resolve(path, method)
+        cache_key = "#{method}\t#{path}"
+        return @cache[cache_key] if @cache.has_key?(cache_key) # return stored nil when the cache key exists
+
+        matched = @config.dig(path, method)
+        @cache[cache_key] = matched # store negative cache to not pay too much cost for 404 even when nil (404)
+        matched
+      end
+    end
+  end
+end

data/lib/LFA/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module LFA
+  VERSION = "0.2.0"
+end

data/lib/LFA.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "LFA/version"
+require_relative "LFA/router"
+require_relative "LFA/adapter"
+
+module LFA
+  def self.ignition!(config_filename)
+    router = Router.resolver(config_filename)
+    return Adapter.new(router)
+  end
+end

data/myfunc.rb

@@ -0,0 +1,41 @@
+require 'json'
+
+module Countries
+  MESSAGE = ENV.fetch("KEY2", "yay")
+
+  def self.process(event:, context:)
+    data = ENV.fetch("KEY1", "y")
+    {
+      statusCode: 200,
+      body: {"data" => data, "message" => MESSAGE}.to_json,
+      headers: {"content-type" => "application/json"},
+    }
+  end
+end
+
+require_relative 'data'
+
+module City
+  # "resource"=>"/api/place/{place_id}", "path"=>"/api/place/tokyo", "pathParameters"=>{"place_id"=>"tokyo"}
+  def self.process(event:, context:)
+    city_name = event.dig("pathParameters", "place_id")
+    {
+      statusCode: 200,
+      body: {"city_name" => city_name, "message" => "good city!"}.to_json,
+      headers: {"content-type" => "application/json"},
+    }
+  end
+end
+
+module Town
+  # "resource"=>"/api/town/{names+}", "path"=>"/api/checkin/yay1", "pathParameters"=>{"names"=>"yay1"}
+  # "resource"=>"/api/town/{names+}", "path"=>"/api/checkin/yay1/foo2/bar3", "pathParameters"=>{"names"=>"yay1/foo2/bar3"},
+  def self.process(event:, context:)
+    towns = event.dig("pathParameters", "names").split("/")
+    {
+      statusCode: 200,
+      body: {"towns" => towns, "message" => "good towns!"}.to_json,
+      headers: {"content-type" => "application/json"},
+    }
+  end
+end

data/sig/LFA.rbs

@@ -0,0 +1,4 @@
+module LFA
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/test.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'lib/LFA'
+
+config = LFA::Router::Config.parse('config.yaml')
+pp(here: "GET /api/country", function: config.dig("/api/country", "GET"))
+pp(here: "GET /api/language", function: config.dig("/api/language", "GET"))
+pp(here: "PUT /api/language", function: config.dig("/api/language", "PUT"))
+pp(here: "GET /api/data/csv", function: config.dig("/api/data/csv", "GET"))
+pp(here: "GET /api/data/json", function: config.dig("/api/data/json", "GET"))
+