landline 0.9.3 → 0.12.0

data/lib/landline/extensions/session.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Landline
+  # Module for controlling session signing secrets
+  module Session
+    # Set hmac secret
+    # @param secret [String]
+    def self.hmac_secret=(secret)
+      @hmac_secret = secret
+    end
+
+    # Get hmac secret
+    def self.hmac_secret
+      unless @hmac_secret or ENV['HMAC_SECRET']
+        warn <<~MSG
+          warn: hmac secret not supplied, using randomized one
+          warn: provide hmac secret with $HMAC_SECRET or Landline::Session.hmac_secret
+        MSG
+      end
+      @hmac_secret ||= ENV.fetch('HMAC_SECRET', SecureRandom.base64(80))
+    end
+
+    # Class for representing session errors
+    class SessionError < ::StandardError
+    end
+
+    # Class for representing session storage
+    class Session
+      def initialize(cookie, cookies_callback)
+        @data = if cookie
+                  Landline::Util::JWT.from_string(
+                    cookie,
+                    Landline::Session.hmac_secret
+                  )
+                else
+                  Landline::Util::JWT.new({})
+                end
+        @valid = !@data.nil?
+        @cookies_callback = cookies_callback
+      end
+
+      # Retrieve data from session storage
+      # @param key [String, Symbol] serializable key
+      def [](key)
+        raise Landline::Session::SessionError, "session not valid" unless @valid
+
+        unless key.is_a? String or key.is_a? Symbol
+          raise StandardError, "key not serializable"
+        end
+
+        @data.data[key]
+      end
+
+      # Set data to session storage
+      # @param key [String, Symbol] serializable key
+      # @param value [Object] serializable data
+      def []=(key, value)
+        raise Landline::Session::SessionError, "session not valid" unless @valid
+
+        unless key.is_a? String or key.is_a? Symbol
+          raise StandardError, "key not serializable"
+        end
+
+        @data.data[key] = value
+        @cookies_callback.call(@data.make(Landline::Session.hmac_secret))
+      end
+
+      attr_reader :valid
+    end
+  end
+end
+
+module Landline
+  module DSL
+    module ProbeMethods
+      # (in Landline::Probe context)
+      # Return session storage hash
+      # @return [Landline::Session::Session]
+      def session
+        return @session if @session
+
+        @session = Landline::Session::Session.new(
+          request.cookies.dig('session', 0)&.value,
+          proc do |value|
+            delete_cookie("session", value)
+            cookie("session", value)
+          end
+        )
+        request.postprocessors.append(proc do
+          @session = nil
+        end)
+        @session
+      end
+    end
+  end
+end

