mayu-live 0.0.0

data/lib/mayu/server/errors.rb

@@ -0,0 +1,110 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Mayu
+  module Server
+    module Errors
+      extend T::Sig
+
+      class ServerError < StandardError
+      end
+
+      class FileNotFound < ServerError
+      end
+      class CookieNotSet < ServerError
+      end
+      class InvalidToken < ServerError
+      end
+      class InvalidMethod < ServerError
+      end
+      class UnauthorizedSessionCookie < ServerError
+      end
+      class SessionAlreadyResumed < ServerError
+      end
+      class SessionNotFound < ServerError
+      end
+      class ServerIsShuttingDown < ServerError
+      end
+      class InvalidSecFetchHeader < ServerError
+      end
+
+      sig do
+        params(block: T.proc.returns(Protocol::HTTP::Response)).returns(
+          Protocol::HTTP::Response
+        )
+      end
+      def self.handle_exceptions(&block)
+        respond_to_exceptions { log_exceptions { yield } }
+      end
+
+      sig do
+        params(block: T.proc.returns(Protocol::HTTP::Response)).returns(
+          Protocol::HTTP::Response
+        )
+      end
+      def self.log_exceptions(&block)
+        yield
+      rescue => e
+        Console.logger.error(self, "#{e.class.name}: #{e.message}")
+        raise
+      end
+
+      sig do
+        params(block: T.proc.returns(Protocol::HTTP::Response)).returns(
+          Protocol::HTTP::Response
+        )
+      end
+      def self.respond_to_exceptions(&block)
+        yield
+      rescue Errno::ENOENT => e
+        text_response(404, "file not found")
+      rescue FileNotFound => e
+        text_response(404, e.message.to_s)
+      rescue CookieNotSet => e
+        text_response(403, "session cookie not set")
+      rescue SessionNotFound => e
+        text_response(404, "session not found")
+      rescue Mayu::MessageCipher::DecryptError => e
+        text_response(403, "decrypt error")
+      rescue Mayu::MessageCipher::ExpiredError => e
+        text_response(403, "session expired")
+      rescue InvalidToken => e
+        text_response(403, "invalid token")
+      rescue SessionAlreadyResumed => e
+        text_response(409, "already resumed")
+      rescue Session::AlreadyRunningError => e
+        text_response(409, "already running")
+      rescue ServerIsShuttingDown => e
+        # https://fly.io/docs/reference/fly-replay/#fly-replay
+        text_response(
+          405,
+          "invalid method",
+          { "fly-replay" => "elsewhere=true" }
+        )
+      rescue InvalidMethod => e
+        text_response(405, "invalid method")
+      rescue UnauthorizedSessionCookie => e
+        text_response(403, "session cookie is invalid")
+      rescue InvalidSecFetchHeader => e
+        text_response(415, e.message)
+      rescue StandardError
+        text_response(500, "error")
+      end
+
+      sig do
+        params(
+          code: Integer,
+          text: String,
+          headers: T::Hash[String, String]
+        ).returns(Protocol::HTTP::Response)
+      end
+      def self.text_response(code, text, headers = {})
+        Protocol::HTTP::Response[
+          code,
+          { "content-type" => "text/plain", **headers },
+          [text]
+        ]
+      end
+    end
+  end
+end

data/lib/mayu/server/file_server.rb

