puppet-editor-services 2.0.4

data/lib/puppet_editor_services/protocol/json_rpc_messages.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require 'puppet_editor_services/protocol/json_rpc'
+
+module PuppetEditorServices
+  module Protocol
+    module JsonRPCMessages
+      # Protocol message primitives
+      class Message
+        attr_accessor :jsonrpc
+
+        def initialize(initial_hash = nil)
+          @jsonrpc = ::PuppetEditorServices::Protocol::JsonRPC::JSONRPC_VERSION
+          from_h!(initial_hash)
+        end
+
+        def from_h!(value)
+          return self if value.nil? || value.empty?
+
+          # jsonrpc is a little special.  Don't override it with nil. This
+          # allows `.new.from_h!(..)` to use the default without knowing exactly
+          # what version is used.
+          self.jsonrpc = value['jsonrpc'] unless value['jsonrpc'].nil?
+          self
+        end
+
+        def to_json(*options)
+          to_h.to_json(options)
+        end
+
+        def to_h
+          {
+            'jsonrpc' => jsonrpc
+          }
+        end
+      end
+
+      # interface RequestMessage extends Message {
+      #   /**
+      #    * The request id.
+      #    */
+      #   id: number | string;
+      #   /**
+      #    * The method to be invoked.
+      #    */
+      #   method: string;
+      #   /**
+      #    * The method's params.
+      #    */
+      #   params?: Array<any> | object;
+      # }
+      class RequestMessage < Message
+        attr_accessor :id, :rpc_method, :params
+
+        def initialize(initial_hash = nil)
+          super
+        end
+
+        def from_h!(value)
+          value = {} if value.nil?
+          super
+          self.id = value['id']
+          self.rpc_method = value['method']
+          self.params = value['params']
+          self
+        end
+
+        def to_h
+          super.merge(
+            'id' => id,
+            'method' => rpc_method,
+            'params' => params
+          )
+        end
+      end
+
+      # interface NotificationMessage extends Message {
+      #   /**
+      #     * The method to be invoked.
+      #     */
+      #   method: string;
+
+      #   /**
+      #     * The notification's params.
+      #     */
+      #   params?: Array<any> | object;
+      # }
+      class NotificationMessage < Message
+        attr_accessor :rpc_method, :params
+
+        def initialize(initial_hash = nil)
+          super
+        end
+
+        def from_h!(value)
+          value = {} if value.nil?
+          super
+          self.rpc_method = value['method']
+          self.params = value['params']
+          self
+        end
+
+        def to_h
+          hash = { 'method' => rpc_method }
+          hash['params'] = params unless params.nil?
+          super.merge(hash)
+        end
+      end
+
+      # interface ResponseMessage extends Message {
+      #   /**
+      #     * The request id.
+      #     */
+      #   id: number | string | null;
+
+      #   /**
+      #     * The result of a request. This member is REQUIRED on success.
+      #     * This member MUST NOT exist if there was an error invoking the method.
+      #     */
+      #   result?: string | number | boolean | object | null;
+
+      #   /**
+      #     * The error object in case a request fails.
+      #     */
+      #   error?: ResponseError<any>;
+      # }
+      class ResponseMessage < Message
+        attr_accessor :id, :result, :error
+        # is_successful is special. It changes based on deserialising from hash or
+        # can be manually set. This affects serialisation
+        attr_accessor :is_successful
+
+        def initialize(initial_hash = nil)
+          super
+        end
+
+        def from_h!(value)
+          value = {} if value.nil?
+          super
+          self.id = value['id']
+          self.result = value['result']
+          self.error = value['error']
+          self.is_successful = value.key?('result')
+          self
+        end
+
+        def to_h
+          hash = { 'id' => id }
+          # Ref - https://www.jsonrpc.org/specification#response_object
+          if is_successful
+            # Succesful responses must ALWAYS have the result key, even if it's null.
+            hash['result'] = result
+          else
+            # Error responses must ALWAYS have the error key
+            # TODO: The RPC spec says error MUST be an Error object, not nil.
+            hash['error'] = error
+          end
+          super.merge(hash)
+        end
+      end
+
+      # Static message generators
+      def self.reply_result(request, result)
+        ResponseMessage.new.from_h!('id' => request.id, 'result' => result)
+      end
+
+      def self.reply_error(request, code, message)
+        reply_error_by_id(request.id, code, message)
+      end
+
+      def self.reply_error_by_id(id, code, message)
+        # Note - Strictly speaking the error should be typed object, however as this hidden behind
+        # this method it's easier to just pass in a known hash construct
+        ResponseMessage.new.from_h!(
+          'id' => id,
+          'error' => {
+            'code' => code,
+            'message' => message
+          }
+        )
+      end
+
+      def self.reply_method_not_found(request, message = nil)
+        reply_error(
+          request,
+          ::PuppetEditorServices::Protocol::JsonRPC::CODE_METHOD_NOT_FOUND,
+          message || ::PuppetEditorServices::Protocol::JsonRPC::MSG_METHOD_NOT_FOUND
+        )
+      end
+
+      def self.new_notification(method_name, params)
+        NotificationMessage.new.from_h!('method' => method_name, 'params' => params)
+      end
+
+      def self.new_request(id, method_name, params)
+        RequestMessage.new.from_h!('id' => id, 'method' => method_name, 'params' => params)
+      end
+    end
+  end
+end

