rider-server 0.1.0 → 0.1.2

data/lib/rider_server/server.rb

@@ -9,6 +9,7 @@
 
 require "rider_server/exception_extension"
 require "rider_server/operations"
+require "rider_server/request"
 require "rider_server/utils"
 require "rider_server/logger"
 require "bencode"
@@ -17,30 +18,28 @@ module RiderServer
   class Server
     include RiderServer::Logger
 
+    # The status of the server, either +:running+ or +:stopped+
     attr_reader :status
-    attr_reader :listeners
 
-    def initialize
+    def initialize(config)
+      @config = config
       @status = :stopped
-      @shutdown_pipe = nil
-    end
 
-    def listen(address, port)
-      Utils.create_listeners(address, port)
-    end
-
-    def setup_shutdown_pipe
-      @shutdown_pipe ||= IO.pipe
+      RiderServer::Logger.configure_logger(level: @config.log_level)
     end
 
+    # Start the servers main event loop.  This will bind to the
+    # configured host and port, and create threads for sending and
+    # recieving requests.
     def run
-      socket = listen("127.0.0.1", 7888)
+      socket = listen(@config.host, @config.port)
       request_count = 0
 
       responses = Thread::Queue.new
-      operations = Operations.new(responses)
+      operations = RiderServer.create_operation_handler(@config, responses)
 
       loop do
+        @status = :running
         client = socket[0].accept
 
         request_count += 1
@@ -57,8 +56,8 @@ module RiderServer
 
             begin
               output = response.bencode
-            rescue StandardError => e
-              log.error "Error encoding response: #{e}"
+            rescue => e
+              log.error "Error encoding response: #{e}\n #{e.backtrace.join("\n")}"
               response = Response.new(response.to_h)
               response.set("ex", e.inspect)
               response.set("out", e.full_message)
@@ -67,9 +66,9 @@ module RiderServer
             end
 
             if log.debug?
-              log.debug "sending response #{response.to_h}"
+              log.debug "Sending response #{response.to_h}"
             else
-              log.info "sending response #{response.inspect}"
+              log.info "Sending response #{response.inspect}"
             end
             client.write(output)
             # Try to allow time for the client to read the response
@@ -92,13 +91,26 @@ module RiderServer
             operation = parser.parse!
 
             log.debug(operation.inspect)
-            operations.handle(operation)
+
+            begin
+              operations.handle(::RiderServer::Request.new(operation))
+            rescue => e
+              log.error "Error handling request: #{e}\n #{e.backtrace}"
+            end
           end
         }
         threads.each { |thr| thr.join }
 
         client.close
+        @status = :stopped
       end
     end
+
+    private
+
+    # Open a TCP server listening on an +address+ and +port+.
+    def listen(address, port)
+      Utils.create_listeners(address, port)
+    end
   end
 end

data/lib/rider_server/services/capture_exceptions.rb

@@ -28,11 +28,27 @@ module RiderServer
         }
       end
 
-      def self.handle_exception(exception, metadata = {})
+      def self.create_exception_wrapper(exception, metadata)
+        id = SecureRandom.uuid
+        {
+          "id" => id,
+          "created_at" => DateTime.now,
+          "exception" => exception,
+          "metadata" => metadata
+        }
+      end
+
+      def self.handle_exception(exception, metadata: {})
+        wrapped_ex = create_exception_wrapper(exception, metadata)
+        # Firstly this needs to generate wrapper for the exception
+        # This needs to use push exception
+
         @sessions.each do |session, stream_id|
-          ex = session.add_exception(stream_id, exception, metadata)
+          ex = session.add_wrapped_exception(wrapped_ex)
           session.response_queue.push(create_response(stream_id, ex))
         end
+
+        wrapped_ex
       end
 
       def initialize(session)

data/lib/rider_server/services/rails.rb

@@ -51,7 +51,7 @@ module RiderServer
             end
           end
         rescue => e
-          @session.push_exception(stream_id, e)
+          @session.add_exception(stream_id, e)
           nputs "Error starting Rails Server: #{e.message}"
         end
       end

data/lib/rider_server/session.rb

@@ -15,8 +15,28 @@ require "rider_server/services/rails"
 require "rider_server/services/capture_io"
 require "rider_server/services/capture_exceptions"
 require "rider_server/logger"