@@ -0,0 +1,140 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "errors"
+
+module Mayu
+  module Server
+    class FileServer
+      class FoundFile < T::Struct
+        const :absolute_path, String
+        const :content_type, String
+        const :size, Integer
+      end
+
+      # TODO: Make configurable. A higher value means less
+      # filsystem IO, but obviously consumes more memory.
+      DEFAULT_MEMORY_CACHE_MAX_SIZE = T.let(1024, Integer)
+
+      CACHE_MAX_AGE = T.let(60 * 60 * 24 * 7, Integer)
+
+      CACHE_CONTROL =
+        T.let(
+          {
+            "cache-control" => "public, max-age=#{CACHE_MAX_AGE}, immutable"
+          }.freeze,
+          T::Hash[String, String]
+        )
+      BROTLI_CONTENT_ENCODING =
+        T.let({ "content-encoding" => "br" }.freeze, T::Hash[String, String])
+
+      extend T::Sig
+
+      sig { params(root_dir: String, memory_cache_max_size: Integer).void }
+      def initialize(
+        root_dir,
+        memory_cache_max_size: DEFAULT_MEMORY_CACHE_MAX_SIZE
+      )
+        @root_dir = root_dir
+        @found_files =
+          T.let(
+            T::Hash[String, FoundFile].new do |h, filename|
+              if found_file = find_file(filename)
+                h[filename] = found_file
+              end
+            end,
+            T::Hash[String, FoundFile]
+          )
+        @memory_cache_max_size = memory_cache_max_size
+        @memory_cache = T.let({}, T::Hash[String, String])
+      end
+
+      sig do
+        params(filename: String, accept_encodings: T::Array[String]).returns(
+          Protocol::HTTP::Response
+        )
+      end
+      def serve(filename, accept_encodings: [])
+        found_file = @found_files[filename]
+
+        unless found_file
+          raise Errors::FileNotFound, "Could not find file #{filename}"
+        end
+
+        headers = {
+          **CACHE_CONTROL,
+          "content-type" => add_charset(found_file.content_type)
+        }
+
+        if accept_encodings.include?("br")
+          if brotlied = @found_files["#{filename}.br"]
+            return(
+              Protocol::HTTP::Response[
+                200,
+                { **headers, **BROTLI_CONTENT_ENCODING },
+                read_file(brotlied)
+              ]
+            )
+          end
+        end
+
+        contents = read_file(found_file)
+        Protocol::HTTP::Response[200, headers, read_file(found_file)]
+      end
+
+      private
+
+      sig { params(filename: String).returns(T.nilable(FoundFile)) }
+      def find_file(filename)
+        absolute_path = File.join(@root_dir, filename)
+
+        return unless File.exist?(absolute_path)
+
+        size = File.size(absolute_path)
+
+        content_type =
+          MIME::Types.type_for(absolute_path.delete_suffix(".br")).first.to_s
+
+        FoundFile.new(absolute_path:, content_type:, size:)
+      end
+
+      sig do
+        params(found_file: FoundFile).returns(
+          T.any([String], Protocol::HTTP::Body::File)
+        )
+      end
+      def read_file(found_file)
+        if found_file.size > @memory_cache_max_size
+          return Protocol::HTTP::Body::File.open(found_file.absolute_path)
+        end
+
+        [
+          @memory_cache[found_file.absolute_path] ||= begin
+            File.read(found_file.absolute_path)
+          end
+        ]
+      end
+
+      sig { params(filename: String).returns(String) }
+      def get_absolute_path(filename)
+        File.join(@root_dir, File.expand_path(filename, "/"))
+      end
+
+      sig { params(content_type: String).returns(String) }
+      def add_charset(content_type)
+        if add_charset?(content_type)
+          "#{content_type}; charset=utf-8"
+        else
+          content_type
+        end
+      end
+
+      sig { params(content_type: String).returns(T::Boolean) }
+      def add_charset?(content_type)
+        content_type in
+          "application/javascript" | "application/json" | "image/svg+xml" |
+            "text/css" | "text/html"
+      end
+    end
+  end
+end

data/lib/mayu/server.rb