data/lib/puppet_editor_services/server/base.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'puppet_editor_services/server'
+require 'puppet_editor_services/connection/base'
+require 'puppet_editor_services/protocol/base'
+
+module PuppetEditorServices
+  module Server
+    class Base
+      attr_reader :server_options, :connection_options, :protocol_options, :handler_options
+
+      def name
+        'SRV'
+      end
+
+      def initialize(server_options, connection_options, protocol_options, handler_options)
+        @server_options = server_options.nil? ? {} : server_options.dup
+        @connection_options = connection_options.nil? ? {} : connection_options.dup
+        @protocol_options = protocol_options.nil? ? {} : protocol_options.dup
+        @handler_options = handler_options.nil? ? {} : handler_options.dup
+
+        @connection_options[:class] = PuppetEditorServices::Connection::Base if @connection_options[:class].nil?
+        @protocol_options[:class] = PuppetEditorServices::Protocol::Base if @protocol_options[:class].nil?
+        @handler_options[:class] = PuppetEditorServices::Handler::Base if @handler_options[:class].nil?
+
+        @server_options[:servicename] = 'LANGUAGE SERVER' if @server_options[:servicename].nil?
+
+        # Assumes there's only ONE active simpler server running at a time.
+        PuppetEditorServices::Server.current_server = self
+      end
+
+      # Returns a client connection for a given connection_id
+      def connection(connection_id); end
+
+      def start; end
+
+      def log(message)
+        PuppetEditorServices.log_message(:debug, "#{name}: #{message}")
+      end
+    end
+  end
+end

data/lib/puppet_editor_services/server/stdio.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'puppet_editor_services/logging'
+require 'puppet_editor_services/server/base'
+require 'puppet_editor_services/connection/stdio'
+require 'puppet_editor_services/protocol/base'
+
+module PuppetEditorServices
+  module Server
+    class Stdio < ::PuppetEditorServices::Server::Base
+      attr_accessor :exiting
+
+      def name
+        'STDIOSRV'
+      end
+
+      def initialize(server_options, protocol_options, handler_options)
+        super(server_options, {}, protocol_options, handler_options)
+        @exiting = false
+      end
+
+      def start
+        # This is a little heavy handed but we need to suppress writes to STDOUT and STDERR
+        $VERBOSE = nil
+        # Some libraries use $stdout to write to the console. Suppress all of that too!
+        # Copy the existing $stdout variable and then reassign to NUL to suppress it
+        $editor_services_stdout = $stdout # rubocop:disable Style/GlobalVars  We need this global var
+        $stdout = File.open(File::NULL, 'w')
+
+        $editor_services_stdout.sync = true # rubocop:disable Style/GlobalVars  We need this global var
+        # Stop the stupid CRLF injection when on Windows
+        $editor_services_stdout.binmode unless $editor_services_stdout.binmode # rubocop:disable Style/GlobalVars  We need this global var
+
+        @client_connection = PuppetEditorServices::Connection::Stdio.new(self)
+
+        log('Starting STDIO server...')
+        loop do
+          inbound_data = nil
+          read_from_pipe($stdin, 2) { |data| inbound_data = data }
+          break if @exiting
+
+          @client_connection.receive_data(inbound_data) unless inbound_data.nil?
+          break if @exiting
+        end
+        log('STDIO server stopped')
+      end
+
+      def stop
+        log('Stopping STDIO server...')
+        @exiting = true
+      end
+
+      def connection(connection_id)
+        @client_connection unless @client_connection.nil? || @client_connection.id != connection_id
+      end
+
+      def close_connection
+        stop
+      end
+
+      def pipe_is_readable?(stream, timeout = 0.5)
+        read_ready = IO.select([stream], [], [], timeout)
+        read_ready && stream == read_ready[0][0]
+      end
+
+      def read_from_pipe(pipe, timeout = 0.1, &_block)
+        if pipe_is_readable?(pipe, timeout)
+          l = nil
+          begin
+            l = pipe.readpartial(4096)
+          rescue EOFError
+            log('Reading from pipe has reached End of File.  Exiting STDIO server')
+            stop
+          rescue # rubocop:disable Style/RescueStandardError
+            # Any errors here should be swallowed because the pipe could be in any state
+          end
+          # since readpartial may return a nil at EOF, skip returning that value
+          # client_connected = true unless l.nil?
+          yield l unless l.nil?
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/puppet_editor_services/server/tcp.rb

