Initial refactor of catalogs using inheritance

Author: kpaulisse

lib/octocatalog-diff/catalog.rb

@@ -12,88 +12,110 @@
 require_relative 'errors'
 
 module OctocatalogDiff
-  # This class represents a catalog. Generation of the catalog is handled via one of the
+  # Basic methods for interacting with a catalog. Generation of the catalog is handled via one of the
   # supported backends listed above as 'require_relative'. Usually, the 'computed' backend
   # will build the catalog from the Puppet command.
   class Catalog
-    # Readable
-    attr_reader :built, :catalog, :catalog_json
+    attr_accessor :node
+    attr_reader :built, :catalog, :catalog_json, :options
 
     # Constructor
-    # @param :backend [Symbol] If set, this will force a backend
-    # @param :json [String] JSON catalog content (will avoid running Puppet to compile catalog)
-    # @param :puppetdb [Object] If set, pull the catalog from PuppetDB rather than building
-    # @param :node [String] Name of node whose catalog is being built
-    # @param :fact_file [String] OPTIONAL: Path to fact file (if not provided, look up in PuppetDB)
-    # @param :hiera_config [String] OPTIONAL: Path to hiera config file (munge temp. copy if not provided)
-    # @param :basedir [String] OPTIONAL: Base directory for catalog (default base directory of this checkout)
-    # @param :pass_env_vars [Array<String>] OPTIONAL: Additional environment vars to pass
-    # @param :convert_file_resources [Boolean] OPTIONAL: Convert file resource source to content
-    # @param :storeconfigs [Boolean] OPTIONAL: Pass the '-s' flag, for puppetdb (storeconfigs) integration
     def initialize(options = {})
+      unless options.is_a?(Hash)
+        raise ArgumentError, "#{self.class}.initialize requires hash argument, not #{options.class}"
+      end
       @options = options
 
+      # Basic settings
+      @node = options[:node]
+      @error_message = nil
+      @catalog = nil
+      @catalog_json = nil
+
       # The compilation directory can be overridden, e.g. when testing
       @override_compilation_dir = options[:compilation_dir]
 
       # Keep track of whether references have been validated yet. Allow this to be fudged for when we do
       # not desire reference validation to happen (e.g., for the "from" catalog that is otherwise valid).
       @references_validated = options[:references_validated] || false
 
-      # Call appropriate backend for catalog generation
-      @catalog_obj = backend(options)
+      # Keep track of whether file resources have been converted.
+      @file_resources_converted = false
 
-      # The catalog is not built yet, except if the backend has no build method
+      # Keep track of whether it's built yet
       @built = false
-      build unless @catalog_obj.respond_to?(:build)
+    end
+
+    # Guess the backend from the input and return the appropriate catalog object.
+    # @param :backend [Symbol] If set, this will force a backend
+    # @param :json [String] JSON catalog content (will avoid running Puppet to compile catalog)
+    # @param :puppetdb [Object] If set, pull the catalog from PuppetDB rather than building
+    # @param :node [String] Name of node whose catalog is being built
+    # @param :fact_file [String] OPTIONAL: Path to fact file (if not provided, look up in PuppetDB)
+    # @param :hiera_config [String] OPTIONAL: Path to hiera config file (munge temp. copy if not provided)
+    # @param :basedir [String] OPTIONAL: Base directory for catalog (default base directory of this checkout)
+    # @param :pass_env_vars [Array<String>] OPTIONAL: Additional environment vars to pass
+    # @param :convert_file_resources [Boolean] OPTIONAL: Convert file resource source to content
+    # @param :storeconfigs [Boolean] OPTIONAL: Pass the '-s' flag, for puppetdb (storeconfigs) integration
+    # @return [OctocatalogDiff::Catalog::<?>] Catalog object from guessed backend
+    def self.create(options = {})
+      # Hard-coded backend
+      if options[:backend]
+        return OctocatalogDiff::Catalog::JSON.new(options) if options[:backend] == :json
+        return OctocatalogDiff::Catalog::PuppetDB.new(options) if options[:backend] == :puppetdb
+        return OctocatalogDiff::Catalog::PuppetMaster.new(options) if options[:backend] == :puppetmaster
+        return OctocatalogDiff::Catalog::Computed.new(options) if options[:backend] == :computed
+        return OctocatalogDiff::Catalog::Noop.new(options) if options[:backend] == :noop
+        raise ArgumentError, "Unknown backend :#{options[:backend]}"
+      end
+
+      # Determine backend based on arguments
+      return OctocatalogDiff::Catalog::JSON.new(options) if options[:json]
+      return OctocatalogDiff::Catalog::PuppetDB.new(options) if options[:puppetdb]
+      return OctocatalogDiff::Catalog::PuppetMaster.new(options) if options[:puppet_master]
+
+      # Default is to build catalog ourselves
+      OctocatalogDiff::Catalog::Computed.new(options)
     end
 
     # Build catalog - this method needs to be called to build the catalog. It is separate due to
     # the serialization of the logger object -- the parallel gem cannot serialize/deserialize a logger
     # object so it cannot be part of any object that is passed around.
     # @param logger [Logger] Logger object, initialized to a default throwaway value
     def build(logger = Logger.new(StringIO.new))