data/lib/landline/extensions/websocket.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+require 'websocket'
+module Landline
+  # Module that holds websocket primitives
+  module WebSocket
+    # Event system
+    module Eventifier
+      # Attach event listener
+      # @param event [Symbol]
+      # @param listener [#call]
+      def on(event, &listener)
+        @__listeners ||= {}
+        @__listeners[event] ||= []
+        @__listeners[event].append(listener)
+        listener
+      end
+
+      # Attach event listener
+      # @param event [Symbol]
+      # @param listener [#call]
+      def off(event, listener)
+        @__listeners ||= {}
+        @__listeners[event]&.delete(listener)
+      end
+
+      # Await for an event
+      # @param event [Symbol, Array<Symbol>] event or array of events to wait for
+      # @return [Array]
+      # @sg-ignore
+      def await(event)
+        blocking = true
+        output = nil
+        listener = proc do |*data|
+          output = data
+          blocking = false
+        end
+        if event.is_a? Array
+          event.each { |x| on(x, &listener) }
+        else
+          on(event, &listener)
+        end
+        while blocking; end
+        return output[0] if output.is_a? Array and output.length == 1
+
+        output
+      end
+
+      private
+
+      # Trigger the queue clearing process
+      # @return [void]
+      def _process
+        return if @processing
+
+        @__processing = true
+        @__queue ||= []
+        @__listeners ||= {}
+        until @__queue.empty?
+          event, msg = @__queue.shift
+          if @__listeners.include? event
+            @__listeners[event].each { |x| x.call(*msg) }
+          end
+        end
+        @processing = false
+      end
+
+      # Send internal event
+      # @param event [Symbol]
+      # @param data [Array]
+      # @return [void]
+      def _emit(event, *data)
+        return unless @__listeners
+
+        return unless @__listeners.include? event
+
+        @__queue ||= []
+        @__queue.push([event, data])
+        _process
+      end
+    end
+
+    # Socket-like object representing websocket interface
+    class WSockWrapper
+      include Eventifier
+
+      class WebSocketError < StandardError
+      end
+
+      def initialize(io, version: 7)
+        @io = io
+        @version = version
+        @frame_parser = ::WebSocket::Frame::Incoming::Server.new(
+          version: version
+        )
+        @readable = true
+        @writable = true
+        @data = Queue.new
+        on :message do |msg|
+          @data.enq(msg)
+        end
+      end
+
+      # Start the main loop for the eventifier
+      # @return [void]
+      def ready
+        return if @ready
+
+        _loop
+        @ready = true
+      end
+
+      # Send data through websocket
+      # @param data [String] binary data
+      # @return [void]
+      def write(data, type: :text)
+        unless @writable
+          raise self.class::WebSocketError,
+                "socket closed for writing"
+        end
+
+        frame = ::WebSocket::Frame::Outgoing::Server.new(
+          version: @version,
+          data: data,
+          type: type
+        )
+        @io.write(frame.to_s)
+      end
+
+      # Read data from socket synchronously
+      # @return [String, nil] nil returned if socket closes
+      def read
+        unless @readable
+          raise self.class::WebSocketError,
+                "socket closed for reading"
+        end
+
+        @data.deq
+      end
+
+      # Close the socket for reading
+      # @return [void]
+      def close_read
+        _emit :close
+        @readable = false
+        @io.close_read
+      end
+
+      # Close the socket for writing
+      def close_write
+        @writable = false
+        @io.close_write
+      end
+
+      # Establish a connection through handshake
+      # @return [self]
+      def self.handshake(request, version: 7, **opts)
+        raise StandardError, "stream cannot be hijacked" unless request.hijack
+
+        handshake = create_handshake(request, version: version, **opts)
+        return nil unless handshake
+
+        io = request.hijack.call
+        io.sendmsg(handshake.to_s)
+        new(io, version: version)
+      end
+
+      # Initiate a handshake
+      def self.create_handshake(request, **opts)
+        handshake = ::WebSocket::Handshake::Server.new(**opts)
+        handshake.from_hash({
+                              headers: request.headers,
+                              path: request.path_info,
+                              query: request.query.query,
+                              body: request.body
+                            })
+        return nil unless handshake.finished? and handshake.valid?
+
+        handshake
+      end
+
+      # Close the socket
+      # @return [void]
+      def close
+        _close
+        @writable = false
+        @readable = false
+      end
+
+      private
+
+      # Event reading loop
+      # @return [void]
+      def _loop
+        @thread = Thread.new do
+          loop do
+            msg = _read
+            if msg and [:text, :binary].include? msg.type
+              _emit :message, msg
+            elsif msg and msg.type == :close
+              _emit :__close, msg
+              break
+            end
+          end
+        rescue IOError => e
+          @writable = false
+          _emit :error, e
+          close
+        ensure
+          close_read
+        end
+      end
+
+      # Receive data through websocket
+      # @return [String] output from frame
+      def _read
+        while (char = @io.getc)
+          @frame_parser << char
+          frame = @frame_parser.next
+          return frame if frame
+        end
+      end
+
+      # Close the websocket
+      # @return [void]
+      def _close
+        frame = ::WebSocket::Frame::Outgoing::Server.new(
+          version: @version,
+          type: :close
+        )
+        @io.write(frame.to_s) if @writable
+        sleep 0.1
+        @io.close
+      end
+    end
+  end
+end
+
+module Landline
+  module Handlers
+    # Web socket server handler
+    class WebSockServer < Landline::Probe
+      # @param path [Object]
+      # @param parent [Landline::Node]
+      # @param params [Hash] options hash
+      # @param callback [#call] callback to process request within
+      # @option params [Integer] :version protocol version
+      # @option params [Array<String>] :protocols array of supported sub-protocols
+      # @option params [Boolean] :secure true if the server will use wss:// protocol
+      def initialize(path, parent:, **params, &callback)
+        nodeparams = params.dup
+        nodeparams.delete(:version)
+        nodeparams.delete(:protocols)
+        nodeparams.delete(:secure)
+        super(path, parent: parent, **nodeparams)
+        @callback = callback
+        @params = params
+      end
+
+      # Method callback on successful request navigation
+      # Creates a websocket from a given request
+      # @param request [Landline::Request]
+      def process(request)
+        @callback.call(
+          Landline::WebSocket::WSockWrapper.handshake(
+            request,
+            **@params
+          )
+        )
+      end
+    end
+  end
+
+  module DSL
+    module PathConstructors
+      # (in Landline::Path context)
+      # Create a new websocket handler
+      def websocket(path, **args, &setup)
+        register(Landline::Handlers::WebSockServer.new(path,
+                                                       parent: @origin,
+                                                       **args,
+                                                       &setup))
+      end
+    end
+  end
+end