+require "rider_server/session_operations/eval"
+require "rider_server/session_operations/inspect"
+require "rider_server/session_operations/inspect_exception"
+require "rider_server/session_operations/interrupt"
+require "rider_server/session_operations/load_path"
+require "rider_server/session_operations/ls_exceptions"
+require "rider_server/session_operations/ls_services"
+require "rider_server/session_operations/service"
+require "rider_server/session_operations/set_namespace"
+require "rider_server/session_operations/set_namespace_variable"
 
 module RiderServer
+  def self.create_session(config, response_queue, history: [])
+    session = Session.new(config, response_queue, history: history)
+
+    ObjectSpace.each_object(Class).select { |klass| klass < ::RiderServer::Service }.map do |klass, h|
+      session.add_service klass
+    end
+
+    session
+  end
+
   class Session
     include RiderServer::Logger
 
@@ -27,24 +47,17 @@ module RiderServer
     attr_reader :response_queue
     attr_reader :history
 
-    SERVICES = [
-      Services::Rails,
-      Services::CaptureIO,
-      Services::CaptureExceptions
-    ]
-
-    def initialize(response_queue, history: [])
+    def initialize(config, response_queue, history: [])
       @id = SecureRandom.uuid
+      @config = config
       @history = history
       @workspace = Workspace.new
       @queue = Thread::Queue.new
-      @exceptions = Utils::FixedArray.new
+      @exceptions = Utils::FixedArray.new(max_size: config.exception_history_size)
       @response_queue = response_queue
       @exception_queue = Thread::Queue.new
       @evaluations = {}
-      @services = SERVICES.each_with_object({}) do |klass, h|
-        h[klass.service_name] = klass.new(self)
-      end
+      @services = {}
 
       # XXX Side effects in initializer, :()
       start_exception_processing
@@ -56,34 +69,40 @@ module RiderServer
       end
     end
 
+    def stdin
+      ::STDIN  # rubocop:disable Style/GlobalStdStream
+    end
+
     def clone
-      Session.new(@responses_queue, history: @history.clone)
+      RiderServer.create_session(@responses_queue, history: @history.clone)
     end
 
     #
     # Input History
     #
 
+    # Push an event onto the history stack.
     def push_history(event)
       @history.push(event)
     end
 
-    def last_history
-      @history.last
-    end
-
     #
     # Historical Results
     #
 
+    # Return a Hash containing all historical evaluations.
     def result_history
       @result_history ||= {}
     end
 
+    # Add an execution result to the history. The +evaluation_id+ is
+    # the operation id of the evaluation and the +value+ is the result
+    # of the evaluation.
     def add_result(evaluation_id, value)
       result_history[evaluation_id] = value
     end
 
+    # Return a historical result of an evaluation by +evaluation_id+.
     def get_result(evaluation_id)
       raise "Missing history item #{evaluation_id}." unless result_history.key?(evaluation_id)
       result_history[evaluation_id]
@@ -93,39 +112,44 @@ module RiderServer
     # Historical Exceptions
     #
 
+    # Add an exception to the exception history. +operation_id+ is the
+    # id of the request. +exception+ is the exception
+    # object. +metadata+ is a Hash containing additional information
+    # about the exception.
     def add_exception(operation_id, exception, metadata = {})
-      id = SecureRandom.uuid
-      @exceptions << {
-        "id" => id,
-        "operation_id" => operation_id,
-        "created_at" => DateTime.now,
-        "exception" => exception,
-        "metadata" => metadata
-      }
-      id
+      ex = wrap_exception(operation_id, exception, metadata)
+      @exception_queue.push(ex)
+      ex
     end
 
+    # Add an exception that has already been wrapped in metadata.
+    # +wrapped_exception+ should be a hash, that has the keys "id",
+    # "created_at", "exception", and "metadata"
+    def add_wrapped_exception(wrapped_exception)
+      @exception_queue.push(wrapped_exception)
+      exception
+    end
+
+    # Return an exception by +exception_id+. Raises an exception if
+    # the exception doesn't exist.
     def get_exception(exception_id)
       exception = @exceptions.find { |item| item["id"] == exception_id }
       raise "Missing exception #{exception_id}." unless exception
       exception
     end
 
