rider-server 0.1.0

data/lib/rider_server/services/capture_io.rb

@@ -0,0 +1,302 @@
+# frozen_string_literal: true
+
+#
+# capture_io.rb -- Handle IO
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+require "rider_server/service"
+
+module RiderServer
+  module Services
+    class CaptureIO < Service
+      attr_reader :stdin, :stdout, :stderr
+
+      @sessions = []
+      @stdin_stream, @stdin = ::IO.pipe
+
+      def self.stdin
+        @stdin
+      end
+
+      def self.sessions
+        @sessions
+      end
+
+      def self.nwrite(stream_name, *string)
+        str = string.join
+        send_response(stream_name, str)
+      end
+
+      def self.create_response(id, stream_name, str)
+        {
+          "id" => id,
+          stream_name => str,
+          "time-stamp" => Time.now.strftime("%Y-%m-%d %H:%M:%S")
+        }
+      end
+
+      def self.send_response(io_stream, string)
+        @sessions.each do |session, stream_id|
+          response = create_response(stream_id, io_stream, string)
+          session.response_queue.push(response)
+        end
+      end
+
+      def initialize(session)
+        @session = session
+        @stdout = ::STDOUT # rubocop:disable Style/GlobalStdStream
+        @stderr = ::STDERR # rubocop:disable Style/GlobalStdStream
+        super
+      end
+
+      def start(stream_id)
+        unless @stdin == ::STDIN && @stdout == ::STDOUT && @stderr == ::STDERR # rubocop:disable Style/GlobalStdStream
+          $stdin = self.class.stdin
+          $stdout = @stdout = Services::IO.new(::STDOUT, "out") # rubocop:disable Style/GlobalStdStream
+          $stderr = @stderr = Services::IO.new(::STDERR, "err") # rubocop:disable Style/GlobalStdStream
+        end
+        self.class.sessions << [@session, stream_id]
+        :running
+      end
+
+      def stop
+        self.class.sessions.delete_if { |s| s[0] == @session }
+
+        if self.class.sessions.empty?
+          $stdin = @stdin = ::STDIN # rubocop:disable Style/GlobalStdStream
+          $stdout = @stdout = ::STDOUT # rubocop:disable Style/GlobalStdStream
+          $stderr = @stderr = ::STDERR # rubocop:disable Style/GlobalStdStream
+        end
+        :stopped
+      end
+
+      def status
+        if self.class.sessions.find { |s| s[0] == @session }
+          :running
+        else
+          :stopped
+        end
+      end
+    end
+
+    class IO
+      def initialize(io, stream_name)
+        @stream_name = stream_name
+        @io = io
+      end
+
+      def write(*string)
+        strings = string.map(&:to_s)
+        Services::CaptureIO.nwrite(@stream_name, *strings)
+        @io.write(*strings)
+      end
+
+      def write_nonblock(string, **kwargs)
+        Services::CaptureIO.nwrite(@stream_name, string.to_s)
+        @io.write_nonblock(strings, **kwargs)
+      end
+
+      def syswrite(string)
+        Services::CaptureIO.nwrite(@stream_name, string.to_s)
+        @io.syswrite(string)
+      end
+
+      def <<(obj)
+        write(obj.to_s)
+        self
+      end
+
+      def print(*args)
+        if args.length == 0
+          write($_)
+        else
+          args.each_with_index do |arg, index|
+            write(arg.to_s)
+            if $, && index < args.length - 1
+              write($,)
+            end
+          end
+          nil
+        end
+      end
+
+      def printf(format_string, *args)
+        write(sprintf(format_string, *args))
+        nil
+      end
+
+      def putc(obj)
+        if obj.is_a?(String)
+          write(obj[0])
+        else
+          # The real version triggers a "TypeError: no implicit
+          # conversion of IO into Integer", when called on objects that
+          # are not numbers or strings and can't be coerced to a number.
+          write(obj.to_int.chr)
+        end
+        obj
+      end
+
+      def puts(*args)
+        args.each do |arg|
+          if arg.is_a?(Array)
+            arg.each do |a|
+              write(a.to_s, "\n")
+            end
+          else
+            write(arg.to_s, "\n")
+          end
+        end
+
+        write("\n") if args.length == 0
+        nil
+      end
+
+      def to_io
+        self
+      end
+
+      def pwrite(string, offset)
+        raise NotImplementedError
+      end
+
+      %i[
+        advise
+        all?
+        any?
+        autoclose?
+        bdecode
+        binmode
+        binmode?
+        chain
+        chunk
+        chunk_while
+        close
+        close_on_exec=
+        close_on_exec?
+        close_read
+        close_write
+        closed?
+        collect
+        collect_concat
+        compact
+        count
+        cycle
+        detect
+        drop
+        drop_while
+        each
+        each_byte
+        each_char
+        each_codepoint
+        each_cons
+        each_entry
+        each_line
+        each_slice
+        each_with_index
+        each_with_object
+        entries
+        eof
+        eof?
+        external_encoding
+        fcntl
+        fdatasync
+        fileno
+        filter
+        filter_map
+        find
+        find_all
+        find_index
+        first
+        flat_map
+        flush
+        fsync
+        getbyte
+        getc
+        gets
+        grep
+        grep_v
+        group_by
+        include?
+        inject
+        internal_encoding
+        ioctl
+        isatty
+        lazy
+        lineno
+        lineno=
+        map
+        max
+        max_by
+        member?
+        min
+        min_by
+        minmax
+        minmax_by
+        nonblock
+        nonblock=
+        nonblock?
+        none?
+        nread
+        one?
+        partition
+        pid
+        pos
+        pos=
+        pread
+        read
+        read_nonblock
+        readbyte
+        readchar
+        readline
+        readlines
+        readpartial
+        ready?
+        reduce
+        reject
+        reopen
+        reverse_each
+        rewind
+        seek
+        select
+        set_encoding
+        set_encoding_by_bom
+        slice_after
+        slice_before
+        slice_when
+        sort
+        sort_by
+        stat
+        sum
+        sync
+        sync=
+        sysread
+        sysseek
+        take
+        take_while
+        tally
+        tell
+        to_a
+        to_h
+        to_i
+        tty?
+        ungetbyte
+        ungetc
+        uniq
+        wait
+        wait_priority
+        wait_readable
+        wait_writable
+        zip
+        autoclose=
+      ].each do |method|
+        define_method(method) do |*args, **kwargs, &block|
+          @io.send(method, *args, **kwargs, &block)
+        end
+      end
+    end
+  end
+end