data/lib/landline/node.rb

@@ -35,7 +35,7 @@ module Landline
     end
 
     # Try to navigate the path. Run method callback in response.
-    # @param [Landline::Request]
+    # @param request [Landline::Request]
     # @return [Boolean]
     def go(request)
       # rejected at pattern
@@ -43,7 +43,8 @@ module Landline
 
       request.push_state
       path, splat, param = @pattern.match(request.path)
-      do_filepath(request, request.path.delete_suffix(path))
+      do_filepath(request, request.path.delete_suffix('/')
+                                       .delete_suffix(path))
       request.path = path
       request.splat.append(*splat)
       request.param.merge!(param)

data/lib/landline/path.rb

@@ -5,12 +5,16 @@ require_relative 'node'
 require_relative 'dsl/constructors_path'
 require_relative 'dsl/methods_path'
 require_relative 'dsl/methods_common'
+require_relative 'dsl/methods_probe'
+require_relative 'dsl/constructors_probe'
 require_relative 'util/lookup'
 
 module Landline
   # Execution context for filters and preprocessors.
   class ProcessorContext
     include Landline::DSL::CommonMethods
+    include Landline::DSL::ProbeMethods
+    include Landline::DSL::ProbeConstructors
 
     def initialize(path)
       @origin = path
@@ -27,8 +31,20 @@ module Landline
     end
   end
 
+  # Ephemeral proxy class to which callback execution binds
+  class PathExecutionOrigin
+    def initialize(request, properties)
+      @request = request
+      @properties = Landline::Util::LookupROProxy.new(properties)
+    end
+
+    attr_accessor :response
+    attr_reader :request, :properties
+  end
+
   # Primary building block of request navigation.
   class Path < Landline::Node
+    ExecutionOrigin = Landline::PathExecutionOrigin
     ProcContext = Landline::ProcessorContext
     Context = Landline::PathContext
 
@@ -46,7 +62,6 @@ module Landline
       # Contexts setup
       context = self.class::Context.new(self)
       context.instance_exec(&setup)
-      @proccontext = self.class::ProcContext.new(self)
     end
 
     # Method callback on successful request navigation.
@@ -54,21 +69,11 @@ module Landline
     # @return [Boolean] true if further navigation will be done
     # @raise [UncaughtThrowError] by default throws :response if no matches found.
     def process(request)