-    # A threadsafe way to add exceptions
-    def push_exception(operation_id, exception, metadata = {})
-      @exception_queue.push([operation_id, exception, metadata])
-    end
-
+    # Start a thread to process exceptions from the exception queue.
     def start_exception_processing
       return if @exception_processing_thread
 
       @exception_processing_thread = Thread.new do
         loop do
-          add_exception(*@exception_queue.pop)
+          @exceptions << @exception_queue.pop
         end
       end
     end
 
+    # Stop the exception processing thread.
     def stop_exception_processing
       @exception_processing_thread.exit
       @exception_processing_thread = nil
@@ -156,11 +180,17 @@ module RiderServer
     #
     # Service control
     #
+
+    def add_service(service_class)
+      cls = service_class.new(self)
+      @services[service_class.service_name] = cls
+    end
+
     def list_services
-      SERVICES.map do |klass|
+      @services.map do |name, _|
         {
-          "name" => klass.service_name,
-          "state" => service_state(klass.service_name).to_s
+          "name" => name,
+          "state" => service_state(name).to_s
         }
       end
     end
@@ -186,5 +216,18 @@ module RiderServer
         :stopped
       end
     end
+
+    private
+
+    def wrap_exception(operation_id, exception, metadata = {})
+      id = SecureRandom.uuid
+      {
+        "id" => id,
+        "operation_id" => operation_id,
+        "created_at" => DateTime.now,
+        "exception" => exception,
+        "metadata" => metadata
+      }
+    end
   end
 end

data/lib/rider_server/session_operation.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+#
+# session_operation.rb -- Base class for operations
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+require "rider_server/operation"
+
+module RiderServer
+  class SessionOperation < Operation
+    # Operations registry
+    @operations = {}
+  end
+end

data/lib/rider_server/session_operations/eval.rb

@@ -0,0 +1,61 @@
+require "rider_server/session_operation"
+require "rider_server/response"
+require "rider_server/utils"
+
+module RiderServer
+  SessionOperation.define do
+    name "eval"
+    documentation "Evaluate a string of code"
+
+    argument :id, :string, "The request id", required: true
+    argument :code, :string, "The code to evaluate"
+    argument :ns, :string, "The namespace to evaluate the code in"
+    argument :file, :string, "The file the code is from"
+    argument :line, :integer, "The line number the code is from"
+
+    def handle(session, operation)
+      # TODO should do something if the session is nil
+
+      response = Response.new(operation)
+
+      # Abort if there is an evaluation with the same id
+      if session.running_evaluation?(operation["id"])
+        msg = "Evaluation already in progress for #{operation["id"]}"
+        log.warn(msg)
+        response.set("value", msg)
+        response.status("eval-error", "done")
+        send_response(response)
+        return
+      end
+
+      session.push_history(operation)
+      code = operation["code"]
+      ns = operation["ns"]
+      file = operation["file"] || ""
+      line = operation["line"] || 0
+
+      eval_thread = Thread.new do
+        begin
+          value = session.workspace.evaluate(code, ns, file, line)
+          response.set("value", Utils.rider_display(value))
+          response.set("ns", session.workspace.evaluate("inspect"))
+          response.status("done")
+          session.add_result(operation["id"], value)
+          session.send_response(response)
+        rescue EvalInterrupt, ScriptError, StandardError => e
+          response.set("ex", e.inspect)
+          response.set("ns", session.workspace.evaluate("inspect"))
+          response.status("eval-error", "done")
+          exception = session.add_exception(operation["id"], e)
+          response.set("rider/exception-id", exception["id"])
+          session.send_response(response)
+        end
+
+        session.remove_evaluation(operation["id"])
+      end
+
+      session.add_evaluation(operation["id"], eval_thread)
+      nil
+    end
+  end
+end

data/lib/rider_server/session_operations/inspect.rb