@@ -0,0 +1,63 @@
+# typed: strict
+
+require "bundler/setup"
+require "sorbet-runtime"
+require "async"
+require "async/container"
+require "async/http/server"
+require "async/http/endpoint"
+require "protocol/http/body/file"
+require "async/io/host_endpoint"
+require "async/io/shared_endpoint"
+require "async/io/ssl_endpoint"
+require "async/io/trap"
+require "localhost"
+require "mime/types"
+require_relative "environment"
+require_relative "session"
+require_relative "configuration"
+require_relative "colors"
+require_relative "server/controller"
+
+module Mayu
+  module Server
+    extend T::Sig
+
+    sig { params(config: Configuration).void }
+    def self.start_dev(config) = start(config)
+
+    sig { params(config: Configuration).void }
+    def self.start_prod(config) = start(config)
+
+    sig { params(config: Configuration).void }
+    def self.start(config)
+      uri = config.server.uri
+      ssl_context = setup_self_signed_cert(config)
+      endpoint = Async::HTTP::Endpoint.new(uri, ssl_context:, reuse_port: true)
+
+      Configuration.log_config(config)
+      Process.setproctitle("mayu #{config.mode} file://#{config.root} #{uri}")
+
+      # Metrics.setup(config) if config.metrics.enabled
+
+      Controller.new(config:, endpoint:).run
+    end
+
+    sig do
+      params(config: Configuration).returns(T.nilable(OpenSSL::SSL::SSLContext))
+    end
+    def self.setup_self_signed_cert(config)
+      return unless config.server.self_signed_cert
+
+      authority = Localhost::Authority.fetch(config.server.host)
+
+      authority.server_context.tap do |context|
+        context.alpn_select_cb = lambda { |_| "h2" }
+        lambda { |protocols| protocols.include?("h2") ? "h2" : nil }
+
+        context.alpn_protocols = ["h2"]
+        context.session_id_context = "mayu"
+      end
+    end
+  end
+end

data/lib/mayu/session.rb