-      return false unless run_filters(request)
-
-      run_preprocessors(request)
-      enqueue_postprocessors(request)
-      @children.each do |x|
-        if (value = x.go(request))
-          return value
-        end
+      if @pipeline
+        @pipeline.call(request) { |inner_req| process_wrapped(inner_req) }
+      else
+        process_wrapped(request)
       end
-      value = index(request)
-      return value if value
-
-      _die(404)
-    rescue StandardError => e
-      _die(500, backtrace: [e.to_s] + e.backtrace)
     end
 
     # Add a preprocessor to the path.
@@ -97,14 +102,23 @@ module Landline
 
     attr_reader :children, :properties
 
+    attr_accessor :bounce, :pipeline
+
     private
 
+    # Create an execution context for in-path processing blocks
+    def get_context(request)
+      exec_origin = self.class::ExecutionOrigin.new(request, @properties)
+      self.class::ProcContext.new(exec_origin)
+    end
+
     # Sequentially run through all filters and drop request if one is false
     # @param request [Landline::Request]
     # @return [Boolean] true if request passed all filters
     def run_filters(request)
+      proccontext = get_context(request)
       @filters.each do |filter|
-        return false unless @proccontext.instance_exec(request, &filter)
+        return false unless proccontext.instance_exec(request, &filter)
       end
       true
     end
@@ -112,8 +126,9 @@ module Landline
     # Sequentially run all preprocessors on a request
     # @param request [Landline::Request]
     def run_preprocessors(request)
+      proccontext = get_context(request)
       @preprocessors.each do |preproc|
-        @proccontext.instance_exec(request, &preproc)
+        proccontext.instance_exec(request, &preproc)
       end
     end
 
@@ -123,6 +138,35 @@ module Landline
       request.postprocessors.append(*@postprocessors)
     end
 
+    # Method callback on successful request navigation.
+    # Finds the next appropriate path to go to.
+    # (inner pipeline-wrapped handler)
+    # @return [Boolean] true if further navigation will be done
+    # @raise [UncaughtThrowError] by default throws :response if no matches found.
+    def process_wrapped(request)
+      return false unless run_filters(request)
+
+      run_preprocessors(request)
+      enqueue_postprocessors(request)
+      @children.each do |x|
+        value = x.go(request)
+        return exit_stack(request, value) if value
+      end
+      value = index(request)
+      return exit_stack(request, value) if value
+
+      @bounce ? exit_stack(request) : _die(404)
+    rescue StandardError => e
+      _die(request, 500, backtrace: [e.to_s] + e.backtrace)
+    end
+
+    # Run enqueued postprocessors on navigation failure
+    # @param request [Landline::Request]
+    def exit_stack(request, response = nil)
+      request.run_postprocessors(response)
+      response
+    end
+
     # Try to perform indexing on the path if possible
     # @param request [Landline::Request]
     # @return [Boolean] true if indexing succeeded
@@ -144,13 +188,15 @@ module Landline
     # @param errorcode [Integer]
     # @param backtrace [Array(String), nil]
     # @raise [UncaughtThrowError] throws :finish to stop processing
-    def _die(errorcode, backtrace: nil)
+    def _die(request, errorcode, backtrace: nil)
+      proccontext = get_context(request)
       throw :finish, [errorcode].append(
-        *(@properties["handle.#{errorcode}"] or
-          @properties["handle.default"]).call(
-            errorcode,
-            backtrace: backtrace
-          )
+        *proccontext.instance_exec(
+          errorcode,
+          backtrace: backtrace,
+          &(@properties["handle.#{errorcode}"] or
+            @properties["handle.default"])
+        )
       )
     end
   end

data/lib/landline/pattern_matching/glob.rb

@@ -52,7 +52,7 @@ module Landline
     #     - underscores
     #     - dashes
     class Glob
-      # @param input [String] Glob pattern
+      # @param pattern [String] Glob pattern
       def initialize(pattern)
         pattern = Landline::PatternMatching.canonicalize(pattern)
         pieces = pattern.split(TOKENS)