@@ -0,0 +1,123 @@
+require "rider_server/inspect"
+require "rider_server/operation"
+require "rider_server/response"
+require "rider_server/utils"
+
+module RiderServer
+  SessionOperation.define do
+    name "inspect"
+    documentation "Inspect an object"
+
+    argument :id, :string, "The request id", required: true
+    argument :location, :array, "The location of the object to inspect"
+
+    def handle(session, operation)
+      response = Response.new(operation)
+      location = operation["location"]
+      raise "Location is required" if location.nil? || location.empty?
+
+      value = traverse_location(location, nil, session)
+      response.set("name", Utils.rider_display(value))
+
+      if value.is_a?(Array)
+        value = value.map.with_index do |item, index|
+          {
+            "name" => item.to_s,
+            "value" => Utils.rider_display(item),
+            "inspect-location" => "rider_array_item:#{index}"
+          }
+        end
+        response.set("value-array", value)
+      elsif value.is_a?(Hash) || value.eql?(::ENV)
+        value = value.map do |key, value|
+          [
+            {
+              "name" => key.to_s,
+              "value" => Utils.rider_display(key),
+              "inspect-location" => "rider_hash_key:#{key.hash}"
+            },
+            {
+              "name" => value.to_s,
+              "value" => Utils.rider_display(value),
+              "inspect-location" => "rider_hash_value:#{key.hash}"
+            }
+          ]
+        end
+        response.set("value-hash", value)
+      elsif value.is_a?(String)
+        response.set("value", value.inspect)
+      elsif value.is_a?(Numeric)
+        response.set("value", value.to_s)
+      end
+
+      response.set("inspect-location", location)
+
+      response.set("class", RiderServer::Inspect.inspect_class(value))
+      response.set("singleton-class", RiderServer::Inspect.inspect_singleton_class(value))
+      response.set("ancestors", RiderServer::Inspect.inspect_ancestors(value))
+      response.set("constants", RiderServer::Inspect.inspect_constants(value))
+      response.set("methods", RiderServer::Inspect.inspect_methods(value))
+      response.set("instance-variables", RiderServer::Inspect.inspect_instance_variables(value))
+      response.set("instance-methods", RiderServer::Inspect.inspect_instance_methods(value))
+      response.set("class-variables", RiderServer::Inspect.inspect_class_variables(value))
+      response.status("done")
+      response
+    end
+
+    def traverse_location(location, ctx, session)
+      loc = location.first
+      locs = location.drop(1)
+
+      if locs.empty?
+        lookup_object(loc, ctx, session)
+      else
+        traverse_location(locs, lookup_object(loc, ctx, session), session)
+      end
+    end
+
+    def lookup_object(loc, ctx, session)
+      lookup, identifier = loc.split(":", 2)
+
+      case lookup
+      when "rider_main"
+        "main"
+      when "rider_history"
+        rider_history(identifier, nil, session)
+      when "rider_exception"
+        rider_exception(identifier, nil, session)
+      when "rider_stackframe_variable"
+        frame_id, local_var = identifier.split(":", 2)
+        ctx.__rider_bindings_stack[frame_id.to_i].local_variable_get(local_var)
+      when "rider_array_item"
+        ctx[identifier.to_i]
+      when "rider_hash_key"
+        hash = identifier.to_i
+        ctx.keys.find { |key| key.hash == hash }
+      when "rider_hash_value"
+        hash = identifier.to_i
+        key = ctx.keys.find { |key| key.hash == hash }
+        ctx.fetch(key)
+      when "toplevel_const_get"
+        Object.const_get(identifier)
+      when "instance_variable_get"
+        ctx.instance_variable_get(identifier)
+      when "singleton_class"
+        ctx.singleton_class
+      when "const_get"
+        ctx.const_get(identifier)
+      when "ancestor_find"
+        ctx.class.ancestors.find { |item| item.to_s == identifier }
+      else
+        raise "Unknown inspect function: #{lookup}"
+      end
+    end
+
+    def rider_history(id, ctx, session)
+      session.get_result(id)
+    end
+
+    def rider_exception(id, ctx, session)
+      session.get_exception(id)["exception"]
+    end
+  end
+end

data/lib/rider_server/session_operations/inspect_exception.rb

