landline 0.10.0 → 0.12.1

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

@@ -4,23 +4,9 @@ require_relative 'pattern_matching'
 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
-    end
-  end
-
   # Execution context for path setup block.
   class PathContext
     include Landline::DSL::PathConstructors
@@ -33,7 +19,6 @@ module Landline
 
   # Primary building block of request navigation.
   class Path < Landline::Node
-    ProcContext = Landline::ProcessorContext
     Context = Landline::PathContext
 
     # @param path [Object] Object to generate {Landline::Pattern} from
@@ -50,7 +35,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 +73,28 @@ 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)
+      request.context.origin.properties.lookup = @properties
+      request.context
+    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)
+        output = catch(:break) do
+          proccontext.instance_exec(request, &filter)
+        end
+        return false unless output
       end
       true
     end
@@ -108,9 +102,15 @@ 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)
+        output = catch(:break) do
+          proccontext.instance_exec(request, &preproc)
+          true
+        end
+        return false unless output
       end
+      true
     end
 
     # Append postprocessors to request
@@ -125,23 +125,33 @@ 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)
+      return false unless 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)
+      notfound(request)
     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
+
+    # Exit with failure or throw 404
+    def notfound(request)
+      @bounce ? exit_stack(request) : _die(request, 404)
     end
 
     # Try to perform indexing on the path if possible
@@ -165,9 +175,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,23 +29,32 @@ module Landline
       # @return [Boolean] true if further navigation is possible
       # @raise [UncaughtThrowError] may raise if die() is called.
       def process(request)
-        @response = nil
+        origin, context = get_context(request)
+
         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
+
+      private
+
+      # Create a context to run handler in
+      def get_context(request)
+        request.context.origin.properties.lookup = @properties
+        [request.context.origin, request.context]
+      end
     end
   end
 end

data/lib/landline/probe.rb

@@ -21,17 +21,7 @@ module Landline
     autoload :TRACE, "landline/probe/http_method"
     autoload :PATCH, "landline/probe/http_method"
     autoload :Serve, "landline/probe/serve_handler"
-  end
-
-  # Context that provides execution context for Probes.
-  class ProbeContext
-    include Landline::DSL::ProbeConstructors
-    include Landline::DSL::ProbeMethods
-    include Landline::DSL::CommonMethods
-
-    def initialize(origin)
-      @origin = origin
-    end
+    autoload :Link, "landline/probe/crosscall_handler"
   end
 
   # Test probe. Also base for all "reactive" nodes.