edgeway 0.2.0 → 0.3.0

data/lib/edgeway/http/client.rb

@@ -0,0 +1,80 @@
+module Edgeway
+  module HTTP
+    DEFAULT_TIMEOUT = 10
+    MAX_TIMEOUT = 300
+
+    class ClientResponse
+      attr_reader :status, :headers, :body
+
+      def initialize(status, headers, body)
+        @status = status
+        @headers = headers
+        @body = body
+      end
+
+      def success? = @status >= 200 && @status < 300
+
+      def json = JSON.parse(@body)
+    end
+
+    class Transport
+      def request(payload)
+        JSON.generate({ "error" => "no HTTP transport is set" })
+      end
+    end
+
+    @client = Transport.new
+
+    def self.client = @client
+
+    def self.client=(client)
+      @client = client
+    end
+
+    def self.get(url, headers: {}, timeout: DEFAULT_TIMEOUT)
+      send_request("GET", url, "", headers, timeout)
+    end
+
+    def self.delete(url, headers: {}, timeout: DEFAULT_TIMEOUT)
+      send_request("DELETE", url, "", headers, timeout)
+    end
+
+    def self.post(url, body: "", headers: {}, timeout: DEFAULT_TIMEOUT)
+      send_request("POST", url, body, headers, timeout)
+    end
+
+    def self.put(url, body: "", headers: {}, timeout: DEFAULT_TIMEOUT)
+      send_request("PUT", url, body, headers, timeout)
+    end
+
+    def self.patch(url, body: "", headers: {}, timeout: DEFAULT_TIMEOUT)
+      send_request("PATCH", url, body, headers, timeout)
+    end
+
+    def self.send_request(verb, url, body, headers, timeout)
+      timeout_ms = timeout_milliseconds(timeout)
+      payload = JSON.generate({
+        "method" => verb, "url" => url, "headers" => headers, "body" => body,
+        "timeout_ms" => timeout_ms
+      })
+      parse_answer(client.request(payload))
+    end
+
+    def self.timeout_milliseconds(timeout)
+      milliseconds = timeout > MAX_TIMEOUT ? 0 : (timeout * 1000).to_i
+      raise ArgumentError, "timeout must be 0.001 to #{MAX_TIMEOUT} seconds" if milliseconds < 1
+
+      milliseconds
+    end
+
+    def self.parse_answer(text)
+      answer = JSON.parse(text)
+      raise Timeout, answer["error"] if answer.key?("timeout")
+      raise Error, answer["error"] if answer.key?("error")
+
+      body = answer["body_base64"].unpack1("m0")
+      body.force_encoding("UTF-8")
+      ClientResponse.new(answer["status"], answer["headers"], body)
+    end
+  end
+end

data/lib/edgeway/http/request.rb

@@ -25,6 +25,11 @@ module Edgeway
         ENV["HTTP_" + name.upcase.gsub("-", "_")] || ""
       end
 
+      # The client address the platform reports, "" when unknown.
+      def remote_addr
+        ENV["REMOTE_ADDR"] || ""
+      end
+
       def json?
         @content_type.start_with?("application/json")
       end

data/lib/edgeway/http/stub_transport.rb

@@ -0,0 +1,38 @@
+require_relative "client"
+
+module Edgeway
+  module HTTP
+    class UnstubbedRequest < Edgeway::Error; end
+
+    class StubTransport < Transport
+      attr_reader :requests
+
+      def initialize
+        @answers = {}
+        @requests = []
+      end
+
+      def stub(verb, url, status, body, headers)
+        lowered = {}
+        headers.each { |name, value| lowered[name.to_s.downcase] = value.to_s }
+        @answers[key(verb, url)] = JSON.generate({ "status" => status, "headers" => lowered, "body_base64" => [body].pack("m0") })
+      end
+
+      def stub_error(verb, url, message, timeout)
+        answer = { "error" => message }
+        answer["timeout"] = true if timeout
+        @answers[key(verb, url)] = JSON.generate(answer)
+      end
+
+      def request(payload)
+        sent = JSON.parse(payload)
+        @requests << sent
+        @answers[key(sent["method"], sent["url"])] || raise(UnstubbedRequest, "no stub for #{sent["method"]} #{sent["url"]} (add stub_http to the test)")
+      end
+
+      private
+
+      def key(verb, url) = "#{verb.to_s.upcase} #{url}"
+    end
+  end
+end

