puppet-editor-services 2.0.4

data/lib/puppet-languageserver/client_session_state.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'puppet-languageserver/session_state/document_store'
+require 'puppet-languageserver/session_state/language_client'
+require 'puppet-languageserver/session_state/object_cache'
+
+module PuppetLanguageServer
+  class ClientSessionState
+    attr_reader :documents, :language_client, :object_cache, :connection_id
+
+    def initialize(message_handler, options = {})
+      @documents       = options[:documents].nil? ? PuppetLanguageServer::SessionState::DocumentStore.new : options[:documents]
+      @language_client = options[:language_client].nil? ? PuppetLanguageServer::SessionState::LanguageClient.new(message_handler) : options[:language_client]
+      @object_cache    = options[:object_cache].nil? ? PuppetLanguageServer::SessionState::ObjectCache.new : options[:object_cache]
+      @connection_id   = options[:connection_id].nil? ? message_handler.protocol.connection.id : options[:connection_id]
+    end
+
+    # Helper methods to know the state of the object cache
+    def default_classes_loaded?
+      object_cache.section_in_origin_exist?(:class, :default)
+    end
+
+    def default_datatypes_loaded?
+      object_cache.section_in_origin_exist?(:datatype, :default)
+    end
+
+    def default_functions_loaded?
+      object_cache.section_in_origin_exist?(:function, :default)
+    end
+
+    def default_types_loaded?
+      object_cache.section_in_origin_exist?(:type, :default)
+    end
+
+    def facts_loaded?
+      object_cache.section_in_origin_exist?(:fact, :default)
+    end
+
+    def static_data_loaded?
+      object_cache.origin_exist?(:bolt)
+    end
+
+    # Loaders for object cache information
+    def load_default_data!(async = true)
+      PuppetLanguageServer.log_message(:info, "Loading Default Data via aggregate #{'(Async)' if async}...")
+      if async
+        sidecar_queue.enqueue('default_aggregate', [], false, connection_id)
+        sidecar_queue.enqueue('facts', [], false, connection_id)
+      else
+        sidecar_queue.execute('default_aggregate', [], false, connection_id)
+        sidecar_queue.execute('facts', [], false, connection_id)
+      end
+
+      true
+    end
+
+    def load_static_data!(async = true)
+      if async
+        Thread.new do
+          PuppetLanguageServer.log_message(:info, 'Loading static data (Async)...')
+          load_static_data_impl
+        end
+      else
+        PuppetLanguageServer.log_message(:info, 'Loading static data...')
+        load_static_data_impl
+      end
+
+      true
+    end
+
+    def load_workspace_data!(async = true)
+      return true if documents.store_root_path.nil?
+
+      action_args = ['--local-workspace', documents.store_root_path]
+      PuppetLanguageServer.log_message(:info, "Loading Workspace Data via aggregate #{'(Async)' if async}...")
+      if async
+        sidecar_queue.enqueue('workspace_aggregate', action_args, false, connection_id)
+      else
+        sidecar_queue.execute('workspace_aggregate', action_args, false, connection_id)
+      end
+
+      true
+    end
+
+    def purge_workspace_data!
+      object_cache.remove_origin!(:workspace)
+    end
+
+    private
+
+    def sidecar_queue
+      PuppetLanguageServer::GlobalQueues.sidecar_queue
+    end
+
+    def load_static_data_impl
+      bolt_static_data = PuppetLanguageServer::Sidecar::Protocol::AggregateMetadata.new
+      Dir.glob(File.join(PuppetLanguageServer.static_data_dir, 'bolt-*.json')) do |path|
+        PuppetLanguageServer.log_message(:debug, "Importing static data file #{path}...")
+        # No need to catch errors here. As this is static data and is tested in rspec
+        # Sure, we could have corrupt/missing files on disk, but then we have bigger issues
+        data = PuppetLanguageServer::Sidecar::Protocol::AggregateMetadata.new.from_json!(File.open(path, 'rb:UTF-8') { |f| f.read })
+        data.each_list { |_, list| bolt_static_data.concat!(list) }
+      end
+
+      object_cache.import_sidecar_list!(bolt_static_data.classes,   :class,    :bolt)
+      object_cache.import_sidecar_list!(bolt_static_data.datatypes, :datatype, :bolt)
+      object_cache.import_sidecar_list!(bolt_static_data.functions, :function, :bolt)
+      object_cache.import_sidecar_list!(bolt_static_data.types,     :type,     :bolt)
+
+      bolt_static_data.each_list do |k, v|
+        if v.nil?
+          PuppetLanguageServer.log_message(:debug, "Static bolt data returned no #{k}")
+        else
+          PuppetLanguageServer.log_message(:debug, "Static bolt data returned #{v.count} #{k}")
+        end
+      end
+    end
+  end
+end

