landline 0.10.0 → 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/path.rb

@@ -31,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
 
@@ -50,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.
@@ -89,18 +100,25 @@ module Landline
       @filters.append(block)
     end
 
-    attr_reader :children, :properties, :request
+    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
@@ -108,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
 
@@ -125,23 +144,27 @@ module Landline
     # @return [Boolean] true if further navigation will be done
     # @raise [UncaughtThrowError] by default throws :response if no matches found.
     def process_wrapped(request)
-      @request = request
       return false unless run_filters(request)
 
       run_preprocessors(request)
       enqueue_postprocessors(request)
       @children.each do |x|
         value = x.go(request)
-        return value if value
+        return exit_stack(request, value) if value
       end
       value = index(request)
-      return value if value
+      return exit_stack(request, value) if value
 
-      @bounce ? false : _die(404)
+      @bounce ? exit_stack(request) : _die(404)
     rescue StandardError => e
-      _die(500, backtrace: [e.to_s] + e.backtrace)
-    ensure
-      @request = nil
+      _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
@@ -165,9 +188,10 @@ 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(
-        *@proccontext.instance_exec(
+        *proccontext.instance_exec(
           errorcode,
           backtrace: backtrace,
           &(@properties["handle.#{errorcode}"] or

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

@@ -12,13 +12,8 @@ module Landline
       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.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]

data/lib/landline/request.rb

@@ -21,10 +21,10 @@ module Landline
       @param = {}
       @splat = []
       # Traversal route. Public and writable.
-      @path = URI.decode_www_form_component(env["PATH_INFO"].dup)
+      @path = URI.decode_www_form_component(env["PATH_INFO"])
       # File serving path. Public and writable.
       @filepath = "/"
-      # Encapsulates all rack variables. Should not be public.
+      # Encapsulates all rack variables. Is no longer private, but usually should not be used directly
       @rack = init_rack_vars(env)
       # Internal navigation states. Private.
       @states = []
@@ -35,18 +35,21 @@ module Landline
     # Run postprocessors
     # @param response [Landline::Response]
     def run_postprocessors(response)
-      @postprocessors.each do |postproc|
+      @postprocessors.reverse_each do |postproc|
         postproc.call(self, response)
       end
+      @postprocessors = []
     end
 
     # Returns request body (if POST data exists)
+    # @note reads data from rack.input, which is not rewindable. .body data is memoized.
     # @return [nil, String]
     def body
       @body ||= @rack.input&.read
     end
 
     # Returns raw Rack input object
+    # @note Rack IO is not always rewindable - if it is read once, the data is gone (i.e. request.body will return nothing).
     # @return [IO] (May not entirely be compatible with IO, see Rack/SPEC.rdoc)
     def input
       @rack.input
@@ -62,10 +65,33 @@ module Landline
       @path, @param, @splat, @filepath = @states.pop
     end
 
+    # Checks if response stream can be partially hijacked
+    def hijack?
+      @_original_env['rack.hijack?']
+    end
+
+    # Returns full hijack callback
+    def hijack
+      @_original_env['rack.hijack']
+    end
+
+    # Reconstructs rack env after modification
+    def env
+      path = @path
+      @_original_env.merge(reconstruct_headers)
+                    .merge({
+                             'PATH_INFO' => path,
+                             'REQUEST_PATH' => path,
+                             'QUERY_STRING' => query.query,
+                             'REQUEST_URI' => "#{path}?#{query.query}"
+                           })
+                    .merge(reconstruct_cookie)
+    end
+
     attr_reader :request_method, :script_name, :path_info, :server_name,
                 :server_port, :server_protocol, :headers, :param, :splat,
-                :postprocessors, :query, :cookies
-    attr_accessor :path, :filepath
+                :postprocessors, :cookies, :rack
+    attr_accessor :path, :filepath, :query
 
     private
 
@@ -117,7 +143,7 @@ module Landline
             .freeze
     end
 
-    # Iniitalize headers hash
+    # Initialize headers hash
     # @param env [Hash]
     # @return Hash
     def init_headers(env)
@@ -131,5 +157,30 @@ module Landline
         x.downcase.gsub("_", "-") if x.is_a? String
       end.freeze
     end
+
+    # Reconstruct headers
+    def reconstruct_headers
+      @headers.filter_map do |k, v|
+        next unless v
+
+        if !['content-type', 'content-length',
+             'remote-addr'].include?(k) && (k.is_a? String)
+          k = "http_#{k}"
+        end
+        k = k.upcase.gsub("-", "_")
+        [k, v]
+      end.to_h
+    end
+
+    # Reconstruct cookie string
+    def reconstruct_cookie
+      return {} if @cookies.empty?
+
+      {
+        "HTTP_COOKIE" => @cookies.map do |_, v|
+          v.finalize_short
+        end.join(";")
+      }
+    end
   end
 end