-      # Only build once
+      # If already built, don't build again
       return if @built
       @built = true
 
-      # Call catalog's build method.
-      if @catalog_obj.respond_to?(:build)
-        logger.debug "Calling build for object #{@catalog_obj.class}"
-        @catalog_obj.build(logger)
-      end
-
-      # These methods must exist in all backends
-      @catalog = @catalog_obj.catalog
-      @catalog_json = @catalog_obj.catalog_json
-      @error_message = @catalog_obj.error_message
-
       # The resource hash is computed the first time it's needed. For now initialize it as nil.
       @resource_hash = nil
 
+      # Invoke the backend's build method, if there is one. There's a stub below in case there's not.
+      build_catalog(logger)
+
       # Perform post-generation processing of the catalog
       return unless valid?
 
       validate_references
       return unless valid?
 
-      unless @catalog_obj.respond_to?(:convert_file_resources) && @catalog_obj.convert_file_resources == false
-        if @options.fetch(:compare_file_text, false)
-          OctocatalogDiff::CatalogUtil::FileResources.convert_file_resources(self, environment)
-        end
-      end
+      convert_file_resources(logger)
+    end
+
+    # Stub method if the backend does not contain a build method.
+    def build_catalog(_logger)
     end
 
     # Compilation environment
     # @return [String] Compilation environment (if set), else 'production' by default
     def environment
-      @catalog_obj.respond_to?(:environment) ? @catalog_obj.environment : 'production'
+      @environment ||= 'production'
     end
 
     # For logging we may wish to know the backend being used
     # @return [String] Class of backend used
     def builder
-      @catalog_obj.class.to_s
+      self.class.to_s
     end
 
     # Set the catalog JSON
@@ -106,8 +128,7 @@ def catalog_json=(str)
     # This retrieves the compilation directory from the catalog, or otherwise the passed-in directory.
     # @return [String] Compilation directory
     def compilation_dir
-      return @override_compilation_dir if @override_compilation_dir
-      @catalog_obj.respond_to?(:compilation_dir) ? @catalog_obj.compilation_dir : @options[:basedir]
+      @override_compilation_dir || @options[:basedir]
     end
 
     # The compilation directory can be overridden, e.g. during testing.
@@ -116,16 +137,16 @@ def compilation_dir=(dir)
       @override_compilation_dir = dir
     end
 
-    # Determine whether the underlying catalog object supports :compare_file_text
-    # @return [Boolean] Whether underlying catalog object supports :compare_file_text
-    def convert_file_resources
-      return true unless @catalog_obj.respond_to?(:convert_file_resources)
-      @catalog_obj.convert_file_resources
+    # Stub method for "convert_file_resources" to avoid errors if the backend doesn't support this.
+    # @return [Boolean] True
+    def convert_file_resources(logger = Logger.new(StringIO.new))
+      logger.debug "Disabling --compare-file-text; not supported by #{self.class}"
     end
 
     # Retrieve the error message.
     # @return [String] Error message (maximum 20,000 characters) - nil if no error.
     def error_message
+      build
       return nil if @error_message.nil? || !@error_message.is_a?(String)
       @error_message[0, 20_000]
     end
@@ -141,12 +162,11 @@ def error_message=(error)
       @resource_hash = nil
     end
 
-    # This retrieves the version of Puppet used to compile a catalog. If the underlying catalog was not
-    # compiled by running Puppet (e.g., it was read in from JSON or puppetdb), then this returns the
-    # puppet version optionally passed in to the constructor. This can also be nil.
+    # Stub method to return the puppet version if the back end doesn't support this.
     # @return [String] Puppet version
     def puppet_version