data/lib/puppet-languageserver/crash_dump.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module PuppetLanguageServer
+  module CrashDump
+    def self.default_crash_file
+      File.join(Dir.tmpdir, 'puppet_language_server_crash.txt')
+    end
+
+    def self.write_crash_file(err, session_state, filename = nil, additional = {})
+      # Create the crash text
+
+      puppet_version         = Puppet.version rescue 'Unknown' # rubocop:disable Style/RescueModifier
+      facter_version         = Facter.version rescue 'Unknown' # rubocop:disable Style/RescueModifier
+      languageserver_version = PuppetLanguageServer.version rescue 'Unknown' # rubocop:disable Style/RescueModifier
+
+      crashtext = <<~TEXT
+        Puppet Language Server Crash File
+        -=--=--=--=--=--=--=--=--=--=--=-
+        #{DateTime.now.strftime('%a %b %e %Y %H:%M:%S %Z')}
+        Puppet Version #{puppet_version}
+        Facter Version #{facter_version}
+        Ruby Version #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}
+        Language Server Version #{languageserver_version}
+
+        Error: #{err}
+
+        Backtrace
+        ---------
+        #{err.backtrace.join("\n")}
+
+      TEXT
+      # Append the documents in the cache
+      session_state.documents.document_uris.each do |uri|
+        crashtext += "Document - #{uri}\n---\n#{session_state.documents.document_content(uri)}\n\n"
+      end
+      # Append additional objects from the crash
+      additional.each do |k, v|
+        crashtext += "#{k}\n---\n#{v}\n\n"
+      end
+
+      crash_file = filename.nil? ? default_crash_file : filename
+      File.binwrite(crash_file, crashtext)
+    rescue # rubocop:disable Style/RescueStandardError
+      # Swallow all errors.  Errors in the error handler should not
+      # terminate the application
+    end
+
+    nil
+  end
+end

data/lib/puppet-languageserver/epp/validation_provider.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module PuppetLanguageServer
+  module Epp
+    module ValidationProvider
+      def self.validate(content, _max_problems = 100)
+        result = []
+        # TODO: Need to implement max_problems
+        _problems = 0
+
+        begin
+          parser = Puppet::Pops::Parser::EvaluatingParser::EvaluatingEppParser.new
+          parser.parse_string(content, nil)
+        rescue StandardError => e
+          # Sometimes the error is in the cause not the root object itself
+          e = e.cause if !e.respond_to?(:line) && e.respond_to?(:cause)
+          ex_line = e.respond_to?(:line) && !e.line.nil? ? e.line - 1 : nil # Line numbers from puppet exceptions are base 1
+          ex_pos = e.respond_to?(:pos) && !e.pos.nil? ? e.pos : nil # Pos numbers from puppet are base 1
+
+          message = e.respond_to?(:message) ? e.message : nil
+          message = e.basic_message if message.nil? && e.respond_to?(:basic_message)
+
+          unless ex_line.nil? || ex_pos.nil? || message.nil?
+            result << LSP::Diagnostic.new('severity' => LSP::DiagnosticSeverity::ERROR,
+                                          'range' => LSP.create_range(ex_line, ex_pos, ex_line, ex_pos + 1),
+                                          'source' => 'Puppet',
+                                          'message' => message)
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/puppet-languageserver/facter_helper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module PuppetLanguageServer
+  module FacterHelper
+    # Facts
+    def self.fact(session_state, name)
+      session_state.object_cache.object_by_name(:fact, name)
+    end
+
+    def self.fact_value(session_state, name)
+      object = session_state.object_cache.object_by_name(:fact, name)
+      object.nil? ? nil : object.value
+    end
+
+    def self.fact_names(session_state)
+      session_state.object_cache.object_names_by_section(:fact).map(&:to_s)
+    end
+
+    def self.facts_to_hash(session_state)
+      fact_hash = {}
+      session_state.object_cache.objects_by_section(:fact) { |factname, fact| fact_hash[factname.to_s] = fact.value }
+      fact_hash
+    end
+  end
+end