data/lib/edgeway/logger.rb

@@ -1,12 +1,40 @@
 module Edgeway
-  # Writes to stderr; the runtime sends it to console.error.
   class Logger
-    def info(message)
-      STDERR.puts "[edgeway] #{message}"
+    LEVELS = ["debug", "info", "warn", "error"]
+
+    def initialize(output = STDERR)
+      @output = output
+    end
+
+    def debug(message, fields = {})
+      write("debug", message, fields)
+    end
+
+    def info(message, fields = {})
+      write("info", message, fields)
+    end
+
+    def warn(message, fields = {})
+      write("warn", message, fields)
+    end
+
+    def error(message, fields = {})
+      write("error", message, fields)
+    end
+
+    private
+
+    def write(level, message, fields)
+      return if LEVELS.index(level) < threshold
+      entry = {}
+      fields.each { |name, value| entry[name.to_s] = value }
+      entry["level"] = level
+      entry["message"] = message
+      @output.puts JSON.generate(entry)
     end
 
-    def error(message)
-      STDERR.puts "[edgeway] ERROR #{message}"
+    def threshold
+      LEVELS.index(Edgeway.config("LOG_LEVEL", "info")) || LEVELS.index("info")
     end
   end
 

data/lib/edgeway/rate_limit/limiter.rb

@@ -0,0 +1,9 @@
+module Edgeway
+  module RateLimit
+    class Limiter
+      def exceeded?(binding_name, key)
+        raise Edgeway::Error, "#{self.class.name} does not check limits"
+      end
+    end
+  end
+end

data/lib/edgeway/rate_limit/null_limiter.rb

@@ -0,0 +1,9 @@
+require_relative "limiter"
+
+module Edgeway
+  module RateLimit
+    class NullLimiter < Limiter
+      def exceeded?(binding_name, key) = false
+    end
+  end
+end

data/lib/edgeway/rate_limit/stub_limiter.rb

@@ -0,0 +1,24 @@
+require_relative "limiter"
+
+module Edgeway
+  module RateLimit
+    class StubLimiter < Limiter
+      attr_reader :checks
+
+      def initialize
+        @exceeded_bindings = []
+        @checks = []
+      end
+
+      def stub(binding_name, exceeded)
+        @exceeded_bindings.delete(binding_name)
+        @exceeded_bindings << binding_name if exceeded
+      end
+
+      def exceeded?(binding_name, key)
+        @checks << [binding_name, key]
+        @exceeded_bindings.include?(binding_name)
+      end
+    end
+  end
+end

data/lib/edgeway/rate_limit.rb

@@ -0,0 +1,2 @@
+require_relative "rate_limit/limiter"
+require_relative "rate_limit/null_limiter"

data/lib/edgeway/server.rb

@@ -17,8 +17,9 @@ module Edgeway
     def self.log_database_stats(name)
       stats = Model.query_stats(name)
       return unless stats.queries > 0
-      prefix = name == Model::PRIMARY ? "" : "database=#{name} "
-      Edgeway.logger.info(prefix + stats.log_text)
+      fields = stats.log_fields
+      fields["database"] = name.to_s unless name == Model::PRIMARY
+      Edgeway.logger.info("query stats", fields)
     end
   end
 end

data/lib/edgeway/service/cloudflare/d1.rb

@@ -3,6 +3,7 @@
 # Spinel's, so CRuby can't read it (tests use edgeway/db/memory).
 require "json"
 require_relative "../../db/adapter"
+require_relative "../import_result"
 
 module Edgeway
   module Cloudflare
@@ -34,8 +35,6 @@ module Edgeway
     # suspended (JSPI), so they read like blocking calls here.
     module D1Imports
       ffi_source <<~C
-        #include <stdlib.h>
-
         #define D1_IMPORT(name) __attribute__((import_module("edgeway_d1"), import_name(name)))
 
         D1_IMPORT("query")   int  js_d1_query(const char *binding, const char *sql, const char *binds);
@@ -44,38 +43,24 @@ module Edgeway
         D1_IMPORT("batch")   int  js_d1_batch(const char *binding, const char *statements);
         D1_IMPORT("take")    void js_d1_take(char *buf);
 