-      @catalog_obj.respond_to?(:puppet_version) ? @catalog_obj.puppet_version : @options[:puppet_version]
+      build
+      @options[:puppet_version]
     end
 
     # This allows retrieving a resource by type and title. This is intended for use when a O(1) lookup is required.
@@ -155,6 +175,7 @@ def puppet_version
     # @return [Hash] Resource item
     def resource(opts = {})
       raise ArgumentError, ':type and :title are required' unless opts[:type] && opts[:title]
+      build
       build_resource_hash if @resource_hash.nil?
       return nil unless @resource_hash[opts[:type]].is_a?(Hash)
       @resource_hash[opts[:type]][opts[:title]]
@@ -163,6 +184,7 @@ def resource(opts = {})
     # This is a compatibility layer for the resources, which are in a different place in Puppet 3.x and Puppet 4.x
     # @return [Array] Resource array
     def resources
+      build
       raise OctocatalogDiff::Errors::CatalogError, 'Catalog does not appear to have been built' if !valid? && error_message.nil?
       raise OctocatalogDiff::Errors::CatalogError, error_message unless valid?
       return @catalog['data']['resources'] if @catalog['data'].is_a?(Hash) && @catalog['data']['resources'].is_a?(Array)
@@ -173,16 +195,17 @@ def resources
       # :nocov:
     end
 
-    # This retrieves the number of retries necessary to compile the catalog. If the underlying catalog
+    # Stub method of the the number of retries necessary to compile the catalog. If the underlying catalog
     # generation backend does not support retries, nil is returned.
     # @return [Integer] Retry count
     def retries
-      @retries = @catalog_obj.respond_to?(:retries) ? @catalog_obj.retries : nil
+      nil
     end
 
     # Determine if the catalog build was successful.
     # @return [Boolean] Whether the catalog is valid
     def valid?
+      build
       !@catalog.nil?
     end
 
@@ -281,29 +304,6 @@ def resources_missing_from_catalog(resources_to_check)
       end
     end
 
-    # Private method: Choose backend based on passed-in options
-    # @param options [Hash] Options passed into constructor
-    # @return [Object] OctocatalogDiff::Catalog::<whatever> object
-    def backend(options)
-      # Hard-coded backend
-      if options[:backend]
-        return OctocatalogDiff::Catalog::JSON.new(options) if options[:backend] == :json
-        return OctocatalogDiff::Catalog::PuppetDB.new(options) if options[:backend] == :puppetdb
-        return OctocatalogDiff::Catalog::PuppetMaster.new(options) if options[:backend] == :puppetmaster
-        return OctocatalogDiff::Catalog::Computed.new(options) if options[:backend] == :computed
-        return OctocatalogDiff::Catalog::Noop.new(options) if options[:backend] == :noop
-        raise ArgumentError, "Unknown backend :#{options[:backend]}"
-      end
-
-      # Determine backend based on arguments
-      return OctocatalogDiff::Catalog::JSON.new(options) if options[:json]
-      return OctocatalogDiff::Catalog::PuppetDB.new(options) if options[:puppetdb]
-      return OctocatalogDiff::Catalog::PuppetMaster.new(options) if options[:puppet_master]
-
-      # Default is to build catalog ourselves
-      OctocatalogDiff::Catalog::Computed.new(options)
-    end
-
     # Private method: Build the resource hash to be used used for O(1) lookups by type and title.
     # This method is called the first time the resource hash is accessed.
     def build_resource_hash
@@ -317,5 +317,16 @@ def build_resource_hash
         end
       end
     end
+
+    # Private method: A common way of running convert_file_resources for backends that allow it.
+    def convert_file_resources_real(logger = Logger.new(StringIO.new))
+      return false unless @options[:compare_file_text]
+      if @options[:basedir]
+        OctocatalogDiff::CatalogUtil::FileResources.convert_file_resources(self, environment)
+      else
+        logger.debug "Disabling --compare-file-text; not supported by #{self.class} without basedir"
+        false
+      end
+    end
   end
 end

lib/octocatalog-diff/catalog/computed.rb

@@ -4,6 +4,7 @@
 require 'json'
 require 'stringio'
 
+require_relative '../catalog'
 require_relative '../catalog-util/bootstrap'
 require_relative '../catalog-util/builddir'
 require_relative '../catalog-util/command'
@@ -15,9 +16,7 @@ module OctocatalogDiff
   class Catalog
     # Represents a Puppet catalog that is computed (via `puppet master --compile ...`)
     # By instantiating this class, the catalog is computed.