data/lib/puppet-languageserver/global_queues/sidecar_queue.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require 'puppet-languageserver/global_queues/single_instance_queue'
+require 'puppet_editor_services/server'
+require 'open3'
+
+module PuppetLanguageServer
+  module GlobalQueues
+    class SidecarQueueJob < SingleInstanceQueueJob
+      attr_accessor :action, :additional_args, :handle_errors, :connection_id
+
+      def initialize(action, additional_args, handle_errors, connection_id)
+        super("#{action}-#{connection_id}")
+        @action = action
+        @additional_args = additional_args
+        @handle_errors = handle_errors
+        @connection_id = connection_id
+      end
+    end
+
+    # Module for enqueing and running sidecar jobs asynchronously
+    # When adding a job, it will remove any other for the same
+    # job in the queue, so that only the latest job needs to be processed.
+    class SidecarQueue < SingleInstanceQueue
+      def max_queue_threads
+        2
+      end
+
+      def job_class
+        SidecarQueueJob
+      end
+
+      def execute_job(job_object)
+        super
+        connection = connection_from_connection_id(job_object.connection_id)
+        raise "Connection is not available for connection id #{job_object.connection_id}" if connection.nil?
+
+        sidecar_path = File.expand_path(File.join(__dir__, '..', '..', '..', 'puppet-languageserver-sidecar'))
+        args = ['--action', job_object.action].concat(job_object.additional_args).concat(sidecar_args_from_connection(connection))
+        cmd = ['ruby', sidecar_path].concat(args)
+        PuppetLanguageServer.log_message(:debug, "SidecarQueue Thread: Running sidecar #{cmd}")
+        stdout, stderr, status = run_sidecar(cmd)
+        PuppetLanguageServer.log_message(:warning, "SidecarQueue Thread: Calling sidecar with #{args.join(' ')} returned exitcode #{status.exitstatus}, #{stderr}")
+        return nil unless status.exitstatus.zero?
+
+        # It's possible server has closed the connection while the sidecar is running.
+        # So raise if the connection is no longer available
+        raise "Connection is no longer available for connection id #{job_object.connection_id}" if connection_from_connection_id(job_object.connection_id).nil?
+
+        session_state = session_state_from_connection(connection)
+        raise "Session state is not available for connection id #{job_object.connection_id}" if session_state.nil?
+
+        cache = session_state.object_cache
+
+        # Correctly encode the result as UTF8
+        result = stdout.bytes.pack('U*')
+
+        case job_object.action.downcase
+        when 'default_aggregate'
+          lists = PuppetLanguageServer::Sidecar::Protocol::AggregateMetadata.new.from_json!(result)
+          cache.import_sidecar_list!(lists.classes,   :class, :default)
+          cache.import_sidecar_list!(lists.datatypes, :datatype, :default)
+          cache.import_sidecar_list!(lists.functions, :function, :default)
+          cache.import_sidecar_list!(lists.types,     :type, :default)
+
+          lists.each_list do |k, v|
+            if v.nil?
+              PuppetLanguageServer.log_message(:debug, "SidecarQueue Thread: default_aggregate returned no #{k}")
+            else
+              PuppetLanguageServer.log_message(:debug, "SidecarQueue Thread: default_aggregate returned #{v.count} #{k}")
+            end
+          end
+
+        when 'default_classes'
+          list = PuppetLanguageServer::Sidecar::Protocol::PuppetClassList.new.from_json!(result)
+          cache.import_sidecar_list!(list, :class, :default)
+          PuppetLanguageServer.log_message(:debug, "SidecarQueue Thread: default_classes returned #{list.count} items")
+
+        when 'default_datatypes'
+          list = PuppetLanguageServer::Sidecar::Protocol::PuppetDataTypeList.new.from_json!(result)
+          cache.import_sidecar_list!(list, :datatype, :default)
+          PuppetLanguageServer.log_message(:debug, "SidecarQueue Thread: default_datatypes returned #{list.count} items")
+
+        when 'default_functions'
+          list = PuppetLanguageServer::Sidecar::Protocol::PuppetFunctionList.new.from_json!(result)
+          cache.import_sidecar_list!(list, :function, :default)
+          PuppetLanguageServer.log_message(:debug, "SidecarQueue Thread: default_functions returned #{list.count} items")
+
+        when 'default_types'
+          list = PuppetLanguageServer::Sidecar::Protocol::PuppetTypeList.new.from_json!(result)
+          cache.import_sidecar_list!(list, :type, :default)
+          PuppetLanguageServer.log_message(:debug, "SidecarQueue Thread: default_types returned #{list.count} items")
+
+        when 'facts'
+          list = PuppetLanguageServer::Sidecar::Protocol::FactList.new.from_json!(result)
+          cache.import_sidecar_list!(list, :fact, :default)
+          PuppetLanguageServer.log_message(:debug, "SidecarQueue Thread: facts returned #{list.count} items")
+
+        when 'node_graph'
+          return PuppetLanguageServer::Sidecar::Protocol::PuppetNodeGraph.new.from_json!(result)
+
+        when 'resource_list'
+          return PuppetLanguageServer::Sidecar::Protocol::ResourceList.new.from_json!(result)
+
+        when 'workspace_aggregate'
+          lists = PuppetLanguageServer::Sidecar::Protocol::AggregateMetadata.new.from_json!(result)
+          cache.import_sidecar_list!(lists.classes,   :class, :workspace)
+          cache.import_sidecar_list!(lists.datatypes, :datatype, :workspace)
+          cache.import_sidecar_list!(lists.functions, :function, :workspace)
+          cache.import_sidecar_list!(lists.types,     :type, :workspace)
+
+          lists.each_list do |k, v|
+            if v.nil?
+              PuppetLanguageServer.log_message(:debug, "SidecarQueue Thread: workspace_aggregate returned no #{k}")
+            else
+              PuppetLanguageServer.log_message(:debug, "SidecarQueue Thread: workspace_aggregate returned #{v.count} #{k}")
+            end
+          end
+
+        when 'workspace_classes'
+          list = PuppetLanguageServer::Sidecar::Protocol::PuppetClassList.new.from_json!(result)
+          cache.import_sidecar_list!(list, :class, :workspace)
+          PuppetLanguageServer.log_message(:debug, "SidecarQueue Thread: workspace_classes returned #{list.count} items")
+
+        when 'workspace_datatypes'
+          list = PuppetLanguageServer::Sidecar::Protocol::PuppetDataTypeList.new.from_json!(result)
+          cache.import_sidecar_list!(list, :datatype, :workspace)
+          PuppetLanguageServer.log_message(:debug, "SidecarQueue Thread: workspace_datatypes returned #{list.count} items")
+
+        when 'workspace_functions'
+          list = PuppetLanguageServer::Sidecar::Protocol::PuppetFunctionList.new.from_json!(result)
+          cache.import_sidecar_list!(list, :function, :workspace)
+          PuppetLanguageServer.log_message(:debug, "SidecarQueue Thread: workspace_functions returned #{list.count} items")
+
+        when 'workspace_types'
+          list = PuppetLanguageServer::Sidecar::Protocol::PuppetTypeList.new.from_json!(result)
+          cache.import_sidecar_list!(list, :type, :workspace)
+          PuppetLanguageServer.log_message(:debug, "SidecarQueue Thread: workspace_types returned #{list.count} items")
+
+        else
+          PuppetLanguageServer.log_message(:error, "SidecarQueue Thread: Unknown action #{job_object.action}")
+        end
+
+        true
+      rescue StandardError => e
+        raise unless job_object.handle_errors
+
+        PuppetLanguageServer.log_message(:error, "SidecarQueue Thread: Error running action #{job_object.action}. #{e}\n#{e.backtrace}")
+        nil
+      end
+
+      private
+
+      def connection_from_connection_id(connection_id)
+        PuppetEditorServices::Server.current_server.connection(connection_id)
+      end
+
+      def session_state_from_connection(connection)
+        return if connection.nil?
+
+        handler = connection.protocol.handler
+        handler.respond_to?(:session_state) ? handler.session_state : nil
+      end
+
+      def run_sidecar(cmd)
+        Open3.capture3(*cmd)
+
+        # The following code should ONLY be uncommented when debugging acceptance tests failures.
+        # It caches the sidecar responses so tests sidecar calls will be (VERY) quick, which speeds
+        # up feedback loops. It has a rubocop failure on purpose so that it fails automated CI checks
+        # and should never be merged in a Pull Request
+        #
+        # output_dir = File.expand_path(File.join(__dir__, '..', '..', '..', 'output'))
+        # FileUtils.mkdir_p(output_dir) unless Dir.exist?(output_dir)
+        # require 'digest'
+        # cache_file = File.join(output_dir, Digest::MD5.hexdigest(cmd.join(' ')) + '.json')
+        # if File.exist?(cache_file)
+        #   return [
+        #     File.read(cache_file, mode: 'rb', encoding: 'utf-8'),
+        #     '',
+        #     Struct.new(:exitstatus).new(0)
+        #   ]
+        # end
+        # # Rubocop failure is here on purpose
+        # stdout,stderr,status = Open3.capture3(*cmd)
+        # File.write(cache_file, stdout, mode: 'wb', encoding: 'utf-8')
+        # [stdout, stderr, status]
+      end
+
+      def sidecar_args_from_connection(connection)
+        return nil if connection.nil?
+
+        options = connection.server.handler_options
+        return [] if options.nil?
+
+        result = []
+        result << '--no-cache' if options[:disable_sidecar_cache]
+        result << "--puppet-version=#{Puppet.version}"
+        result << "--feature-flags=#{options[:flags].join(',')}" if options[:flags] && !options[:flags].empty?
+        result << "--puppet-settings=#{options[:puppet_settings].join(',')}" if options[:puppet_settings] && !options[:puppet_settings].empty?
+        result
+      end
+    end
+  end
+end