-        /* The last result, NUL-terminated; grown as needed and reused. */
-        static char *result;
-        static int result_cap;
-
-        static const char *take_result(int length) {
-          if (length + 1 > result_cap) {
-            char *grown = realloc(result, length + 1);
-            if (!grown) abort();
-            result = grown;
-            result_cap = length + 1;
-          }
-          js_d1_take(result);
-          result[length] = 0;
-          return result;
-        }
+        static ImportResultBuffer d1_result;
 
         /* What ffi_func binds. Its own extern declaration would lose the
            import attributes, so the imports are wrapped. */
         const char *d1_query(const char *binding, const char *sql, const char *binds) {
-          return take_result(js_d1_query(binding, sql, binds));
+          return take_import_result(&d1_result, js_d1_query(binding, sql, binds), js_d1_take);
         }
 
         const char *d1_execute(const char *binding, const char *sql, const char *binds) {
-          return take_result(js_d1_execute(binding, sql, binds));
+          return take_import_result(&d1_result, js_d1_execute(binding, sql, binds), js_d1_take);
         }
 
         const char *d1_exec(const char *binding, const char *sql) {
-          return take_result(js_d1_exec(binding, sql));
+          return take_import_result(&d1_result, js_d1_exec(binding, sql), js_d1_take);
         }
 
         const char *d1_batch(const char *binding, const char *statements) {
-          return take_result(js_d1_batch(binding, statements));
+          return take_import_result(&d1_result, js_d1_batch(binding, statements), js_d1_take);
         }
       C
       ffi_func :d1_query, [:str, :str, :str], :str

data/lib/edgeway/service/cloudflare/jwt.rb

@@ -3,33 +3,21 @@
 # (ffi_source is Spinel's; tests use edgeway/http/auth/stub).
 require "json"
 require_relative "../../http/auth/jwt"
+require_relative "../import_result"
 
 module Edgeway
   module Cloudflare
     module JWTImports
       ffi_source <<~C
-        #include <stdlib.h>
-
         #define JWT_IMPORT(name) __attribute__((import_module("edgeway_jwt"), import_name(name)))
 
         JWT_IMPORT("verify") int  js_jwt_verify(const char *token);
         JWT_IMPORT("take")   void js_jwt_take(char *buf);
 
-        /* The last result, NUL-terminated; grown as needed and reused. */
-        static char *jwt_result;
-        static int jwt_result_cap;
+        static ImportResultBuffer jwt_result;
 
         const char *jwt_verify(const char *token) {
-          int length = js_jwt_verify(token);
-          if (length + 1 > jwt_result_cap) {
-            char *grown = realloc(jwt_result, length + 1);
-            if (!grown) abort();
-            jwt_result = grown;
-            jwt_result_cap = length + 1;
-          }
-          js_jwt_take(jwt_result);
-          jwt_result[length] = 0;
-          return jwt_result;
+          return take_import_result(&jwt_result, js_jwt_verify(token), js_jwt_take);
         }
       C
       ffi_func :jwt_verify, [:str], :str

data/lib/edgeway/service/cloudflare/kv.rb

@@ -0,0 +1,45 @@
+require "json"
+require_relative "../import_result"
+require_relative "kv_store"
+
+module Edgeway
+  module Cloudflare
+    module KVImports
+      ffi_source <<~C
+        #define KV_IMPORT(name) __attribute__((import_module("edgeway_kv"), import_name(name)))
+
+        KV_IMPORT("get")    int  js_kv_get(const char *binding, const char *key);
+        KV_IMPORT("put")    int  js_kv_put(const char *binding, const char *key, const char *text, int expires_in);
+        KV_IMPORT("delete") int  js_kv_delete(const char *binding, const char *key);
+        KV_IMPORT("take")   void js_kv_take(char *buffer);
+
+        static ImportResultBuffer kv_result;
+
+        const char *kv_get(const char *binding, const char *key) {
+          return take_import_result(&kv_result, js_kv_get(binding, key), js_kv_take);
+        }
+
+        const char *kv_put(const char *binding, const char *key, const char *text, int expires_in) {
+          return take_import_result(&kv_result, js_kv_put(binding, key, text, expires_in), js_kv_take);
+        }
+
+        const char *kv_delete(const char *binding, const char *key) {
+          return take_import_result(&kv_result, js_kv_delete(binding, key), js_kv_take);
+        }
+      C
+      ffi_func :kv_get, [:str, :str], :str
+      ffi_func :kv_put, [:str, :str, :str, :int], :str
+      ffi_func :kv_delete, [:str, :str], :str
+    end
+
+    class KVImportTransport < KVTransport
+      def get(binding_name, key) = KVImports.kv_get(binding_name, key)
+
+      def put(binding_name, key, text, expires_in_seconds)
+        KVImports.kv_put(binding_name, key, text, expires_in_seconds)
+      end
+
+      def delete(binding_name, key) = KVImports.kv_delete(binding_name, key)
+    end
+  end
+end