@@ -0,0 +1,358 @@
+# typed: strict
+
+require "time"
+require "nanoid"
+require_relative "environment"
+require_relative "vdom/vtree"
+require_relative "vdom/marshalling"
+require_relative "event_stream"
+
+module Mayu
+  class Session
+    extend T::Sig
+
+    class InvalidTokenError < StandardError
+    end
+    class InvalidIdError < StandardError
+    end
+    class AlreadyRunningError < StandardError
+    end
+
+    sig do
+      params(environment: Environment, path: String).returns(T.attached_class)
+    end
+    def self.init(environment:, path:)
+      new(environment:, path:)
+    end
+
+    sig do
+      params(environment: Environment, dumped: String).returns(T.attached_class)
+    end
+    def self.restore(environment:, dumped:)
+      Marshal.restore(
+        dumped,
+        ->(obj) do
+          case obj
+          when self
+            obj.instance_variable_set(:@environment, environment)
+            obj
+          when SerializedSession
+            obj.to_session(environment)
+          else
+            obj
+          end
+        end
+      )
+    end
+
+    ID_FORMAT = /\A[A-Za-z0-9_-]{21}\z/
+
+    TOKEN_LENGTH = 64
+    TOKEN_FORMAT = /\A\w{#{TOKEN_LENGTH}}\z/
+
+    sig { returns(String) }
+    def self.generate_token
+      SecureRandom.alphanumeric(TOKEN_LENGTH)
+    end
+
+    sig { params(token: String).returns(T::Boolean) }
+    def self.valid_token?(token)
+      token.match?(TOKEN_FORMAT)
+    end
+
+    sig { params(token: String).void }
+    def self.validate_token!(token)
+      raise InvalidTokenError unless valid_token?(token)
+    end
+
+    sig { params(id: String).returns(T::Boolean) }
+    def self.valid_id?(id)
+      id.match?(ID_FORMAT)
+    end
+
+    sig { params(id: String).void }
+    def self.validate_id!(id)
+      raise InvalidIdError unless valid_id?(id)
+    end
+
+    sig { params(token: String).returns(T::Boolean) }
+    def authorized?(token)
+      if self.token.length == token.length
+        OpenSSL.fixed_length_secure_compare(self.token, token)
+      else
+        false
+      end
+    end
+
+    Marshaled = T.type_alias { [String, String, String, String, String] }
+
+    sig { returns(String) }
+    attr_reader :id
+    sig { returns(String) }
+    attr_reader :token
+    sig { returns(String) }
+    attr_reader :path
+    sig { returns(T::Hash[String, String]) }
+    attr_reader :headers
+    sig { returns(Environment) }
+    attr_reader :environment
+    sig { returns(Float) }
+    attr_reader :last_ping_at
+    sig { returns(EventStream::Log) }
+    attr_reader :log
+
+    sig { params(timeout_seconds: T.any(Float, Integer)).returns(T::Boolean) }
+    def expired?(timeout_seconds = 30)
+      seconds_since_last_ping > timeout_seconds
+    end
+
+    sig { returns(Float) }
+    def seconds_since_last_ping
+      Time.now.to_f - last_ping_at
+    end
+
+    sig do
+      params(
+        environment: Environment,
+        path: String,
+        headers: T::Hash[String, String],
+        vtree: T.nilable(VDOM::VTree),
+        store: T.nilable(State::Store)
+      ).void
+    end
+    def initialize(environment:, path:, headers: {}, vtree: nil, store: nil)
+      @environment = environment
+      @id = T.let(Nanoid.generate, String)
+      @token = T.let(self.class.generate_token, String)
+      @path = path
+      @headers = headers
+      @vtree = T.let(vtree || VDOM::VTree.new(session: self), VDOM::VTree)
+      @log = T.let(EventStream::Log.new, EventStream::Log)
+      @store =
+        T.let(
+          store || environment.create_store(initial_state: {}),
+          State::Store
+        )
+      @app = T.let(environment.load_root(path, headers:), VDOM::Descriptor)
+      @last_ping_at = T.let(Time.now.to_f, Float)
+      @barrier = T.let(Async::Barrier.new, Async::Barrier)
+    end
+
+    sig { void }
+    def stop!
+      @barrier.stop
+    end
+
+    Writable =
+      T.type_alias { T.any(Async::HTTP::Body::Writable, Brotli::Writer) }
+
+    sig do
+      params(body: Writable, task: Async::Task).returns(
+        { stylesheets: T::Array[String] }
+      )
+    end
+    def initial_render(body, task: Async::Task.current)
+      @vtree.render(@app, lifecycles: false)
+
+      root = @vtree.root or raise "There is no root"
+
+      html = root.to_html
+      stylesheets =
+        @vtree
+          .assets
+          .select { _1.end_with?(".css") }
+          .map { "/__mayu/static/#{_1}" }
+
+      # freeze
+
+      # encrypted_session =
+      #   @environment.message_cipher.dump(SerializedSession.dump_session(self))
+
+      links = [
+        %{<script async type="module" src="/__mayu/runtime/#{environment.init_js}##{id}" crossorigin="same-origin" fetchpriority="high"></script>},
+        *stylesheets.map do |stylesheet|
+          %{<link rel="stylesheet" href="#{stylesheet}">}
+        end
+      ].join
+
+      # scripts = %{<template id="mayu-init">#{encrypted_session}</template>}
+      scripts = ""
+      body.write("<!DOCTYPE html>\n")
+
+      task.async do
+        @vtree.root&.write_html(body, links:, scripts:)
+        body.close
+      rescue => e
+        p e
+      end
+
+      { stylesheets: }
+    end
+
+    class SerializedSession
+      extend T::Sig
+
+      sig { returns(T::Array[T.untyped]) }
+      attr_reader :data
+
+      sig { params(data: T::Array[T.untyped]).void }
+      def initialize(data)
+        @data = data
+      end
+
+      sig { params(session: Session).returns(String) }
+      def self.dump_session(session)
+        Marshal.dump(self.new(session.marshal_dump))
+      end
+
+      sig { params(environment: Environment).returns(Session) }
+      def to_session(environment)
+        session = Session.allocate
+        session.instance_variable_set(:@environment, environment)
+        session.marshal_load(@data)
+        session
+      end
+
+      sig { returns(T::Array[T.untyped]) }
+      def marshal_dump
+        @data
+      end
+
+      sig { params(a: T::Array[T.untyped]).void }
+      def marshal_load(a)
+        @data = a
+      end
+    end
+
+    sig { returns(T::Array[T.untyped]) }
+    def marshal_dump
+      [
+        @id,
+        @token,
+        @path,
+        @headers,
+        VDOM::Marshalling.dump(@vtree),
+        Marshal.dump(@store.state)
+      ]
+    end
+
+    sig { params(a: T::Array[T.untyped]).void }
+    def marshal_load(a)
+      @id, @token, @path, @headers, dumped_vtree, state = a
+      @last_ping_at = Time.now.to_f
+      @vtree = VDOM::Marshalling.restore(dumped_vtree, session: self)
+      @store = @environment.create_store(initial_state: Marshal.restore(state))
+      @app = @environment.load_root(@path, headers:)
+      @barrier = Async::Barrier.new
+      @log = EventStream::Log.new
+    end
+
+    sig do
+      params(
+        url: String,
+        method: Symbol,
+        headers: T::Hash[String, String],
+        body: T.nilable(String)
+      ).returns(Fetch::Response)
+    end
+    def fetch(url, method: :GET, headers: {}, body: nil)
+      @environment.fetch.fetch(url, method:, headers:, body:)
+    end
+
+    sig { void }
+    def activity!
+      @last_ping_at = Time.now.to_f
+    end
+
+    sig do
+      params(callback_id: String, payload: T::Hash[Symbol, T.untyped]).void
+    end
+    def handle_callback(callback_id, payload = {})
+      activity!
+      @vtree.handle_callback(callback_id, payload)
+    end
+
+    sig { void }
+    def rerender
+      @app = @environment.load_root(path, headers:)
+      @vtree.replace_root(@app)
+    end
+
+    sig { params(path: String).void }
+    def navigate(path)
+      Console.logger.info(self, "navigate: #{path.inspect}")
+      @app = @environment.load_root(path, headers:)
+      @path = path
+      @vtree.replace_root(@app)
+    end
+
+    sig do
+      params(
+        task: Async::Task,
+        block: T.proc.params(msg: [Symbol, T.untyped]).void
+      ).returns(Async::Barrier)
+    end
+    def run(task: Async::Task.current, &block)
+      root = @vtree.root
+
+      raise "No root!" unless root
+
+      barrier = Async::Barrier.new(parent: @barrier)
+
+      barrier.async do |subtask|
+        yield [:init, { ids: root.id_tree }]
+
+        root.traverse do |vnode|
+          if c = vnode.component
+            # TODO: Make sure the component isn't already mounted..
+            # maybe can check that in the component wrapper?
+            # Also, shouldn't this be done once when resuming rather
+            # than when starting the event stream?
+            c.mount
+          end
+        end
+
+        @vtree.render(@app, lifecycles: true)
+
+        updater = VDOM::VTree::Updater.new(@vtree)
+
+        updater
+          .run(metrics: environment.metrics, task: subtask) do |msg|
+            case msg
+            in [:patch, patches]
+              yield [:patch, patches]
+            in [:exception, error]
+              yield [:exception, error]
+            in [:pong, timestamp]
+              yield [:pong, timestamp]
+            in [:navigate, href]
+              navigate(href)
+              yield [:navigate, path: href.force_encoding("utf-8")]
+            in [:action, payload]
+              yield [:action, payload]
+            in [:update_finished, *]
+              # noop
+            else
+              Console.logger.error(self, "Unknown event: #{msg.inspect}")
+            end
+          end
+          .wait
+
+        barrier.stop
+      end
+
+      barrier.async do
+        loop do
+          # puts "keep alive task"
+          sleep 1
+          yield [:keep_alive, nil]
+        end
+      ensure
+        # puts "Stopped this task"
+        barrier.stop
+      end
+
+      barrier
+    end
+  end
+end

data/lib/mayu/state/README.md

@@ -0,0 +1,6 @@
+# `state/`
+
+This directory contains classes related to dealing with state.
+
+It's inspired by [Redux Toolkit](https://redux-toolkit.js.org/),
+but simplified.