Merge pull request #237 from glennsarti/use-object-cache-take2

(GH-236) Use an in memory and persistent object cache for Puppet assets

Author: jpogran

client/CHANGELOG.md

@@ -8,6 +8,8 @@ Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how
 
 - ([GH-225](https://github.com/jpogran/puppet-vscode/issues/225)) Readd Local Workspace comand line option
 - ([GH-231](https://github.com/jpogran/puppet-vscode/issues/231)) Make Document Validation asynchronous
+- ([GH-236](https://github.com/jpogran/puppet-vscode/issues/236)) Remove the preload option
+- ([GH-236](https://github.com/jpogran/puppet-vscode/issues/236)) Add experimental file cache option
 
 ## 0.9.0 - 2018-02-01
 

client/package.json

@@ -288,10 +288,10 @@
           "default": 10,
           "description": "The timeout to connect to the local Puppet Language Server"
         },
-        "puppet.languageserver.preLoadPuppet": {
+        "puppet.languageserver.filecache.enable": {
           "type": "boolean",
-          "default": true,
-          "description": "Initalize Puppet and Facter when local Puppet Language Server starts"
+          "default": false,
+          "description": "(Experimental) Enable a persistent file cache for Puppet objects in the Language Server"
         },
         "puppet.languageserver.debugFilePath": {
           "type": "string",

client/src/configuration.ts

@@ -6,23 +6,23 @@ import { IConnectionConfiguration, ConnectionType } from './interfaces';
 import { ConnectionManager } from './connection';
 
 export class ConnectionConfiguration implements IConnectionConfiguration {
-  public type: ConnectionType = ConnectionType.Unknown; 
+  public type: ConnectionType = ConnectionType.Unknown;
   public host: string = undefined;
   public port: number = undefined;
   public timeout: number = undefined;
-  public preLoadPuppet: boolean = undefined;
+  public enableFileCache: boolean = undefined;
   public debugFilePath: string = undefined;
   public puppetAgentDir: string = undefined;
 
   constructor(context: vscode.ExtensionContext) {
     let config = vscode.workspace.getConfiguration('puppet');
 
-    this.host          = config['languageserver']['address'];
-    this.port          = config['languageserver']['port'];
-    this.timeout       = config['languageserver']['timeout'];
-    this.preLoadPuppet = config['languageserver']['preLoadPuppet'];
-    this.debugFilePath = config['languageserver']['debugFilePath'];
-    
+    this.host            = config['languageserver']['address'];
+    this.port            = config['languageserver']['port'];
+    this.timeout         = config['languageserver']['timeout'];
+    this.enableFileCache = config['languageserver']['filecache']['enable'];
+    this.debugFilePath   = config['languageserver']['debugFilePath'];
+
     this.puppetAgentDir = config['puppetAgentDir'];
   }
 }

client/src/connection.ts

@@ -170,7 +170,9 @@ export class ConnectionManager implements IConnectionManager {
     }
     args.push('--port=' + this.connectionConfiguration.port);
     args.push('--timeout=' + this.connectionConfiguration.timeout);
-    if (this.connectionConfiguration.preLoadPuppet == false) { args.push('--no-preload'); }
+    if (this.connectionConfiguration.enableFileCache) {
+      args.push('--enable-file-cache');
+    }
     if ((this.connectionConfiguration.debugFilePath != undefined) && (this.connectionConfiguration.debugFilePath != '')) {
       args.push('--debug=' + this.connectionConfiguration.debugFilePath);
     }
@@ -291,10 +293,10 @@ export class ConnectionManager implements IConnectionManager {
 
         connectionManager.languageClient.sendRequest(messages.PuppetVersionRequest.type).then((versionDetails) => {
           lastVersionResponse = versionDetails
-          if (!connectionManager.connectionConfiguration.preLoadPuppet || (versionDetails.factsLoaded &&
+          if (versionDetails.factsLoaded &&
               versionDetails.functionsLoaded &&
               versionDetails.typesLoaded &&
-              versionDetails.classesLoaded)) {
+              versionDetails.classesLoaded) {
             clearInterval(handle);
             this.setConnectionStatus(lastVersionResponse.puppetVersion, ConnectionStatus.Running);
             resolve();

client/src/debugAdapter.ts

@@ -43,7 +43,7 @@ class DebugConfiguration implements IConnectionConfiguration {
   public host: string = "127.0.0.1";
   public port: number = 8082;
   public timeout: number = 10;
-  public preLoadPuppet: boolean = false;
+  public enableFileCache: boolean = undefined;
   public debugFilePath: string; // = "STDOUT";
   public puppetAgentDir: string;
 }
@@ -117,7 +117,7 @@ function startDebugServer(config:DebugConfiguration, debugLogger: ILogger) {
   if (localServer == null) { localServer = RubyHelper.getRubyEnvFromPuppetAgent(rubyfile, config, debugLogger); }
   // Commented out for the moment.  This will be enabled once the configuration and exact user story is figured out.
   // if (localServer == null) { localServer = RubyHelper.getRubyEnvFromPDK(rubyfile, config, debugLogger); }
-  
+
   if (localServer == null) {
     sendErrorMessage("Unable to find a valid ruby environment");
     process.exit(255);
@@ -145,7 +145,7 @@ function startDebugging(config:DebugConfiguration, debugLogger:ILogger) {
   debugServerProc.on('close', (exitCode) => {
     debugLogger.debug("Debug server terminated with exit code: " + exitCode);
     debugServerProc.kill();
-    process.exit(exitCode); 
+    process.exit(exitCode);
   });
 
   debugServerProc.on('error', (data) => {
@@ -155,19 +155,19 @@ function startDebugging(config:DebugConfiguration, debugLogger:ILogger) {
   process.on('SIGTERM', () => {
     debugLogger.debug("Received SIGTERM");
     debugServerProc.kill();
-    process.exit(0); 
+    process.exit(0);
   });
 
   process.on('SIGHUP', () => {
     debugLogger.debug("Received SIGHUP");
     debugServerProc.kill();
-    process.exit(0); 
+    process.exit(0);
   });
 
   process.on('exit', () => {
     debugLogger.debug("Received Exit");
     debugServerProc.kill();
-    process.exit(0); 
+    process.exit(0);
   });
 }
 

client/src/interfaces.ts

@@ -21,7 +21,7 @@ export interface IConnectionConfiguration {
   host: string;
   port: number;
   timeout: number;
-  preLoadPuppet: boolean;
+  enableFileCache: boolean;
   debugFilePath: string;
   puppetAgentDir: string;
 }

server/lib/puppet-languageserver.rb

@@ -56,7 +56,8 @@ def self.parse(options)
           args[:connection_timeout] = timeout.to_i
         end
 
-        opts.on('-d', '--no-preload', 'Do not preload Puppet information when the language server starts.  Default is to preload') do |_misc|
+        opts.on('-d', '--no-preload', '** DEPRECATED ** Do not preload Puppet information when the language server starts.  Default is to preload') do |_misc|
+          puts '** WARNING ** Using "--no-preload" may cause Puppet Type loading to be incomplete.'
           args[:preload_puppet] = false
         end
 
@@ -72,6 +73,12 @@ def self.parse(options)
           args[:stdio] = true
         end
 
+        opts.on('--enable-file-cache', 'Enables the file system cache for Puppet Objects (types, class etc.)') do |_misc|
+          args[:cache] = {
+            :persistent_cache => :file
+          }
+        end
+
         opts.on('--local-workspace=PATH', 'The workspace or file path that will be used to provide module-specific functionality. Default is no workspace path.') do |path|
           args[:workspace] = path
         end
@@ -101,6 +108,9 @@ def self.init_puppet(options)
     log_message(:info, "Language Server is v#{PuppetVSCode.version}")
     log_message(:info, "Using Puppet v#{Puppet.version}")
 
+    log_message(:info, 'Initializing Puppet Helper Cache...')
+    PuppetLanguageServer::PuppetHelper.configure_cache(options[:cache])
+
     log_message(:info, 'Initializing settings...')
     if options[:fast_start_tcpserver]
       Thread.new do
@@ -118,12 +128,12 @@ def self.init_puppet_worker(options)
 
     log_message(:info, "Using Facter v#{Facter.version}")
     if options[:preload_puppet]
+      log_message(:info, 'Preloading Puppet Types (Sync)...')
+      PuppetLanguageServer::PuppetHelper.load_types
+
       log_message(:info, 'Preloading Facter (Async)...')
       PuppetLanguageServer::FacterHelper.load_facts_async
 
-      log_message(:info, 'Preloading Puppet Types (Async)...')
-      PuppetLanguageServer::PuppetHelper.load_types_async
-
       log_message(:info, 'Preloading Functions (Async)...')
       PuppetLanguageServer::PuppetHelper.load_functions_async
 

server/lib/puppet-languageserver/completion_provider.rb

@@ -44,29 +44,26 @@ def self.complete(content, line_num, char_num)
         # We are inside a resource definition.  Should display all available
         # properities and parameters.
 
-        # TODO: Should really cache all of the resources and params/props for quick
-        # searching and then only actually instatiate when needed.  For the moment,
-        # instantiate all the things!
-
-        item_type = Puppet::Type.type(item.type_name.value)
+        item_type = PuppetLanguageServer::PuppetHelper.get_type(item.type_name.value)
         # Add Parameters
-        item_type.parameters.each do |param|
-          items << LanguageServer::CompletionItem.create('label'  => param.to_s,
+        item_type.parameters.each_key do |name|
+          items << LanguageServer::CompletionItem.create('label'  => name.to_s,
                                                          'kind'   => LanguageServer::COMPLETIONITEMKIND_PROPERTY,
                                                          'detail' => 'Parameter',
                                                          'data'   => { 'type' => 'resource_parameter',
-                                                                       'param' => param.to_s,
+                                                                       'param' => name.to_s,
                                                                        'resource_type' => item.type_name.value })
         end
         # Add Properties
-        item_type.properties.each do |prop|
-          items << LanguageServer::CompletionItem.create('label'  => prop.name.to_s,
+        item_type.properties.each_key do |name|
+          items << LanguageServer::CompletionItem.create('label'  => name.to_s,
                                                          'kind'   => LanguageServer::COMPLETIONITEMKIND_PROPERTY,
                                                          'detail' => 'Property',
                                                          'data'   => { 'type' => 'resource_property',
-                                                                       'prop' => prop.name.to_s,
+                                                                       'prop' => name.to_s,
                                                                        'resource_type' => item.type_name.value })
         end
+        # TODO: What about meta parameters?
       end
 
       LanguageServer::CompletionList.create('isIncomplete' => incomplete,
@@ -110,12 +107,12 @@ def self.all_resources(&block)
 
     def self.all_statement_functions(&block)
       # Find functions which don't return values i.e. statements
-      PuppetLanguageServer::PuppetHelper.functions.select { |_key, obj| obj[:type] == :statement }.each_key do |key|
-        item = LanguageServer::CompletionItem.create('label' => key.to_s,
+      PuppetLanguageServer::PuppetHelper.filtered_function_names { |_name, data| data.type == :statement }.each do |name|
+        item = LanguageServer::CompletionItem.create('label' => name.to_s,
                                                      'kind'   => LanguageServer::COMPLETIONITEMKIND_FUNCTION,
                                                      'detail' => 'Function',
                                                      'data'   => { 'type' => 'function',
-                                                                   'name' => key.to_s })
+                                                                   'name' => name.to_s })
         block.call(item) if block
       end
     end
@@ -162,32 +159,36 @@ def self.resolve(completion_item)
 
       when 'function'
         item_type = PuppetLanguageServer::PuppetHelper.function(data['name'])
-        completion_item['documentation'] = item_type[:doc] unless item_type[:doc].nil?
+        completion_item['documentation'] = item_type.doc unless item_type.doc.nil?
         completion_item['insertText'] = "#{data['name']}(${1:value}"
-        (2..item_type[:arity]).each do |index|
+        (2..item_type.arity).each do |index|
           completion_item['insertText'] += ", ${#{index}:value}"
         end
         completion_item['insertText'] += ')'
         completion_item['insertTextFormat'] = LanguageServer::INSERTTEXTFORMAT_SNIPPET
 
       when 'resource_type'
-        item_type = Puppet::Type.type(data['name'])
+        item_type = PuppetLanguageServer::PuppetHelper.get_type(data['name'])
         # TODO: More things?
         completion_item['documentation'] = item_type.doc unless item_type.doc.nil?
         completion_item['insertText'] = "#{data['name']} { '${1:title}':\n\tensure => '${2:present}'\n}"
         completion_item['insertTextFormat'] = LanguageServer::INSERTTEXTFORMAT_SNIPPET
       when 'resource_parameter'
-        item_type = Puppet::Type.type(data['resource_type'])
-        param_type = item_type.attrclass(data['param'].intern)
-        # TODO: More things?
-        completion_item['documentation'] = param_type.doc unless param_type.doc.nil?
-        completion_item['insertText'] = "#{data['param']} => "
+        item_type = PuppetLanguageServer::PuppetHelper.get_type(data['resource_type'])
+        param_type = item_type.parameters[data['param'].intern]
+        unless param_type.nil?
+          # TODO: More things?
+          completion_item['documentation'] = param_type[:doc] unless param_type[:doc].nil?
+          completion_item['insertText'] = "#{data['param']} => "
+        end
       when 'resource_property'
-        item_type = Puppet::Type.type(data['resource_type'])
-        prop_type = item_type.attrclass(data['prop'].intern)
-        # TODO: More things?
-        completion_item['documentation'] = prop_type.doc unless prop_type.doc.nil?
-        completion_item['insertText'] = "#{data['prop']} => "
+        item_type = PuppetLanguageServer::PuppetHelper.get_type(data['resource_type'])
+        prop_type = item_type.properties[data['prop'].intern]
+        unless prop_type.nil?
+          # TODO: More things?
+          completion_item['documentation'] = prop_type[:doc] unless prop_type[:doc].nil?
+          completion_item['insertText'] = "#{data['prop']} => "
+        end
       end
 
       LanguageServer::CompletionItem.create(completion_item)

server/lib/puppet-languageserver/definition_provider.rb

@@ -65,14 +65,14 @@ def self.find_definition(content, line_num, char_num)
     def self.type_or_class(resource_name)
       # Strip the leading double-colons for root resource names
       resource_name = resource_name.slice(2, resource_name.length - 2) if resource_name.start_with?('::')
-      location = PuppetLanguageServer::PuppetHelper.type_load_info(resource_name)
-      location = PuppetLanguageServer::PuppetHelper.class_load_info(resource_name) if location.nil?
-      unless location.nil?
+      item = PuppetLanguageServer::PuppetHelper.get_type(resource_name)
+      item = PuppetLanguageServer::PuppetHelper.get_class(resource_name) if item.nil?
+      unless item.nil?
         return LanguageServer::Location.create(
-          'uri' => 'file:///' + location['source'],
-          'fromline' => location['line'],
+          'uri' => 'file:///' + item.source,
+          'fromline' => item.line,
           'fromchar' => 0,
-          'toline' => location['line'],
+          'toline' => item.line,
           'tochar' => 1024
         )
       end
@@ -81,17 +81,15 @@ def self.type_or_class(resource_name)
     private_class_method :type_or_class
 
     def self.function_name(func_name)
-      location = PuppetLanguageServer::PuppetHelper.function_load_info(func_name)
-      unless location.nil?
-        return LanguageServer::Location.create(
-          'uri' => 'file:///' + location['source'],
-          'fromline' => location['line'],
-          'fromchar' => 0,
-          'toline' => location['line'],
-          'tochar' => 1024
-        )
-      end
-      nil
+      item = PuppetLanguageServer::PuppetHelper.function(func_name)
+      return nil if item.nil? || item.source.nil? || item.line.nil?
+      LanguageServer::Location.create(
+        'uri' => 'file:///' + item.source,
+        'fromline' => item.line,
+        'fromchar' => 0,
+        'toline' => item.line,
+        'tochar' => 1024
+      )
     end
     private_class_method :function_name
   end

server/lib/puppet-languageserver/hover_provider.rb

@@ -40,10 +40,10 @@ def self.resolve(content, line_num, char_num)
         item_type = PuppetLanguageServer::PuppetHelper.get_type(path[distance_up_ast - 1].type_name.value)
         raise "#{path[distance_up_ast - 1].type_name.value} is not a valid puppet type" if item_type.nil?
         # Check if it's a property
-        attribute = item_type.validproperty?(item.attribute_name)
+        attribute = item_type.properties.keys.include?(item.attribute_name.intern)
         if attribute != false
           content = get_attribute_property_content(item_type, item.attribute_name.intern)
-        elsif item_type.validparameter?(item.attribute_name.intern)
+        elsif item_type.parameters.keys.include?(item.attribute_name.intern)
           content = get_attribute_parameter_content(item_type, item.attribute_name.intern)
         end
 
@@ -102,17 +102,17 @@ def self.get_fact_content(factname)
     end
 
     def self.get_attribute_parameter_content(item_type, param)
-      param_type = item_type.attrclass(param)
+      param_type = item_type.parameters[param]
       content = "**#{param}** Parameter"
-      content += "\n\n#{param_type.doc}" unless param_type.doc.nil?
+      content += "\n\n#{param_type[:doc]}" unless param_type[:doc].nil?
       content
     end
 
     def self.get_attribute_property_content(item_type, property)
-      prop_type = item_type.attrclass(property)
+      prop_type = item_type.properties[property]
       content = "**#{property}** Property"
-      content += "\n\n(_required_)" if prop_type.required?
-      content += "\n\n#{prop_type.doc}" unless prop_type.doc.nil?
+      content += "\n\n(_required_)" if prop_type[:required?]
+      content += "\n\n#{prop_type[:doc]}" unless prop_type[:doc].nil?
       content
     end
 
@@ -124,7 +124,7 @@ def self.get_call_named_function_expression_content(item)
 
       # TODO: what about rvalue?
       content = "**#{func_name}** Function\n\n" # TODO: Do I add in the params from the arity number?
-      content += func_info[:doc]
+      content += func_info.doc
 
       content
     end