data/lib/edgeway/service/cloudflare/kv_store.rb

@@ -0,0 +1,58 @@
+require "json"
+require_relative "../../cache/store"
+
+module Edgeway
+  module Cloudflare
+    class KVTransport
+      def get(binding_name, key)
+        raise Edgeway::Error, "#{self.class.name} does not get"
+      end
+
+      def put(binding_name, key, text, expires_in_seconds)
+        raise Edgeway::Error, "#{self.class.name} does not put"
+      end
+
+      def delete(binding_name, key)
+        raise Edgeway::Error, "#{self.class.name} does not delete"
+      end
+    end
+
+    class KVStore < Cache::Store
+      def initialize(binding:, namespace: nil, expires_in: nil, transport:)
+        super(namespace: namespace, expires_in: expires_in)
+        @binding_name = binding
+        @transport = transport
+      end
+
+      def read_text(key)
+        check_key(key)
+        answer = parse_answer("get", @transport.get(@binding_name, key))
+        answer.nil? ? nil : answer["value"]
+      end
+
+      def write_text(key, text, expires_in_seconds)
+        check_key(key)
+        !parse_answer("put", @transport.put(@binding_name, key, text, expires_in_seconds)).nil?
+      end
+
+      def delete_text(key)
+        check_key(key)
+        !parse_answer("delete", @transport.delete(@binding_name, key)).nil?
+      end
+
+      private
+
+      def check_key(key)
+        raise ArgumentError, "cache key can't be . or .." if key == "." || key == ".."
+      end
+
+      def parse_answer(operation, json)
+        answer = JSON.parse(json)
+        return answer unless answer.key?("error")
+
+        Edgeway.logger.warn("cache operation failed", { "operation" => operation, "binding" => @binding_name, "error" => answer["error"] })
+        nil
+      end
+    end
+  end
+end

data/lib/edgeway/service/cloudflare/rate_limit.rb

@@ -0,0 +1,27 @@
+require "json"
+require_relative "../import_result"
+require_relative "rate_limiter"
+
+module Edgeway
+  module Cloudflare
+    module RateLimitImports
+      ffi_source <<~C
+        #define RATE_LIMIT_IMPORT(name) __attribute__((import_module("edgeway_ratelimit"), import_name(name)))
+
+        RATE_LIMIT_IMPORT("check") int  js_rate_limit_check(const char *binding, const char *key);
+        RATE_LIMIT_IMPORT("take")  void js_rate_limit_take(char *buffer);
+
+        static ImportResultBuffer rate_limit_result;
+
+        const char *rate_limit_check(const char *binding, const char *key) {
+          return take_import_result(&rate_limit_result, js_rate_limit_check(binding, key), js_rate_limit_take);
+        }
+      C
+      ffi_func :rate_limit_check, [:str, :str], :str
+    end
+
+    class RateLimitImportTransport < RateLimitTransport
+      def check(binding_name, key) = RateLimitImports.rate_limit_check(binding_name, key)
+    end
+  end
+end

data/lib/edgeway/service/cloudflare/rate_limiter.rb

@@ -0,0 +1,33 @@
+require "json"
+require_relative "../../rate_limit"
+
+module Edgeway
+  module Cloudflare
+    class RateLimitTransport
+      def check(binding_name, key)
+        raise Edgeway::Error, "#{self.class.name} does not check"
+      end
+    end
+
+    class RateLimiter < RateLimit::Limiter
+      def initialize(transport:)
+        @transport = transport
+      end
+
+      def exceeded?(binding_name, key)
+        answer = JSON.parse(@transport.check(binding_name, Digest::SHA256.hexdigest(key)))
+        raise ConfigurationError, "rate limit: #{answer["misconfigured"]}" if answer.key?("misconfigured")
+        return failed_open(binding_name, answer["error"]) if answer.key?("error")
+
+        answer["success"] == false
+      end
+
+      private
+
+      def failed_open(binding_name, message)
+        Edgeway.logger.warn("rate limit check failed", { "binding" => binding_name, "error" => message })
+        false
+      end
+    end
+  end
+end