data/lib/rider_server/services/rails.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+#
+# rails.rb -- Rails service for Rider
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+require "rider_server/service"
+
+module RiderServer
+  module Services
+    class Rails < Service
+      def initialize(session)
+        @session = session
+        super
+      end
+
+      def start(stream_id)
+        @stream_id = stream_id
+
+        # Suck it ruby, i can define constants at runtime
+        eval('::APP_PATH = File.expand_path("./config/application", Dir.pwd)', TOPLEVEL_BINDING, __FILE__, __LINE__)
+        nputs "Starting Rails Server..."
+
+        @thread = Thread.new do
+          require File.expand_path("./config/boot", Dir.pwd)
+          require "rails/command"
+          require "rails/commands/server/server_command"
+
+          set_application_directory!
+
+          ::Rails::Server.new(server_options).tap do |server|
+            require APP_PATH
+
+            Dir.chdir(::Rails.application.root)
+
+            unless Rails.application.config.middleware.include?(Services::RailsExceptionMiddleware)
+              ::Rails.application.config.middleware.insert_after(
+                ActionDispatch::DebugExceptions, Services::RailsExceptionMiddleware, @stream_id, @session
+              )
+            end
+
+            if server.serveable?
+              nputs_boot_information(server.server, server.served_url)
+              after_stop_callback = -> { nputs "Rails Server Exiting..." }
+              server.start(after_stop_callback)
+            else
+              nputs rack_server_suggestion(options[:using])
+            end
+          end
+        rescue => e
+          @session.push_exception(stream_id, e)
+          nputs "Error starting Rails Server: #{e.message}"
+        end
+      end
+
+      def stop
+        @thread.raise(Interrupt)
+      end
+
+      def status
+        if @thread&.alive?
+          :running
+        else
+          :stopped
+        end
+      end
+
+      private
+
+      def set_application_directory!
+        Dir.chdir(File.expand_path("../..", APP_PATH)) unless File.exist?(File.expand_path("config.ru"))
+      end
+
+      def server_options
+        {
+          server: nil,
+          log_stdout: true,
+          Port: nil,
+          Host: nil,
+          DoNotReverseLookup: true,
+          config: "config.ru",
+          environment: "development",
+          daemonize: false,
+          pid: nil,
+          caching: nil,
+          restart_cmd: nil,
+          early_hints: nil
+        }
+      end
+
+      def nputs_boot_information(server, url)
+        nputs <<~MSG
+          => Booting #{ActiveSupport::Inflector.demodulize(server)}
+          => Rails #{::Rails.version} application starting in #{::Rails.env} #{url}
+        MSG
+      end
+
+      def nputs(string)
+        response = create_response
+        response["out"] = string + "\n"
+        @session.response_queue.push(response)
+        nil
+      end
+
+      def create_response
+        {
+          "id" => @stream_id,
+          "time-stamp" => Time.now.strftime("%Y-%m-%d %H:%M:%S")
+        }
+      end
+    end
+
+    class RailsExceptionMiddleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      rescue => e
+        Services::CaptureExceptions.handle_exception(e, env)
+        raise
+      end
+    end
+  end
+end