-    class Computed
-      attr_reader :node, :error_message, :catalog, :catalog_json, :retries
-
+    class Computed < OctocatalogDiff::Catalog
       # Constructor
       # @param :node [String] REQUIRED: Node name
       # @param :basedir [String] Directory in which to compile the catalog
@@ -28,14 +27,9 @@ class Computed
       # @param :puppet_version [String] Puppet version (optional; if not supplied, it is calculated)
       # @param :puppet_command [String] Full command to run Puppet (optional; if not supplied, it is calculated)
       def initialize(options)
-        raise ArgumentError, 'Usage: OctocatalogDiff::Catalog::Computed.initialize(options_hash)' unless options.is_a?(Hash)
-        raise ArgumentError, 'Node name must be passed to OctocatalogDiff::Catalog::Computed' unless options[:node].is_a?(String)
+        super
 
-        # Standard readable variables
-        @node = options[:node]
-        @error_message = nil
-        @catalog = nil
-        @catalog_json = nil
+        raise ArgumentError, 'Node name must be passed to OctocatalogDiff::Catalog::Computed' unless options[:node].is_a?(String)
 
         # Additional class variables
         @pass_env_vars = options.fetch(:pass_env_vars, [])
@@ -53,17 +47,6 @@ def initialize(options)
         raise ArgumentError, 'Branch is undefined' unless @opts[:branch]
       end
 
-      # Actually build the catalog (populate @error_message, @catalog, @catalog_json)
-      def build(logger = Logger.new(StringIO.new))
-        if @facts_terminus != 'facter'
-          facts_obj = OctocatalogDiff::CatalogUtil::Facts.new(@opts, logger)
-          logger.debug "Start retrieving facts for #{@node} from #{self.class}"
-          @opts[:facts] = facts_obj.facts
-          logger.debug "Success retrieving facts for #{@node} from #{self.class}"
-        end
-        build_catalog(logger)
-      end
-
       # Get the Puppet version
       # @return [String] Puppet version
       def puppet_version
@@ -83,6 +66,11 @@ def environment
         @opts.fetch(:environment, 'production')
       end
 
+      # Convert file source => ... to content => ... if a basedir is given.
+      def convert_file_resources(logger = Logger.new(StringIO.new))
+        convert_file_resources_real(logger)
+      end
+
       private
 
       # Private method: Clean up a checkout directory, if it exists
@@ -137,7 +125,13 @@ def bootstrap(logger)
       # Private method: Build catalog by running Puppet
       # @param logger [Logger] Logger object
       def build_catalog(logger = nil)
-        return nil unless @catalog.nil? && @error_message.nil?
+        if @facts_terminus != 'facter'
+          facts_obj = OctocatalogDiff::CatalogUtil::Facts.new(@opts, logger)
+          logger.debug "Start retrieving facts for #{@node} from #{self.class}"
+          @opts[:facts] = facts_obj.facts
+          logger.debug "Success retrieving facts for #{@node} from #{self.class}"
+        end
+
         bootstrap(logger)
         result = run_puppet(logger)
         @retries = result[:retries]

lib/octocatalog-diff/catalog/json.rb

@@ -1,21 +1,22 @@
 # frozen_string_literal: true
 
+require_relative '../catalog'
+require_relative '../catalog-util/fileresources'
+
 require 'json'
 
 module OctocatalogDiff
   class Catalog
     # Represents a Puppet catalog that is read in directly from a JSON file.
-    class JSON
-      attr_accessor :node
-      attr_reader :error_message, :catalog, :catalog_json
-
+    class JSON < OctocatalogDiff::Catalog
       # Constructor
       # @param :json [String] REQUIRED: Content of catalog, will be parsed as JSON
       # @param :node [String] Node name (if not supplied, will be determined from catalog)
       def initialize(options)
-        raise ArgumentError, 'Usage: OctocatalogDiff::Catalog::JSON.initialize(options_hash)' unless options.is_a?(Hash)
+        super
         raise ArgumentError, "Must supply :json as string in options: #{options[:json].class}" unless options[:json].is_a?(String)
-        @catalog_json = options[:json]
+
+        @catalog_json = options.fetch(:json)
         begin
           @catalog = ::JSON.parse(@catalog_json)
           @error_message = nil
@@ -27,6 +28,11 @@ def initialize(options)
           @catalog_json = nil
         end
       end
+
+      # Convert file source => ... to content => ... if a basedir is given.
+      def convert_file_resources(logger = Logger.new(StringIO.new))
+        convert_file_resources_real(logger)
+      end
     end
   end
 end