data/lib/puppet-languageserver/global_queues/single_instance_queue.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module PuppetLanguageServer
+  module GlobalQueues
+    class SingleInstanceQueueJob
+      # Unique key for the job. The SingleInstanceQueue uses the key
+      # to ensure that only a single instance is in the queue
+      attr_reader :key
+
+      def initialize(key)
+        @key = key
+      end
+    end
+
+    # Base class for enqueing and running queued jobs asynchronously
+    # When adding a job, it will remove any other for the same
+    # key in the queue, so that only the latest job needs to be processed.
+    class SingleInstanceQueue
+      def initialize
+        @queue = []
+        @queue_mutex = Mutex.new
+        @queue_threads_mutex = Mutex.new
+        @queue_threads = []
+      end
+
+      # Default is one thread to process the queue
+      def max_queue_threads
+        1
+      end
+
+      # The ruby Job class that this queue operates on
+      # Should be inherited from SingleInstanceQueueJob
+      # @api asbtract
+      def job_class
+        SingleInstanceQueueJob
+      end
+
+      def new_job(*args)
+        job_class.new(*args)
+      end
+
+      # Helpful method to create, then enqueue a job
+      def enqueue(*args)
+        enqueue_job(new_job(*args))
+      end
+
+      # Enqueue a job
+      def enqueue_job(job_object)
+        raise "Invalid job object for #{self.class}. Got #{job_object.class} but expected #{job_class}" unless job_object.is_a?(job_class)
+
+        @queue_mutex.synchronize do
+          @queue.reject! { |queue_item| queue_item.key == job_object.key }
+          @queue << job_object
+        end
+
+        @queue_threads_mutex.synchronize do
+          # Clear up any done threads
+          @queue_threads.reject! { |thr| thr.nil? || !thr.alive? }
+          # Append a new thread if we have space
+          if @queue_threads.count < max_queue_threads
+            @queue_threads << Thread.new do
+              thread_worker
+            rescue => e # rubocop:disable Style/RescueStandardError
+              PuppetLanguageServer.log_message(:error, "Error in #{self.class} Thread: #{e}")
+              raise
+            end
+          end
+        end
+        nil
+      end
+
+      # Helpful method to create, then enqueue a job
+      def execute(*args)
+        execute_job(new_job(*args))
+      end
+
+      # Synchronously executes the same work as an enqueued item. Does not consume a queue thread
+      # The thread worker calls this method when processing enqueued items
+      # @abstract
+      def execute_job(job_object)
+        raise "Invalid job object for #{self.class}. Got #{job_object.class} but expected #{job_class}" unless job_object.is_a?(job_class)
+      end
+
+      # Wait for the queue to become empty
+      def drain_queue
+        @queue_threads.each do |item|
+          item.join unless item.nil? || !item.alive?
+        end
+        nil
+      end
+
+      # Testing helper resets the queue and prepopulates it with
+      # a known arbitrary configuration.
+      # ONLY USE THIS FOR TESTING!
+      def reset_queue(initial_state = [])
+        @queue_mutex.synchronize do
+          @queue = initial_state
+        end
+      end
+
+      private
+
+      # Thread worker which processes all jobs in the queue and calls the sidecar for each action
+      def thread_worker
+        work_item = nil
+        loop do
+          @queue_mutex.synchronize do
+            return if @queue.empty?
+
+            work_item = @queue.shift
+          end
+          return if work_item.nil?
+
+          # Perform action
+          begin
+            # When running async (i.e. from a thread swallow any output)
+            _result = execute_job(work_item)
+          rescue StandardError => e
+            PuppetLanguageServer.log_message(:error, "#{self.class} Thread: Error running job #{work_item.key}. #{e}\n#{e.backtrace}")
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/puppet-languageserver/global_queues/validation_queue.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'puppet-languageserver/global_queues/single_instance_queue'
+require 'puppet_editor_services/server'
+
+module PuppetLanguageServer
+  module GlobalQueues
+    class ValidationQueueJob < SingleInstanceQueueJob
+      attr_accessor :file_uri, :doc_version, :connection_id, :options
+
+      def initialize(file_uri, doc_version, connection_id, options = {})
+        super(file_uri)
+        @file_uri = file_uri
+        @doc_version = doc_version
+        @connection_id = connection_id
+        @options = options
+      end
+    end
+
+    # Class for enqueing and running document level validation asynchronously
+    #
+    # Uses a single instance queue so only the latest document needs to be processed.
+    # It will also ignore sending back validation results to the client if the document is updated during the validation process
+    class ValidationQueue < SingleInstanceQueue
+      def max_queue_threads
+        1
+      end
+
+      def job_class
+        ValidationQueueJob
+      end
+
+      def execute_job(job_object)
+        super
+        session_state = session_state_from_connection_id(job_object.connection_id)
+        document_store = session_state.nil? ? nil : session_state.documents
+        raise "Document store is not available for connection id #{job_object.connection_id}" unless document_store
+
+        # Check if the document still exists
+        doc = document_store.get_document(job_object.file_uri)
+        unless doc
+          # Send an empty diagnostics message to clear the diagnostics
+          send_diagnostics(job_object.connection_id, job_object.file_uri, [])
+          PuppetLanguageServer.log_message(:debug, "#{self.class.name}: Ignoring #{job_object.file_uri} as it is has been removed.")
+          return
+        end
+
+        # Check if the document is the latest version
+        content = document_store.document_content(job_object.file_uri, job_object.doc_version)
+        unless content
+          PuppetLanguageServer.log_message(:debug, "#{self.class.name}: Ignoring #{job_object.file_uri} as it is not the latest version.")
+          return
+        end
+
+        # Perform validation
+        options = job_object.options.dup
+        results = case document_store.document_type(job_object.file_uri)
+                  when :manifest
+                    options[:tasks_mode] = document_store.plan_file?(job_object.file_uri)
+                    PuppetLanguageServer::Manifest::ValidationProvider.validate(session_state, content, options)
+                  when :epp
+                    PuppetLanguageServer::Epp::ValidationProvider.validate(content)
+                  when :puppetfile
+                    options[:document_uri] = job_object.file_uri
+                    PuppetLanguageServer::Puppetfile::ValidationProvider.validate(content, options)
+                  else
+                    []
+                  end
+
+        # Because this may be asynchronous it's possible the user has edited the document while we're performing validation.
+        # Check if the document is still latest version and ignore the results if it's no longer the latest
+        current_version = document_store.document_version(job_object.file_uri)
+        if current_version != job_object.doc_version
+          PuppetLanguageServer.log_message(:debug, "ValidationQueue Thread: Ignoring #{job_object.file_uri} as has changed version from #{job_object.doc_version} to #{current_version}")
+          return
+        end
+
+        # Send the response
+        send_diagnostics(job_object.connection_id, job_object.file_uri, results)
+      end
+
+      private
+
+      def session_state_from_connection_id(connection_id)
+        connection = PuppetEditorServices::Server.current_server.connection(connection_id)
+        return if connection.nil?
+
+        handler = connection.protocol.handler
+        handler.respond_to?(:session_state) ? handler.session_state : nil
+      end
+
+      def send_diagnostics(connection_id, file_uri, diagnostics)
+        connection = PuppetEditorServices::Server.current_server.connection(connection_id)
+        return if connection.nil?
+
+        connection.protocol.encode_and_send(
+          ::PuppetEditorServices::Protocol::JsonRPCMessages.new_notification('textDocument/publishDiagnostics', 'uri' => file_uri, 'diagnostics' => diagnostics)
+        )
+      end
+    end
+  end
+end

data/lib/puppet-languageserver/global_queues.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'puppet-languageserver/global_queues/validation_queue'
+require 'puppet-languageserver/global_queues/sidecar_queue'
+
+module PuppetLanguageServer
+  module GlobalQueues
+    def self.validate_queue
+      @validate_queue ||= ValidationQueue.new
+    end
+
+    def self.sidecar_queue
+      @sidecar_queue ||= SidecarQueue.new
+    end
+  end
+end