syntropy 0.2 → 0.4

data/docker-compose.yml

@@ -0,0 +1,51 @@
+services:
+  backend:
+    build: .
+    privileged: true
+    restart: always
+    ports:
+      - 127.0.0.1:1234:1234
+    # expose:
+    #   - 1234
+    volumes:
+      - .:/home/app
+    deploy:
+      # replicas: 1
+      resources:
+        limits:
+          memory: 500M
+    # restart: unless-stopped
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "1M"
+        max-file: "10"
+
+    # healthcheck:
+    #   test: "curl 'http://localhost:1234/?q=ping'"
+    #   interval: "30s"
+    #   timeout: "3s"
+    #   start_period: "5s"
+    #   retries: 3
+
+  proxy:
+    depends_on:
+      - backend
+    build:
+      context: ./proxy
+      dockerfile: Dockerfile
+    restart: always
+    volumes:
+      - ./proxy/etc/Caddyfile:/etc/caddy/Caddyfile
+    ports:
+      - "80:80"
+      - "443:443"
+      - "443:443/udp"
+    # env_file:
+      # - ./conf/caddy.env
+      # - ./conf/caddy_sensitive.env
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "1M"
+        max-file: "10"

data/lib/syntropy/app.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
-require 'qeweney'
 require 'json'
+require 'yaml'
+
+require 'qeweney'
 require 'papercraft'
 
 require 'syntropy/errors'
@@ -12,23 +14,23 @@ module Syntropy
   class App
     attr_reader :route_cache
 
-    def initialize(machine, src_path, mount_path, env = {})
+    def initialize(machine, src_path, mount_path, opts = {})
       @machine = machine
-      @src_path = src_path
+      @src_path = File.expand_path(src_path)
       @mount_path = mount_path
       @route_cache = {}
-      @env = env
+      @opts = opts
 
       @relative_path_re = calculate_relative_path_re(mount_path)
-      if (wf = env[:watch_files])
-        period = wf.is_a?(Numeric) ? wf : 0.1
-        machine.spin do
-          Syntropy.file_watch(@machine, src_path, period: period) { invalidate_cache(it) }
-        rescue Exception => e
-          p e
-          p e.backtrace
-        end
+      @machine.spin do
+        # we do startup stuff asynchronously, in order to first let TP2 do its
+        # setup tasks
+        @machine.sleep 0.15
+        @opts[:logger]&.call("Serving from #{File.expand_path(@src_path)}")
+        start_file_watcher if opts[:watch_files]
       end
+
+      @module_loader ||= Syntropy::ModuleLoader.new(@src_path, @opts)
     end
 
     def find_route(path, cache: true)
@@ -36,24 +38,16 @@ module Syntropy
       return cached if cached
 
       entry = calculate_route(path)
-      if entry[:kind] != :not_found
-        @route_cache[path] = entry if cache
-      end
+      @route_cache[path] = entry if entry[:kind] != :not_found && cache
       entry
     end
 
-    def invalidate_cache(fn)
-      invalidated_keys = []
-      @route_cache.each do |k, v|
-        invalidated_keys << k if v[:fn] == fn
-      end
-
-      invalidated_keys.each { @route_cache.delete(it) }
-    end
-
     def call(req)
       entry = find_route(req.path)
       render_entry(req, entry)
+    rescue Syntropy::Error => e
+      msg = e.message
+      req.respond(msg.empty? ? nil : msg, ':status' => e.http_status)
     rescue StandardError => e
       p e
       p e.backtrace
@@ -62,9 +56,37 @@ module Syntropy
 
     private
 
