(GH-163) Use the aggregate action for puppetstrings feature

This commit changes the language server to use the default and workspace
aggregate actions, but behind the puppetstrings feature.  There are no test
changes required.

Author: glennsarti

lib/puppet-languageserver-sidecar/puppet_helper_puppetstrings.rb

@@ -83,7 +83,7 @@ def self.retrieve_via_puppet_strings(cache, options = {})
       end
 
       # Remove Puppet3 functions which have a Puppet4 function already loaded
-      if object_types.include?(:function)
+      if object_types.include?(:function) && !result.functions.nil?
         pup4_functions = result.functions.select { |i| i.function_version == 4 }.map { |i| i.key }
         result.functions.reject! { |i| i.function_version == 3 && pup4_functions.include?(i.key) }
       end

lib/puppet-languageserver/puppet_helper.rb

@@ -181,6 +181,11 @@ def self.cache
 
     # Workspace Loading
     def self.load_workspace_async
+      if PuppetLanguageServer.featureflag?('puppetstrings')
+        return true if PuppetLanguageServer::DocumentStore.store_root_path.nil?
+        sidecar_queue.enqueue('workspace_aggregate', ['--local-workspace', PuppetLanguageServer::DocumentStore.store_root_path])
+        return true
+      end
       load_workspace_classes_async
       load_workspace_functions_async
       load_workspace_types_async
@@ -226,5 +231,12 @@ def self.with_temporary_file(content)
       tempfile.delete if tempfile
     end
     private_class_method :with_temporary_file
+
+    def self.load_default_aggregate_async
+      @default_classes_loaded   = false if @default_classes_loaded.nil?
+      @default_functions_loaded = false if @default_functions_loaded.nil?
+      @default_types_loaded     = false if @default_types_loaded.nil?
+      sidecar_queue.enqueue('default_aggregate', [])
+    end
   end
 end

lib/puppet-languageserver/puppet_helper/cache.rb

@@ -12,6 +12,7 @@ def initialize(_options = {})
       def import_sidecar_list!(list, section, origin = nil)
         section_object = section_to_object(section)
         return if section_object.nil?
+        list = [] if list.nil?
 
         @cache_lock.synchronize do
           # Remove the existing items

lib/puppet-languageserver/sidecar_queue.rb

@@ -63,6 +63,24 @@ def execute_sync(action, additional_args, handle_errors = false)
       result = stdout.bytes.pack('U*')
 
       case 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.functions, :function, :default)
+        @cache.import_sidecar_list!(lists.types,     :type, :default)
+
+        PuppetLanguageServer::PuppetHelper.assert_default_classes_loaded
+        PuppetLanguageServer::PuppetHelper.assert_default_functions_loaded
+        PuppetLanguageServer::PuppetHelper.assert_default_types_loaded
+
+        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)
@@ -90,6 +108,20 @@ def execute_sync(action, additional_args, handle_errors = false)
       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.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)

lib/puppet_languageserver.rb

@@ -24,6 +24,15 @@ def self.active?
     @server_is_active
   end
 
+  def self.configure_featureflags(flags)
+    @flags = flags
+  end
+
+  def self.featureflag?(flagname)
+    return false if @flags.nil? || @flags.empty?
+    @flags.include?(flagname)
+  end
+
   def self.require_gems(options)
     original_verbose = $VERBOSE
     $VERBOSE = nil
@@ -83,6 +92,15 @@ def self.require_gems(options)
         require File.expand_path(File.join(File.dirname(__FILE__), 'puppet-languageserver', lib))
       end
     end
+
+    # Validate the feature flags
+    unless options[:flags].nil? || options[:flags].empty?
+      flags = options[:flags]
+      log_message(:debug, "Detected feature flags [#{flags.join(', ')}]")
+
+      configure_featureflags(flags)
+    end
+
     @server_is_active = true
   ensure
     $VERBOSE = original_verbose
@@ -223,17 +241,25 @@ def self.init_puppet_worker(options)
 
     log_message(:info, "Using Facter v#{Facter.version}")
     if options[:preload_puppet]
-      log_message(:info, 'Preloading Puppet Types (Async)...')
-      PuppetLanguageServer::PuppetHelper.load_default_types_async
+      if featureflag?('puppetstrings')
+        log_message(:info, 'Preloading Default metadata (Async)...')
+        PuppetLanguageServer::PuppetHelper.load_default_aggregate_async
 
-      log_message(:info, 'Preloading Facter (Async)...')
-      PuppetLanguageServer::FacterHelper.load_facts_async
+        log_message(:info, 'Preloading Facter (Async)...')
+        PuppetLanguageServer::FacterHelper.load_facts_async
+      else
+        log_message(:info, 'Preloading Puppet Types (Async)...')
+        PuppetLanguageServer::PuppetHelper.load_default_types_async
 
-      log_message(:info, 'Preloading Functions (Async)...')
-      PuppetLanguageServer::PuppetHelper.load_default_functions_async
+        log_message(:info, 'Preloading Facter (Async)...')
+        PuppetLanguageServer::FacterHelper.load_facts_async
 
-      log_message(:info, 'Preloading Classes (Async)...')
-      PuppetLanguageServer::PuppetHelper.load_default_classes_async
+        log_message(:info, 'Preloading Functions (Async)...')
+        PuppetLanguageServer::PuppetHelper.load_default_functions_async
+
+        log_message(:info, 'Preloading Classes (Async)...')
+        PuppetLanguageServer::PuppetHelper.load_default_classes_async
+      end
 
       if PuppetLanguageServer::DocumentStore.store_has_module_metadata? || PuppetLanguageServer::DocumentStore.store_has_environmentconf?
         log_message(:info, 'Preloading Workspace (Async)...')

spec/languageserver/integration/puppet-languageserver/sidecar_queue_spec.rb

@@ -62,6 +62,28 @@ def exitstatus
   end
 
   describe '#execute_sync' do
+    context 'default_aggregate action' do
+      let(:action) { 'default_aggregate' }
+
+      it 'should deserialize the json, import into the cache and assert default classes are loaded' do
+        fixture = PuppetLanguageServer::Sidecar::Protocol::AggregateMetadata.new
+        fixture.append!(random_sidecar_puppet_class)
+        fixture.append!(random_sidecar_puppet_function)
+        fixture.append!(random_sidecar_puppet_type)
+        sidecar_response = [fixture.to_json, 'stderr', SuccessStatus.new]
+
+        expect(subject).to receive(:run_sidecar).and_return(sidecar_response)
+        expect(PuppetLanguageServer::PuppetHelper).to receive(:assert_default_classes_loaded)
+        expect(PuppetLanguageServer::PuppetHelper).to receive(:assert_default_functions_loaded)
+        expect(PuppetLanguageServer::PuppetHelper).to receive(:assert_default_types_loaded)
+
+        subject.execute_sync(action, [])
+        expect(cache.object_by_name(:class, fixture.classes[0].key)).to_not be_nil
+        expect(cache.object_by_name(:function, fixture.functions[0].key)).to_not be_nil
+        expect(cache.object_by_name(:type, fixture.types[0].key)).to_not be_nil
+      end
+    end
+
     context 'default_classes action' do
       let(:action) { 'default_classes' }