@@ -0,0 +1,349 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'openssl'
+
+# frozen_string_literal: true
+
+require 'puppet_editor_services/logging'
+require 'puppet_editor_services/server/base'
+require 'puppet_editor_services/connection/tcp'
+require 'puppet_editor_services/protocol/base'
+
+# Based on code from
+# http://stackoverflow.com/questions/29858113/unable-to-make-socket-accept-non-blocking-ruby-2-2
+
+module PuppetEditorServices
+  module Server
+    class Tcp < ::PuppetEditorServices::Server::Base
+      class << self
+        attr_reader :io_locker, :events, :e_locker, :services, :s_locker, :io_connection_dic, :c_locker
+      end
+
+      @io_locker = Mutex.new
+      @events = []
+      @e_locker = Mutex.new
+      @services = {}
+      @s_locker = Mutex.new
+      @io_connection_dic = {}
+      @c_locker = Mutex.new
+
+      def initialize(server_options, protocol_options, handler_options)
+        super(server_options, {}, protocol_options, handler_options)
+
+        add_service(server_options[:ipaddress], server_options[:port])
+      end
+
+      def name
+        'TCPSRV'
+      end
+
+      ####
+      # this code will be called when a socket recieves data.
+      # @api private
+      def get_data(io, connection_data)
+        data = io.recv_nonblock(1_048_576) # with maximum number of bytes to read at a time...
+        raise 'Received a 0byte payload' if data.length.zero?
+
+        # We're already in a callback so no need to invoke as a callback
+        connection_data[:handler].receive_data(data)
+      rescue StandardError => e
+        log("Closing socket due to error - #{e}\n#{e.backtrace}")
+        remove_connection(io)
+      end
+
+      #########
+      # main loop and activation code
+      #
+      # This will create a thread pool and set them running.
+      # @api public
+      def start
+        # prepare threads
+        max_threads = server_options[:max_threads] || 2
+        exit_flag = false
+        threads = []
+        thread_cycle = proc do
+          begin
+            io_review
+          rescue # rubocop:disable Style/RescueStandardError
+            # Swallow all errors
+            false
+          end
+          true while fire_event
+        end
+        max_threads.times { Thread.new { thread_cycle.call until exit_flag } }
+
+        log('Services running. Press ^C to stop')
+
+        # sleep until trap raises exception (cycling might cause the main thread to loose signals that might be caught inside rescue clauses)
+        kill_timer = server_options[:connection_timeout]
+        kill_timer = -1 if kill_timer.nil? || kill_timer < 1
+        log("Will stop the server in #{server_options[:connection_timeout]} seconds if no connection is made.") if kill_timer > 0
+        log('Will stop the server when client disconnects') if !server_options[:stop_on_client_exit].nil? && server_options[:stop_on_client_exit]
+
+        # Output to STDOUT.  This is required by clients so it knows the server is now running
+        self.class.s_locker.synchronize do
+          self.class.services.each_value do |service|
+            $stdout.write("#{server_options[:servicename]} RUNNING #{service[:hostname]}:#{service[:port]}\n")
+          end
+        end
+        $stdout.flush
+
+        loop do
+          begin
+            sleep(1)
+            # The kill_timer is used to stop the server if no clients have connected in X seconds
+            # a value of 0 or less will not timeout.
+            if kill_timer > 0
+              kill_timer -= 1
+              if kill_timer.zero?
+                connection_count = 0
+                self.class.c_locker.synchronize { connection_count = self.class.io_connection_dic.count }
+                if connection_count.zero?
+                  log("No connection has been received in #{server_options[:connection_timeout]} seconds.  Shutting down server.")
+                  stop_services
+                end
+              end
+            end
+          rescue # rubocop:disable Style/RescueStandardError
+            # Swallow all errors
+            true
+          end
+          break if self.class.services.empty?
+        end
+
+        # start shutdown.
+        exit_flag = true
+        log('Started shutdown process. Press ^C to force quit.')
+        # shut down listening sockets
+        stop_services
+        # disconnect active connections
+        stop_connections
+        # cycle down threads
+        log('Waiting for workers to cycle down')
+        threads.each { |t| t.join if t.alive? }
+
+        # rundown any active events
+        thread_cycle.call
+      end
+
+      #######################
+      ## Events (Callbacks) / Multi-tasking Platform
+      # returns true if there are any unhandled events
+      # @api private
+      def events?
+        self.class.e_locker.synchronize { !self.class.events.empty? }
+      end
+
+      # pushes an event to the event's stack
+      # if a block is passed along, it will be used as a callback: the block will be called with the values returned by the handler's `call` method.
+      # @api private
+      def push_event(handler, *args, &block)
+        if block
+          self.class.e_locker.synchronize { self.class.events << [proc { |a| push_event block, handler.call(*a) }, args] }
+        else
+          self.class.e_locker.synchronize { self.class.events << [handler, args] }
+        end
+      end
+
+      # Runs the block asynchronously by pushing it as an event to the event's stack
+      #
+      # @api private
+      def run_async(*args, &block)
+        self.class.e_locker.synchronize { self.class.events << [block, args] } if block
+        !block.nil?
+      end
+
+      # creates an asynchronous call to a method, with an optional callback (shortcut)
+      # @api private
+      def callback(object, method, *args, &block)
+        push_event object.method(method), *args, &block
+      end
+
+      # event handling FIFO
+      # @api private
+      def fire_event
+        event = self.class.e_locker.synchronize { self.class.events.shift }
+        return false unless event
+
+        begin
+          event[0].call(*event[1])
+        rescue OpenSSL::SSL::SSLError
+          log('SSL Bump - SSL Certificate refused?')
+        # rubocop:disable Lint/RescueException
+        rescue Exception => e
+          raise if e.is_a?(SignalException) || e.is_a?(SystemExit)
+        end
+        # rubocop:enable Lint/RescueException
+
+        true
+      end
+
+      #####
+      # Reactor
+      #
+      # IO review code will review the connections and sockets
+      # it will accept new connections and react to socket input
+      # @api private
+      def io_review
+        self.class.io_locker.synchronize do
+          return false unless self.class.events.empty?
+
+          united = self.class.services.keys + self.class.io_connection_dic.keys
+          return false if united.empty?
+
+          io_r = IO.select(united, nil, united, 0.1)
+          if io_r
+            io_r[0].each do |io|
+              if self.class.services[io]
+                begin
+                  callback(self, :add_connection, io.accept_nonblock, self.class.services[io])
+                rescue Errno::EWOULDBLOCK
+                  # There's nothing to handle. Swallow the error
+                rescue StandardError => e
+                  log(e.message)
+                end
+              elsif self.class.io_connection_dic[io]
+                callback(self, :get_data, io, self.class.io_connection_dic[io])
+              else
+                log('what?!')
+                remove_connection(io)
+                self.class.services.delete(io)
+              end
+            end
+            io_r[2].each do |io|
+              (remove_connection(io) || self.class.services.delete(io)).close
+            rescue # rubocop:disable Style/RescueStandardError
+              # Swallow all errors
+              true
+            end
+          end
+        end
+        callback self, :clear_connections
+        true
+      end
+
+      #######################
+      # IO - listening sockets (services)
+
+      # @api private
+      def add_service(hostname = 'localhost', port = nil, parameters = {})
+        hostname = 'localhost' if hostname.nil? || hostname.empty?
+        service = TCPServer.new(hostname, port)
+        parameters[:hostname] = hostname
+        parameters[:port] = service.local_address.ip_port
+        self.class.s_locker.synchronize { self.class.services[service] = parameters }
+        callback(self, :log, "Started listening on #{hostname}:#{parameters[:port]}.")
+        true
+      end
+
+      # @api public
+      def stop_services(from_trap = false)
+        log('Stopping services')
+        if from_trap
+          # synchronize is not allowed when called from a trap statement
+          stop_all_services
+        else
+          self.class.s_locker.synchronize do
+            stop_all_services
+          end
+        end
+      end
+
+      # @api private
+      def stop_all_services
+        self.class.services.each do |s, p|
+          begin
+            s.close
+          rescue # rubocop:disable Style/RescueStandardError
+            # Swallow all errors
+            true
+          end
+          log("Stopped listening on #{p[:hostname]}:#{p[:port]}")
+        end
+        self.class.services.clear
+      end
+
+      # @api public
+      def remove_connection_async(io)
+        callback(self, :remove_connection, io)
+      end
+
+      #####################
+      # IO - Active connections handling
+
+      # @api private
+      def stop_connections
+        self.class.c_locker.synchronize do
+          self.class.io_connection_dic.each_key do |io|
+            io.close
+          rescue # rubocop:disable Style/RescueStandardError
+            # Swallow all errors
+            true
+          end
+          self.class.io_connection_dic.clear
+        end
+      end
+
+      # @api private
+      def add_connection(io, service_object)
+        conn = ::PuppetEditorServices::Connection::Tcp.new(self, io)
+        if io
+          self.class.c_locker.synchronize do
+            self.class.io_connection_dic[io] = { handler: conn, service: service_object }
+          end
+        end
+        callback(conn, :post_init)
+      rescue Exception => e # rubocop:disable Lint/RescueException  Need to swallow all errors here
+        callback(self, :log, "Error creating connection #{e.inspect}\n#{e.backtrace}")
+      end
+
+      # @api public
+      def connection(connection_id)
+        self.class.c_locker.synchronize do
+          self.class.io_connection_dic.each_value do |v|
+            return v[:handler] unless v[:handler].nil? || v[:handler].id != connection_id
+          end
+        end
+        nil
+      end
+
+      # @api private
+      def remove_connection(io)
+        # This needs to be synchronous
+        begin
+          self.class.io_connection_dic[io][:handler].unbind
+        rescue e
+          # Any errors when unbinding the handler should NOT stop the underlying socket
+          # from being closed
+          log("Error unbinding #{e.inspect}\n#{e.backtrace}")
+        end
+        connection_count = 0
+        self.class.c_locker.synchronize do
+          self.class.io_connection_dic.delete io
+          connection_count = self.class.io_connection_dic.count
+          begin
+            io.close
+          rescue # rubocop:disable Style/RescueStandardError
+            # Swallow all errors
+            true
+          end
+        end
+
+        return unless connection_count.zero? && !@server_options[:stop_on_client_exit].nil? && @server_options[:stop_on_client_exit]
+
+        callback(self, :log, 'All clients have disconnected.  Shutting down server.')
+        callback(self, :stop_services)
+      end
+
+      # clears closed connections from the stack
+      # @api private
+      def clear_connections
+        # Using a SymbolProc here does not work
+        # rubocop:disable Style/SymbolProc
+        self.class.c_locker.synchronize { self.class.io_connection_dic.delete_if { |c| c.closed? } }
+        # rubocop:enable Style/SymbolProc
+      end
+    end
+  end
+end

data/lib/puppet_editor_services/server.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'puppet_editor_services/server/base'
+
+module PuppetEditorServices
+  module Server
+    def self.current_server
+      @@current_server # This is fine
+    end
+
+    def self.current_server=(value)
+      @@current_server = value # rubocop:disable Style/ClassVars  This is fine
+    end
+  end
+end