data/lib/rider_server/session.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+#
+# session.rb -- Represents a session in the Rider REPL
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+require "date"
+require "securerandom"
+require "rider_server/workspace"
+require "rider_server/errors"
+require "rider_server/services/rails"
+require "rider_server/services/capture_io"
+require "rider_server/services/capture_exceptions"
+require "rider_server/logger"
+
+module RiderServer
+  class Session
+    include RiderServer::Logger
+
+    attr_reader :id
+    attr_reader :workspace
+    attr_reader :exceptions
+    attr_reader :evaluations
+    attr_reader :response_queue
+    attr_reader :history
+
+    SERVICES = [
+      Services::Rails,
+      Services::CaptureIO,
+      Services::CaptureExceptions
+    ]
+
+    def initialize(response_queue, history: [])
+      @id = SecureRandom.uuid
+      @history = history
+      @workspace = Workspace.new
+      @queue = Thread::Queue.new
+      @exceptions = Utils::FixedArray.new
+      @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
+
+      # XXX Side effects in initializer, :()
+      start_exception_processing
+    end
+
+    def send_response(response)
+      if response
+        @response_queue.push(response)
+      end
+    end
+
+    def clone
+      Session.new(@responses_queue, history: @history.clone)
+    end
+
+    #
+    # Input History
+    #
+
+    def push_history(event)
+      @history.push(event)
+    end
+
+    def last_history
+      @history.last
+    end
+
+    #
+    # Historical Results
+    #
+
+    def result_history
+      @result_history ||= {}
+    end
+
+    def add_result(evaluation_id, value)
+      result_history[evaluation_id] = value
+    end
+
+    def get_result(evaluation_id)
+      raise "Missing history item #{evaluation_id}." unless result_history.key?(evaluation_id)
+      result_history[evaluation_id]
+    end
+
+    #
+    # Historical Exceptions
+    #
+
+    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
+    end
+
+    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
+
+    def start_exception_processing
+      return if @exception_processing_thread
+
+      @exception_processing_thread = Thread.new do
+        loop do
+          add_exception(*@exception_queue.pop)
+        end
+      end
+    end
+
+    def stop_exception_processing
+      @exception_processing_thread.exit
+      @exception_processing_thread = nil
+    end
+
+    #
+    # Historical Evaluations
+    #
+
+    def add_evaluation(evaluation_id, eval_thread)
+      @evaluations[evaluation_id] = eval_thread
+    end
+
+    def remove_evaluation(evaluation_id)
+      @evaluations.delete(evaluation_id)
+    end
+
+    def running_evaluation?(evaluation_id)
+      @evaluations[evaluation_id]
+    end
+
+    def interrupt_evaluation(evaluation_id)
+      log.info "Interrupting eval thread #{evaluation_id}"
+      # Signal the eval thread to raise an exception
+      @evaluations[evaluation_id].raise EvalInterrupt.new
+    end
+
+    #
+    # Service control
+    #
+    def list_services
+      SERVICES.map do |klass|
+        {
+          "name" => klass.service_name,
+          "state" => service_state(klass.service_name).to_s
+        }
+      end
+    end
+
+    def start_service(service_type, stream_id)
+      raise "Service #{service_type} is already running." \
+        if @services[service_type].status == :running
+
+      @services[service_type].start(stream_id)
+    end
+
+    def stop_service(service_type)
+      raise "Service #{service_type} is not running." \
+        if @services[service_type].status == :stopped
+
+      @services[service_type].stop
+    end
+
+    def service_state(service_type)
+      if @services.key?(service_type)
+        @services[service_type].status
+      else
+        :stopped
+      end
+    end
+  end
+end

data/lib/rider_server/utils.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+#
+# utils.rb -- Miscellaneous Utilities
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+require "socket"
+require "io/nonblock"
+
+module RiderServer
+  module Utils
+    ##
+    # Creates TCP server sockets bound to +address+:+port+ and returns them.
+    #
+    # It will create IPV4 and IPV6 sockets on all interfaces.
+    def create_listeners(address, port)
+      unless port
+        raise ArgumentError, "must specify port"
+      end
+      sockets = Socket.tcp_server_sockets(address, port)
+      sockets.map { |s|
+        s.autoclose = false
+        ts = TCPServer.for_fd(s.fileno)
+        s.close
+        ts
+      }
+    end
+    module_function :create_listeners
+
+    def rider_inspect(obj)
+      if obj.respond_to?(:rider_inspect)
+        obj.rider_inspect
+      else
+        obj.inspect
+      end
+    end
+    module_function :rider_inspect
+
+    class FixedArray < Array
+      def initialize(*args)
+        @max_size = args[0] || 10
+        super
+      end
+
+      def <<(element)
+        super
+        shift while size > @max_size
+      end
+
+      alias_method :push, :<<
+    end
+  end
+
+  def create_response(operation)
+    {
+      "id" => operation["id"],
+      "time-stamp" => Time.now.strftime("%Y-%m-%d %H:%M:%S")
+    }
+  end
+end

data/lib/rider_server/version.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+#
+# version.rb -- Rider version information
+#
+# Author: Russell Sim
+# Copyright (c) 2024 Russell Sim
+# SPDX-License-Identifier: MIT
+
+module RiderServer
+  VERSION = "0.1.0"
+end