+    def start_file_watcher
+      @opts[:logger]&.call('Watching for module file changes...', nil)
+      wf = @opts[:watch_files]
+      period = wf.is_a?(Numeric) ? wf : 0.1
+      @machine.spin do
+        Syntropy.file_watch(@machine, @src_path, period: period) do
+          @opts[:logger]&.call("Detected changed file: #{it}")
+          invalidate_cache(it)
+        rescue Exception => e
+          p e
+          p e.backtrace
+          exit!
+        end
+      end
+    end
+
+    def invalidate_cache(fn)
+      @module_loader.unload(fn)
+
+      invalidated_keys = []
+      @route_cache.each do |k, v|
+        @opts[:logger]&.call("Invalidate cache for #{k}", nil)
+        invalidated_keys << k if v[:fn] == fn
+      end
+
+      invalidated_keys.each { @route_cache.delete(it) }
+    end
+
     def calculate_relative_path_re(mount_path)
       mount_path = '' if mount_path == '/'
-      /^#{mount_path}(?:\/(.*))?$/
+      %r{^#{mount_path}(?:/(.*))?$}
     end
 
     FILE_KINDS = {
@@ -74,7 +96,7 @@ module Syntropy
     NOT_FOUND = { kind: :not_found }
 
     # We don't allow access to path with /.., or entries that start with _
-    FORBIDDEN_RE = /(\/_)|((\/\.\.)\/?)/
+    FORBIDDEN_RE = %r{(/_)|((/\.\.)/?)}
 
     def calculate_route(path)
       return NOT_FOUND if path =~ FORBIDDEN_RE
@@ -95,7 +117,7 @@ module Syntropy
     end
 
     def file_entry(fn)
-      { fn: fn, kind: FILE_KINDS[File.extname(fn)] || :static }
+      { fn: File.expand_path(fn), kind: FILE_KINDS[File.extname(fn)] || :static }
     end
 
     def find_index_entry(dir)
@@ -126,7 +148,7 @@ module Syntropy
       entry[:kind] == :module ? entry : NOT_FOUND
     end
 
-    UP_TREE_PATH_RE = /^(.+)?\/[^\/]+$/
+    UP_TREE_PATH_RE = %r{^(.+)?/[^/]+$}
 
     def parent_path(path)
       m = path.match(UP_TREE_PATH_RE)
@@ -136,21 +158,47 @@ module Syntropy
     def render_entry(req, entry)
       case entry[:kind]
       when :not_found
-        req.respond('Not found', ':status' => Qeweney::Status::NOT_FOUND)
+        respond_not_found(req, entry)
       when :static
-        entry[:mime_type] ||= Qeweney::MimeTypes[File.extname(entry[:fn])]
-        req.respond(IO.read(entry[:fn]), 'Content-Type' => entry[:mime_type])
+        respond_static(req, entry)
       when :markdown
-        body = render_markdown(IO.read(entry[:fn]))
-        req.respond(body, 'Content-Type' => 'text/html')
+        respond_markdown(req, entry)
       when :module
-        call_module(entry, req)
+        respond_module(req, entry)
       else
-        raise "Invalid entry kind"
+        raise 'Invalid entry kind'
       end
     end
 
-    def call_module(entry, req)
+    def respond_not_found(req, _entry)
+      headers = { ':status' => Qeweney::Status::NOT_FOUND }
+      case req.method
+      when 'head'
+        req.respond(nil, headers)
+      else
+        req.respond('Not found', headers)
+      end
+    end
+
+    def respond_static(req, entry)
+      entry[:mime_type] ||= Qeweney::MimeTypes[File.extname(entry[:fn])]
+      headers = { 'Content-Type' => entry[:mime_type] }
+      req.respond_by_http_method(
+        'head'  => [nil, headers],
+        'get'   => -> { [IO.read(entry[:fn]), headers] }
+      )
+    end
+
+    def respond_markdown(req, entry)
+      entry[:mime_type] ||= Qeweney::MimeTypes[File.extname(entry[:fn])]
+      headers = { 'Content-Type' => entry[:mime_type] }
+      req.respond_by_http_method(
+        'head'  => [nil, headers],
+        'get'   => -> { [render_markdown(entry[:fn]), headers] }
+      )
+    end
+
+    def respond_module(req, entry)
       entry[:code] ||= load_module(entry)
       if entry[:code] == :invalid
         req.respond(nil, ':status' => Qeweney::Status::INTERNAL_SERVER_ERROR)
@@ -158,6 +206,8 @@ module Syntropy
       end
 
       entry[:code].call(req)
+    rescue Syntropy::Error => e
+      req.respond(nil, ':status' => e.http_status)
     rescue StandardError => e
       p e
       p e.backtrace
@@ -165,28 +215,62 @@ module Syntropy
     end
 
     def load_module(entry)
-      loader = Syntropy::ModuleLoader.new(@src_path, @env)
-      ref = entry[:fn].gsub(%r{^#{@src_path}\/}, '').gsub(/\.rb$/, '')
-      o = loader.load(ref)
-      # klass = Class.new
-      # o = klass.instance_eval(body, entry[:fn], 1)
-
-      if o.is_a?(Papercraft::HTML)
-        return wrap_template(o)
-      else
-        return o
-      end
+      ref = entry[:fn].gsub(%r{^#{@src_path}/}, '').gsub(/\.rb$/, '')
+      o = @module_loader.load(ref)
+      o.is_a?(Papercraft::Template) ? wrap_template(o) : o
+    rescue Exception => e
+      @opts[:logger]&.call("Error while loading module #{ref}: #{e.message}")
+      :invalid
     end
 
     def wrap_template(templ)
-      ->(req) {
+      lambda { |req|
         body = templ.render
         req.respond(body, 'Content-Type' => 'text/html')
       }
     end
 
-    def render_markdown(str)
-      Papercraft.markdown(str)
+    def render_markdown(fn)
+      atts, md = parse_markdown_file(fn)
+
+      if atts[:layout]
+        layout = @module_loader.load("_layout/#{atts[:layout]}")
+        html = layout.apply { emit_markdown(md) }.render
+      else
+        html = Papercraft.markdown(md)
+      end
+      html
+    end
+
+    DATE_REGEXP = /(\d{4}\-\d{2}\-\d{2})/
+    FRONT_MATTER_REGEXP = /\A(---\s*\n.*?\n?)^((---|\.\.\.)\s*$\n?)/m
+    YAML_OPTS = {
+      permitted_classes: [Date],
+      symbolize_names: true
+    }
+
+    # Parses the markdown file at the given path.
+    #
+    # @param path [String] file path
+    # @return [Array] an tuple containing properties<Hash>, contents<String>
+    def parse_markdown_file(path)
+      content = IO.read(path) || ''
+      atts = {}
+
+      # Parse date from file name
+      if (m = path.match(DATE_REGEXP))
+        atts[:date] ||= Date.parse(m[1])
+      end
+
+      if (m = content.match(FRONT_MATTER_REGEXP))
+        front_matter = m[1]
+        content = m.post_match
+
+        yaml = YAML.safe_load(front_matter, **YAML_OPTS)
+        atts = atts.merge(yaml)
+      end
+
+      [atts, content]
     end
   end
 end

data/lib/syntropy/errors.rb

@@ -4,17 +4,31 @@ require 'qeweney'
 
 module Syntropy
   class Error < StandardError
+    Status = Qeweney::Status
+
     attr_reader :http_status
 
     def initialize(status, msg = '')
-      @http_status = status || Qeweney::Status::INTERNAL_SERVER_ERROR
       super(msg)
+      @http_status = status || Qeweney::Status::INTERNAL_SERVER_ERROR
+    end
+
+    class << self
+      # Create class methods for common errors
+      {
+        not_found:          Status::NOT_FOUND,
+        method_not_allowed: Status::METHOD_NOT_ALLOWED,
+        teapot:             Status::TEAPOT
+      }
+      .each { |k, v|
+        define_method(k) { |msg = ''| new(v, msg) }
+      }
     end
   end
 
   class ValidationError < Error
     def initialize(msg)
-      @http_status = Qeweney::Status::BAD_REQUEST
+      super(Qeweney::Status::BAD_REQUEST, msg)
     end
   end
 end

data/lib/syntropy/module.rb

@@ -1,37 +1,54 @@
 # frozen_string_literal: true
 
+require 'papercraft'
+
 module Syntropy
   class ModuleLoader
     def initialize(root, env)
       @root = root
       @env = env
-      @loaded = {}
+      @loaded = {} # maps ref to code
+      @fn_map = {} # maps filename to ref
     end
 
     def load(ref)
       @loaded[ref] ||= load_module(ref)
     end
 
+    def unload(fn)
+      ref = @fn_map[fn]
+      return if !ref
+
+      @loaded.delete(ref)
+      @fn_map.delete(fn)
+    end
+
     private
 
     def load_module(ref)
-      fn = File.join(@root, "#{ref}.rb")
-      raise RuntimeError, "File not found #{fn}" if !File.file?(fn)
+      fn = File.expand_path(File.join(@root, "#{ref}.rb"))
+      @fn_map[fn] = ref
+      raise "File not found #{fn}" if !File.file?(fn)
 
       mod_body = IO.read(fn)
       mod_ctx = Class.new(Syntropy::Module)
       mod_ctx.loader = self
-      # mod_ctx = .new(self, @env)
       mod_ctx.module_eval(mod_body, fn, 1)
 
       export_value = mod_ctx.__export_value__
 
+      wrap_module(mod_ctx, export_value)
+    end
+
+    def wrap_module(mod_ctx, export_value)
       case export_value
       when nil
-        raise RuntimeError, 'No export found'
+        raise 'No export found'
       when Symbol
         # TODO: verify export_value denotes a valid method
         mod_ctx.new(@env)
+      when String
+        ->(req) { req.respond(export_value) }
       when Proc
         export_value
       else
@@ -57,6 +74,10 @@ module Syntropy
       @__export_value__ = ref
     end
 
+    def self.templ(&block)
+      Papercraft.html(&block)
+    end
+
     def self.__export_value__
       @__export_value__
     end

data/lib/syntropy/request_extensions.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'qeweney'
+
+module Syntropy
+  module RequestExtensions
+    def ctx
+      @ctx ||= {}
+    end
+
+    def validate_http_method(*accepted)
+      raise Syntropy::Error.method_not_allowed if !accepted.include?(method)
+    end
+
+    def respond_by_http_method(map)
+      value = map[self.method]
+      raise Syntropy::Error.method_not_allowed if !value
+
+      value = value.() if value.is_a?(Proc)
+      (body, headers) = value
+      respond(body, headers)
+    end
+
+    def respond_on_get(body, headers = {})
+      case self.method
+      when 'head'
+        respond(nil, headers)
+      when 'get'
+        respond(body, headers)
+      else
+      raise Syntropy::Error.method_not_allowed
+      end
+    end
+
+    def respond_on_post(body, headers = {})
+      case self.method
+      when 'head'
+        respond(nil, headers)
+      when 'post'
+        respond(body, headers)
+      else
+      raise Syntropy::Error.method_not_allowed
+      end
+    end
+
+    def validate_param(name, *clauses)
+      value = query[name]
+      clauses.each do |c|
+        valid = param_is_valid?(value, c)
+        raise(Syntropy::ValidationError, 'Validation error') if !valid
+
+        value = param_convert(value, c)
+      end
+      value
+    end
+
+    private
+
+    BOOL_REGEXP = /^(t|f|true|false|on|off|1|0|yes|no)$/
+    BOOL_TRUE_REGEXP = /^(t|true|on|1|yes)$/
+    INTEGER_REGEXP = /^[+-]?[0-9]+$/
+    FLOAT_REGEXP = /^[+-]?[0-9]+(\.[0-9]+)?$/
+
+    def param_is_valid?(value, cond)
+      return cond.any? { |c| param_is_valid?(value, c) } if cond.is_a?(Array)
+
+      if value
+        if cond == :bool
+          return value =~ BOOL_REGEXP
+        elsif cond == Integer
+          return value =~ INTEGER_REGEXP
+        elsif cond == Float
+          return value =~ FLOAT_REGEXP
+        end
+      end
+
+      cond === value
+    end
+
+    def param_convert(value, klass)
+      if klass == :bool
+        value =~ BOOL_TRUE_REGEXP ? true : false
+      elsif klass == Integer
+        value.to_i
+      elsif klass == Float
+        value.to_f
+      elsif klass == Symbol
+        value.to_sym
+      else
+        value
+      end
+    end
+  end
+end
+
+Qeweney::Request.include(Syntropy::RequestExtensions)

data/lib/syntropy/rpc_api.rb

@@ -11,7 +11,7 @@ module Syntropy
     end
 
     def call(req)
-      response, status = invoke(req)
+      response, status = __invoke__(req)
       req.respond(
         response.to_json,
         ':status'       => status,
@@ -19,15 +19,17 @@ module Syntropy
       )
     end
 
-    def invoke(req)
-      q = req.validate_param(:q, String)
+    private
+
+    def __invoke__(req)
+      q = req.validate_param(:q, String).to_sym
       response = case req.method
       when 'get'
-        send(q.to_sym, req)
+        __invoke_get__(q, req)
       when 'post'
-        send(:"#{q}!", req)
+        __invoke_post__(q, req)
       else
-        raise Syntropy::Error.new(Qeweney::Status::METHOD_NOT_ALLOWED)
+        raise Syntropy::Error.method_not_allowed
       end
       [{ status: 'OK', response: response }, Qeweney::Status::OK]
     rescue => e
@@ -35,14 +37,29 @@ module Syntropy
         p e
         p e.backtrace
       end
-      error_response(e)
+      __error_response__(e)
+    end
+
+    def __invoke_get__(sym,  req)
+      return send(sym, req) if respond_to?(sym)
+
+      err = respond_to?(:"#{sym}!") ? Syntropy::Error.method_not_allowed : Syntropy::Error.not_found
+      raise err
+    end
+
+    def __invoke_post__(sym, req)
+      sym_post = :"#{sym}!"
+      return send(sym_post, req) if respond_to?(sym_post)
+
+      err = respond_to?(sym) ? Syntropy::Error.method_not_allowed : Syntropy::Error.not_found
+      raise err
     end
 
     INTERNAL_SERVER_ERROR = Qeweney::Status::INTERNAL_SERVER_ERROR
 
-    def error_response(err)
+    def __error_response__(err)
       http_status = err.respond_to?(:http_status) ? err.http_status : INTERNAL_SERVER_ERROR
-      error_name = err.class.name
+      error_name = err.class.name.split('::').last
       [{ status: error_name, message: err.message }, http_status]
     end
   end

data/lib/syntropy/side_run.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'etc'
+
+module Syntropy
+  module SideRun
+    class << self
+      def call(machine, &block)
+        setup if !@queue
+
+        # TODO: share mailboxes, acquire them with e.g. with_mailbox { |mbox| ... }
+        mailbox = Thread.current[:fiber_mailbox] ||= UM::Queue.new
+        machine.push(@queue, [mailbox, block])
+        result = machine.shift(mailbox)
+        result.is_a?(Exception) ? (raise result) : result
+      end
+
+      def setup
+        @queue = UM::Queue.new
+        count = (Etc.nprocessors - 1).clamp(2..6)
+        @workers = count.times.map {
+          Thread.new { side_run_worker(@queue) }
+        }
+      end
+
+      def side_run_worker(queue)
+        machine = UM.new
+        loop { handle_request(machine, queue) }
+      rescue UM::Terminate
+        # # We can also add a timeout here
+        # t0 = Time.now
+        # while !queue.empty? && (Time.now - t0) < 10
+        #   handle_request(machine, queue)
+        # end
+      end
+
+      def handle_request(machine, queue)
+        response_mailbox, closure = machine.shift(queue)
+        result = closure.call
+        machine.push(response_mailbox, result)
+      rescue Exception => e
+        machine.push(response_mailbox, e)
+      end
+    end
+  end
+end

data/lib/syntropy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Syntropy
-  VERSION = '0.2'
+  VERSION = '0.4'
 end