data/lib/edgeway/service/cloudflare/test_databases.rb

@@ -0,0 +1,65 @@
+require_relative "d1"
+
+module Edgeway
+  module Cloudflare
+    module TestImports
+      ffi_source <<~C
+        __attribute__((import_module("edgeway_test"), import_name("reset"))) void js_test_reset(void);
+
+        int test_reset(void) {
+          js_test_reset();
+          return 0;
+        }
+      C
+      ffi_func :test_reset, [], :int
+    end
+
+    class TestD1Adapter < D1Adapter
+      attr_reader :log
+
+      def initialize(binding: "DB")
+        super(binding: binding)
+        @log = []
+      end
+
+      def select_all(sql, binds)
+        log_statement(sql, binds)
+        super(sql, binds)
+      end
+
+      def execute(sql, binds)
+        log_statement(sql, binds)
+        super(sql, binds)
+      end
+
+      def exec(sql)
+        log_statement(sql, [])
+        super(sql)
+      end
+
+      def batch(statements)
+        @log << "BATCH #{statements.size}"
+        super(statements)
+      end
+
+      def close
+      end
+
+      private
+
+      def log_statement(sql, binds)
+        @log << "#{sql} | #{JSON.generate(binds)}"
+      end
+    end
+  end
+
+  module TestDatabases
+    def self.reset
+      Cloudflare::TestImports.test_reset
+    end
+
+    def self.open(name)
+      Cloudflare::TestD1Adapter.new(binding: Edgeway::TEST_BINDINGS.fetch(name))
+    end
+  end
+end

data/lib/edgeway/service/fetch.rb

@@ -0,0 +1,26 @@
+require_relative "../http/client"
+require_relative "import_result"
+
+module Edgeway
+  module FetchImports
+    ffi_source <<~C
+      #define FETCH_IMPORT(name) __attribute__((import_module("edgeway_fetch"), import_name(name)))
+
+      FETCH_IMPORT("request") int  js_fetch_request(const char *payload);
+      FETCH_IMPORT("take")    void js_fetch_take(char *buffer);
+
+      static ImportResultBuffer fetch_result;
+
+      const char *fetch_request(const char *payload) {
+        return take_import_result(&fetch_result, js_fetch_request(payload), js_fetch_take);
+      }
+    C
+    ffi_func :fetch_request, [:str], :str
+  end
+
+  class FetchTransport < HTTP::Transport
+    def request(payload)
+      FetchImports.fetch_request(payload)
+    end
+  end
+end

data/lib/edgeway/service/import_result.rb

@@ -0,0 +1,24 @@
+module Edgeway
+  module ImportResult
+    ffi_source <<~C
+      #include <stdlib.h>
+
+      typedef struct {
+        char *text;
+        int capacity;
+      } ImportResultBuffer;
+
+      static const char *take_import_result(ImportResultBuffer *buffer, int length, void (*take)(char *)) {
+        if (length + 1 > buffer->capacity) {
+          char *grown = realloc(buffer->text, length + 1);
+          if (!grown) abort();
+          buffer->text = grown;
+          buffer->capacity = length + 1;
+        }
+        take(buffer->text);
+        buffer->text[length] = 0;
+        return buffer->text;
+      }
+    C
+  end
+end

data/lib/edgeway/test/sqlite_databases.rb

@@ -0,0 +1,18 @@
+module Edgeway
+  module TestDatabases
+    # Called before each test.
+    def self.reset
+    end
+
+    def self.open(name)
+      migrations = name == Edgeway::Model::PRIMARY ? "db/migrations" : "db/#{name}/migrations"
+      directory = File.join(Edgeway::TEST_APP_ROOT, migrations)
+      if name != Edgeway::Model::PRIMARY && !File.directory?(directory)
+        raise Edgeway::ConfigurationError, "database #{name} (config/database.yml) has no #{migrations} directory"
+      end
+      database = Edgeway::DB::SQLiteAdapter.new(":memory:")
+      database.apply_migrations(directory)
+      database
+    end
+  end
+end