@@ -0,0 +1,46 @@
+require "rider_server/operation"
+require "rider_server/response"
+
+module RiderServer
+  SessionOperation.define do
+    name "inspect-exception"
+    documentation "Inspect an exception."
+
+    argument :id, :string, "The request id", required: true
+    argument :"exception-id", :string, "The exception id"
+
+    def handle(session, operation)
+      response = Response.new(operation)
+      exception_id = operation["exception-id"]
+
+      value = session.get_exception(exception_id)
+      response.set("inspect-location", value["id"])
+      response.set("exception-id", value["id"])
+      response.set("source-operation-id", value["operation_id"])
+      response.set("created-at", value["created_at"].to_s)
+
+      exception = value["exception"]
+      response.set("value", exception.inspect)
+      response.set("stacktrace", encode_stacktrace(exception, exception_id))
+
+      response.status("done")
+      response
+    end
+
+    def encode_stacktrace(exception, exception_id)
+      exception.backtrace.zip(exception.__rider_bindings_stack).map.with_index do |(line, frame), frame_id|
+        {
+          "line" => line,
+          "inspect-location" => ["rider_exception:#{exception_id}", "rider_stackframe:#{frame_id}"],
+          "frame" => (frame&.local_variables || []).map do |var|
+                       {
+                         "name" => var.to_s,
+                         "value" => Utils.rider_display(frame.local_variable_get(var)),
+                         "inspect-location" => ["rider_exception:#{exception_id}", "rider_stackframe_variable:#{frame_id}:#{var}"]
+                       }
+                     end
+        }
+      end
+    end
+  end
+end

data/lib/rider_server/session_operations/interrupt.rb

@@ -0,0 +1,29 @@
+require "rider_server/operation"
+require "rider_server/response"
+
+module RiderServer
+  SessionOperation.define do
+    name "interrupt"
+    documentation "Interrupts the evaluation of a session."
+
+    argument :id, :string, "The request id", required: true
+    argument :"interrupt-id", :string, "The ID of the evaluation to interrupt.", required: true
+
+    def handle(session, operation)
+      # TODO should do something if the session is nil
+
+      if operation["interrupt-id"].nil? || operation["interrupt-id"].empty?
+        if session.evaluations.empty?
+          raise ArgumentError, "No evaluations to interrupt"
+        end
+        session.interrupt_evaluation(session.evaluations.keys.max)
+      else
+        session.interrupt_evaluation(operation["interrupt-id"])
+      end
+
+      response = Response.new(operation)
+      response.status("interrupted", "done")
+      response
+    end
+  end
+end

data/lib/rider_server/session_operations/load_path.rb

@@ -0,0 +1,19 @@
+require "rider_server/operation"
+require "rider_server/response"
+
+module RiderServer
+  SessionOperation.define do
+    name "load-path"
+    documentation "Return the current load path."
+
+    argument :id, :string, "The request id", required: true
+
+    def handle(session, operation)
+      response = Response.new(operation)
+      load_path = session.workspace.evaluate("$LOAD_PATH", "main")
+      response.set("load-path", load_path)
+      response.status("done")
+      response
+    end
+  end
+end

data/lib/rider_server/session_operations/ls_exceptions.rb

@@ -0,0 +1,28 @@
+require "rider_server/session_operation"
+require "rider_server/response"
+
+module RiderServer
+  SessionOperation.define do
+    name "ls-exceptions"
+    documentation "List all exceptions that exist in the sessions cache."
+
+    argument :id, :string, "The request id", required: true
+
+    def handle(session, operation)
+      response = Response.new(operation)
+
+      exceptions = session.exceptions.map do |item|
+        {
+          "id" => item["id"],
+          "operation-id" => item["operation_id"],
+          "created-at" => item["created_at"].iso8601,
+          "exception" => item["exception"].inspect
+        }
+      end
+
+      response.set("exceptions", exceptions)
+      response.status("done")
+      response
+    end
+  end
+end

data/lib/rider_server/session_operations/ls_services.rb

@@ -0,0 +1,18 @@
+require "rider_server/operation"
+require "rider_server/response"
+
+module RiderServer
+  SessionOperation.define do
+    name "ls-services"
+    documentation "List all services."
+
+    argument :id, :string, "The request id", required: true
+
+    def handle(session, operation)
+      response = Response.new(operation)
+      response.set("services", session.list_services)
+      response.status("done")
+      response
+    end
+  end
+end