data/lib/landline/pattern_matching/rematch.rb

@@ -39,7 +39,7 @@ module Landline
       end
 
       # Test if input is convertible and if it should be converted.
-      # @param input
+      # @param string [String] input to test conversion on
       # @return [Boolean] Input can be safely converted to Glob
       def self.can_convert?(string)
         string.is_a? Regexp

data/lib/landline/probe/crosscall_handler.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "../probe"
+
+module Landline
+  module Handlers
+    # Probe that sends files from a location
+    class Link < Landline::Probe
+      # @param path [Object]
+      # @param parent [Landline::Node]
+      def initialize(path, application, parent:)
+        @application = application
+        super(path, parent: parent, filepath: true)
+      end
+
+      # Method callback on successful request navigation.
+      # Sends request over to another rack app, stripping the part of the path that was not navigated
+      # @param request [Landline::Request]
+      # @return [Array(Integer, Host{String => Object}, Object)]
+      def process(request)
+        throw :finish, @application.call(request.env)
+      end
+    end
+  end
+end

data/lib/landline/probe/handler.rb

@@ -7,18 +7,13 @@ module Landline
     # Probe that executes a callback on request
     class Handler < Landline::Probe
       # @param path [Object]
-      # @param parent [Landline::Node]
+      # @param args [Hash] hashed parameters to passthrough to Probe
       # @param exec [#call]
       def initialize(path, **args, &exec)
         super(path, **args)
         @callback = exec
-        @context = Landline::ProbeContext.new(self)
-        @response = nil
       end
- 
-      attr_accessor :response
-      attr_reader :request
- 
+
       # Method callback on successful request navigation.
       # Runs block supplied with object initialization.
       # Request's #splat and #param are passed to block.
@@ -34,20 +29,21 @@ module Landline
       # @return [Boolean] true if further navigation is possible
       # @raise [UncaughtThrowError] may raise if die() is called.
       def process(request)
-        @response = nil
+        origin = Landline::ProbeExecutionOrigin.new(request, @properties)
+        context = Landline::ProbeContext.new(origin)
         return reject(request) unless request.path.match?(/^\/?$/)
- 
-        @request = request
+
         response = catch(:break) do
-          @context.instance_exec(*request.splat,
-                                 **request.param,
-                                 &@callback)
+          context.instance_exec(*request.splat,
+                                **request.param,
+                                &@callback)
         end
         return false unless response
- 
-        if @response and [String, File, IO].include? response.class
-          @response.body = response
-          throw :finish, @response
+
+        oresponse = origin.response
+        if oresponse and [String, File, IO].include? response.class
+          oresponse.body = response
+          throw :finish, oresponse
         end
         throw :finish, response
       end

data/lib/landline/probe/serve_handler.rb

@@ -9,7 +9,6 @@ module Landline
     class Serve < Landline::Probe
       # @param path [Object]
       # @param parent [Landline::Node]
-      # @param exec [#call]
       def initialize(path, parent:)
         super(path, parent: parent, filepath: true)
       end

data/lib/landline/probe.rb

@@ -21,6 +21,7 @@ module Landline
     autoload :TRACE, "landline/probe/http_method"
     autoload :PATCH, "landline/probe/http_method"
     autoload :Serve, "landline/probe/serve_handler"
+    autoload :Link, "landline/probe/crosscall_handler"
   end
 
   # Context that provides execution context for Probes.
@@ -34,6 +35,17 @@ module Landline
     end
   end
 
+  # Ephemeral proxy class to which callback execution binds
+  class ProbeExecutionOrigin
+    def initialize(request, properties)
+      @request = request
+      @properties = Landline::Util::LookupROProxy.new(properties)
+    end
+
+    attr_accessor :response
+    attr_reader :request, :properties
+  end
+
   # Test probe. Also base for all "reactive" nodes.
   class Probe < Landline::Node
     # @param path [Object]