quixoten-puppetdb-terminus 3.2.4 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 910dde6a5e9dd41e559bccccafa56f87803d3102
-  data.tar.gz: fe5dac1f457c8fae51a09a75f1d9597c042f5a3d
+  metadata.gz: 4470280424f9b67fc3543f3009a0f91916257ff4
+  data.tar.gz: 7bfa68983d4a6f301b16250e78019299e5d2d88f
 SHA512:
-  metadata.gz: ad7d999498f478abf34e4a91549211e749d092f94136c25cee2d64eb3d212a13ad2dfe2ec8564909f3e579067eb8f568a9b03e30cc9369f559a6914cda3080ba
-  data.tar.gz: 52a1d74294eedb0a0970bc7e0a41af0f15ff9bd76c7610803a911b7d48490a2966cdb95ddac9380c9245b653c24c9816bcd3ad916843269cb70d7a5c14cabbd4
+  metadata.gz: 11c510c0300fc56d183a5c8a80322cd16115111e45c4cf238ffdb842bb9de465aab2ae84199b356bae065a8167fef637290b65ff724820b394e8099018f7574f
+  data.tar.gz: 670591770ccaebb59f44f00fdcb7e7e5ec3969c878845edcb47599e6094cc89221977084585a45b7f1b7926d3c3d48514663c17de4f323857357da65baa57cd1

data/lib/puppet/face/node/status.rb

@@ -19,7 +19,7 @@ Puppet::Face.define(:node, '0.0.1') do
 
       args.map do |node|
         begin
-          response = Puppet::Util::Puppetdb::Http.action("/pdb/query/v4/nodes/#{CGI.escape(node)}") do |http_instance, path|
+          response = Puppet::Util::Puppetdb::Http.action("/pdb/query/v4/nodes/#{CGI.escape(node)}", :query) do |http_instance, path|
              http_instance.get(path, headers)
           end
           if response.is_a? Net::HTTPSuccess

data/lib/puppet/functions/puppetdb_query.rb

@@ -0,0 +1,6 @@
+require 'puppet/util/puppetdb'
+Puppet::Functions.create_function(:puppetdb_query) do
+  def puppetdb_query(query)
+    Puppet::Util::Puppetdb.query_puppetdb(query)
+  end
+end

data/lib/puppet/indirector/catalog/puppetdb.rb

@@ -10,7 +10,7 @@ class Puppet::Resource::Catalog::Puppetdb < Puppet::Indirector::REST
   def save(request)
     profile("catalog#save", [:puppetdb, :catalog, :save, request.key]) do
       catalog = munge_catalog(request.instance, extract_extra_request_data(request))
-      submit_command(request.key, catalog, CommandReplaceCatalog, 7)
+      submit_command(request.key, catalog, CommandReplaceCatalog, 8)
     end
   end
 
@@ -24,7 +24,6 @@ class Puppet::Resource::Catalog::Puppetdb < Puppet::Indirector::REST
       :transaction_uuid => request.options[:transaction_uuid],
       :environment => request.environment.to_s,
       :producer_timestamp => request.options[:producer_timestamp] || Time.now.iso8601(5),
-      :code_id => request.options[:code_id],
     }
   end
 
@@ -39,6 +38,8 @@ class Puppet::Resource::Catalog::Puppetdb < Puppet::Indirector::REST
         catalog.to_data_hash
       end
 
+      add_code_id_if_missing(data)
+      add_catalog_uuid_if_missing(data, extra_request_data[:transaction_uuid])
       add_parameters_if_missing(data)
       add_namevar_aliases(data, catalog)
       stringify_titles(data)
@@ -47,12 +48,11 @@ class Puppet::Resource::Catalog::Puppetdb < Puppet::Indirector::REST
       sort_unordered_metaparams(data)
       munge_edges(data)
       synthesize_edges(data, catalog)
+      change_name_to_certname(data)
       filter_keys(data)
       add_transaction_uuid(data, extra_request_data[:transaction_uuid])
       add_environment(data, extra_request_data[:environment])
       add_producer_timestamp(data, extra_request_data[:producer_timestamp])
-      change_name_to_certname(data)
-      add_code_id(data, extra_request_data[:code_id])
 
       data
     end
@@ -119,11 +119,25 @@ class Puppet::Resource::Catalog::Puppetdb < Puppet::Indirector::REST
   # Include code_id in hash, returning the complete hash.
   #
   # @param hash [Hash] original data hash
-  # @param code_id [String] code_id
-  # @return [Hash] returns original hash augmented with transaction_uuid
+  # @return [Hash] returns original hash with a gaurunteed code_id key
+  # @api private
+  def add_code_id_if_missing(hash)
+    # This weird code ensure that `hash` will always have a `code_id` key and if
+    # it already had a `code_id` key we use that as the value. If `hash` didn't
+    # have a `code_id` key the lookup will return nil and hash['code_id'] == nil
+    hash['code_id'] = hash['code_id']
+
+    hash
+  end
+
+  # Include code_id in hash, returning the complete hash.
+  #
+  # @param hash [Hash] original data hash
+  # @param default [String] default catalog_uuid to use if hash doesn't have one
+  # @return [Hash] returns original hash with a gaurunteed catalog_uuid key/value
   # @api private
-  def add_code_id(hash, code_id)
-    hash['code_id'] = code_id
+  def add_catalog_uuid_if_missing(hash, default)
+    hash['catalog_uuid'] = hash['catalog_uuid'] || default
 
     hash
   end
@@ -305,7 +319,7 @@ class Puppet::Resource::Catalog::Puppetdb < Puppet::Indirector::REST
                 # case problem here: http://projects.puppetlabs.com/issues/19474
                 # Once that problem is solved and older versions of Puppet that have
                 # the bug are no longer supported we can probably remove this code.
-                unless other_ref =~ /^[A-Z][a-z0-9_-]*(::[A-Z][a-z0-9_-]*)*\[.*\]/m
+                unless other_ref =~ /^[A-Z][a-z0-9_]*(::[A-Z][a-z0-9_]*)*\[.*\]/m
                   rel = edge_to_s(resource_hash_to_ref(resource_hash), other_ref, param)
                   raise Puppet::Error, "Invalid relationship: #{rel}, because " +
                     "#{other_ref} doesn't seem to be in the correct format. " +
@@ -380,7 +394,12 @@ class Puppet::Resource::Catalog::Puppetdb < Puppet::Indirector::REST
     profile("Filter extraneous keys from the catalog",
             [:puppetdb, :keys, :filter_extraneous]) do
       hash.delete_if do |k,v|
-        ! ['name', 'version', 'edges', 'resources'].include?(k)
+        ! ['certname',
+           'version',
+           'edges',
+           'resources',
+           'code_id',
+           'catalog_uuid'].include?(k)
       end
     end
   end

data/lib/puppet/indirector/facts/puppetdb.rb

@@ -16,24 +16,13 @@ class Puppet::Node::Facts::Puppetdb < Puppet::Indirector::REST
     trusted.to_h
   end
 
-  def maybe_strip_internal(facts)
-    if Puppet::Node::Facts.method_defined? :strip_internal
-      facts.strip_internal
-    else
-      facts.values
-    end
-  end
-
   def save(request)
     profile("facts#save", [:puppetdb, :facts, :save, request.key]) do
       payload = profile("Encode facts command submission payload",
                         [:puppetdb, :facts, :encode]) do
         facts = request.instance.dup
-        facts.values = facts.strip_internal.dup
-
-        if ! Puppet::Util::Puppetdb.puppet3compat? || Puppet[:trusted_node_data]
-          facts.values[:trusted] = get_trusted_info(request.node)
-        end
+        facts.values = facts.values.dup
+        facts.values[:trusted] = get_trusted_info(request.node)
         {
           "certname" => facts.name,
           "values" => facts.values,
@@ -52,7 +41,7 @@ class Puppet::Node::Facts::Puppetdb < Puppet::Indirector::REST
   def find(request)
     profile("facts#find", [:puppetdb, :facts, :find, request.key]) do
       begin
-        response = Http.action("/pdb/query/v4/nodes/#{CGI.escape(request.key)}/facts") do |http_instance, path|
+        response = Http.action("/pdb/query/v4/nodes/#{CGI.escape(request.key)}/facts", :query) do |http_instance, path|
           profile("Query for nodes facts: #{URI.unescape(path)}",
                   [:puppetdb, :facts, :find, :query_nodes, request.key]) do
             http_instance.get(path, headers)
@@ -120,7 +109,7 @@ class Puppet::Node::Facts::Puppetdb < Puppet::Indirector::REST
       query_param = CGI.escape(query.to_json)
 
       begin
-        response = Http.action("/pdb/query/v4/nodes?query=#{query_param}") do |http_instance, path|
+        response = Http.action("/pdb/query/v4/nodes?query=#{query_param}", :query) do |http_instance, path|
           profile("Fact query request: #{URI.unescape(path)}",
                   [:puppetdb, :facts, :search, :query_request, request.key]) do
             http_instance.get(path, headers)

data/lib/puppet/indirector/resource/puppetdb.rb

@@ -27,7 +27,7 @@ class Puppet::Resource::Puppetdb < Puppet::Indirector::REST
       query_param = CGI.escape(expr.to_json)
 
       begin
-        response = Http.action("/pdb/query/v4/resources?query=#{query_param}") do |http_instance, path|
+        response = Http.action("/pdb/query/v4/resources?query=#{query_param}", :query) do |http_instance, path|
           profile("Resources query: #{URI.unescape(path)}",
                   [:puppetdb, :resource, :search, :query, request.key]) do
             http_instance.get(path, headers)

data/lib/puppet/reports/puppetdb.rb

@@ -19,7 +19,7 @@ Puppet::Reports.register_report(:puppetdb) do
   # @return [void]
   def process
     profile("report#process", [:puppetdb, :report, :process]) do
-      submit_command(self.host, report_to_hash, CommandStoreReport, 6)
+      submit_command(self.host, report_to_hash, CommandStoreReport, 7)
     end
 
     nil
@@ -40,21 +40,28 @@ Puppet::Reports.register_report(:puppetdb) do
       resources = build_resources_list
       is_noop = resources.any? { |rs| has_noop_event?(rs) } and resources.none? { |rs| has_failed_event?(rs) }
 
+
+      defaulted_catalog_uuid = defined?(catalog_uuid) ? catalog_uuid : transaction_uuid
+      defaulted_code_id = defined?(code_id) ? code_id : nil
+      defaulted_cached_catalog_status = defined?(cached_catalog_status) ? cached_catalog_status : nil
       {
-        "certname"                => host,
-        "puppet_version"          => puppet_version,
-        "report_format"           => report_format,
-        "configuration_version"   => configuration_version.to_s,
-        "producer_timestamp"      => Puppet::Util::Puppetdb.to_wire_time(Time.now),
-        "start_time"              => Puppet::Util::Puppetdb.to_wire_time(time),
-        "end_time"                => Puppet::Util::Puppetdb.to_wire_time(time + run_duration),
-        "environment"             => environment,
-        "transaction_uuid"        => transaction_uuid,
-        "status"                  => status,
-        "noop"                    => is_noop,
-        "logs"                    => build_logs_list,
-        "metrics"                 => build_metrics_list,
-        "resources"               => resources,
+        "certname" => host,
+        "puppet_version" => puppet_version,
+        "report_format" => report_format,
+        "configuration_version" => configuration_version.to_s,
+        "producer_timestamp" => Puppet::Util::Puppetdb.to_wire_time(Time.now),
+        "start_time" => Puppet::Util::Puppetdb.to_wire_time(time),
+        "end_time" => Puppet::Util::Puppetdb.to_wire_time(time + run_duration),
+        "environment" => environment,
+        "transaction_uuid" => transaction_uuid,
+        "status" => status,
+        "noop" => is_noop,
+        "logs" => build_logs_list,
+        "metrics" => build_metrics_list,
+        "resources" => resources,
+        "catalog_uuid" => defaulted_catalog_uuid,
+        "code_id" => defaulted_code_id,
+        "cached_catalog_status" => defaulted_cached_catalog_status,
       }
     end
   end

data/lib/puppet/util/puppetdb.rb

@@ -6,6 +6,7 @@ require 'puppet/util/puppetdb/command'
 require 'puppet/util/puppetdb/config'
 require 'digest/sha1'
 require 'time'
+require 'json'
 require 'fileutils'
 
 module Puppet::Util::Puppetdb
@@ -28,10 +29,6 @@ module Puppet::Util::Puppetdb
     @config
   end
 
-  def self.puppet3compat?
-    defined?(Puppet::Parser::AST::HashOrArrayAccess)
-  end
-
   # Given an instance of ruby's Time class, this method converts it to a String
   # that conforms to PuppetDB's wire format for representing a date/time.
   def self.to_wire_time(time)
@@ -68,6 +65,21 @@ module Puppet::Util::Puppetdb
     end
   end
 
+  # Query PuppetDB.
+  #
+  # @param query [String, Array] The PQL or AST query for PuppetDB
+  # @return [Array<Hash>]
+  def self.query_puppetdb(query)
+    Puppet::Util::Profiler.profile("Submitted query '#{query}'", [:puppetdb, :query, query]) do
+      headers = { "Accept" => "application/json",
+                  "Content-Type" => "application/json; charset=UTF-8" }
+      response = Puppet::Util::Puppetdb::Http.action("/pdb/query/v4", :query) do |http_instance, path|
+        http_instance.post(path, { 'query' => query }.to_json, headers)
+      end
+      JSON.parse(response.body)
+    end
+  end
+
   # Profile a block of code and log the time it took to execute.
   #
   # This outputs logs entries to the Puppet masters logging destination

data/lib/puppet/util/puppetdb/atom.rb

@@ -0,0 +1,22 @@
+require 'thread'
+
+module Puppet::Util::Puppetdb
+  class Atom
+    def initialize(value)
+      @value = value
+      @mutex = Mutex.new
+    end
+
+    def deref()
+      @mutex.synchronize {
+        @value
+      }
+    end
+
+    def reset(value)
+      @mutex.synchronize {
+        @value = value
+      }
+    end
+  end
+end

data/lib/puppet/util/puppetdb/char_encoding.rb

@@ -65,7 +65,7 @@ module CharEncoding
   # @param bad_char_range a range indicating a block of invalid characters
   # @return String
   def self.error_char_context(str, bad_char_range)
-    
+
     gap = bad_char_range.to_a.length
 
     start_char = [0, bad_char_range.begin-100].max
@@ -106,9 +106,10 @@ module CharEncoding
   # information using error_context_str
   #
   # @param str A string coming from to_pson, likely a command to be submitted to PDB
-  # @param error_context_str information about where this string came from for use in error messages
+  # @param error_context_str information about where this string came from for
+  # use in error messages. Defaults to nil, in which case no error is reported.
   # @return Str
-  def self.coerce_to_utf8(str, error_context_str)
+  def self.coerce_to_utf8(str, error_context_str=nil)
     str_copy = str.dup
     # This code is passed in a string that was created by
     # to_pson. to_pson calls force_encoding('ASCII-8BIT') on the
@@ -127,30 +128,27 @@ module CharEncoding
       # byte related issues that could arise from mis-interpreting a
       # random extra byte as part of a multi-byte UTF-8 character
       str_copy.force_encoding("US-ASCII")
-      warn_if_invalid_chars(str_copy.encode!("UTF-8",
-                                             :invalid => :replace,
-                                             :undef => :replace,
-                                             :replace => DEFAULT_INVALID_CHAR),
-                            error_context_str)
+
+      str_lossy = str_copy.encode!("UTF-8",
+                                   :invalid => :replace,
+                                   :undef => :replace,
+                                   :replace => DEFAULT_INVALID_CHAR)
+      if !error_context_str.nil?
+        warn_if_invalid_chars(str_lossy, error_context_str)
+      else
+        str_lossy
+      end
     end
   end
 
   def self.utf8_string(str, error_context_str)
-    if RUBY_VERSION =~ /^1.8/
-      # Ruby 1.8 doesn't have String#encode and related methods, and there
-      #  appears to be a bug in iconv that will interpret some byte sequences
-      #  as 6-byte characters.  Thus, we are forced to resort to some unfortunate
-      #  manual chicanery.
-      warn_if_changed(str, ruby18_clean_utf8(str))
-    else
-      begin
-        coerce_to_utf8(str, error_context_str)
-      rescue Encoding::InvalidByteSequenceError, Encoding::UndefinedConversionError => e
-          # If we got an exception, the string is either invalid or not
-          # convertible to UTF-8, so drop those bytes.
+    begin
+      coerce_to_utf8(str, error_context_str)
+    rescue Encoding::InvalidByteSequenceError, Encoding::UndefinedConversionError => e
+      # If we got an exception, the string is either invalid or not
+      # convertible to UTF-8, so drop those bytes.
 
-        warn_if_changed(str, str.encode('UTF-8', :invalid => :replace, :undef => :replace))
-      end
+      warn_if_changed(str, str.encode('UTF-8', :invalid => :replace, :undef => :replace))
     end
   end
 
@@ -162,137 +160,6 @@ module CharEncoding
     converted_str
   end
 
-  # @api private
-  def self.ruby18_clean_utf8(str)
-    #iconv_to_utf8(str)
-    #ruby18_manually_clean_utf8(str)
-
-    # So, we've tried doing this UTF8 cleaning for ruby 1.8 a few different
-    # ways.  Doing it via IConv, we don't do a good job of handling characters
-    # whose codepoints would exceed the legal maximum for UTF-8.  Doing it via
-    # our manual scrubbing process is slower and doesn't catch overlong
-    # encodings.  Since this code really shouldn't even exist in the first place
-    # we've decided to simply compose the two scrubbing methods for now, rather
-    # than trying to add detection of overlong encodings.  It'd be a non-trivial
-    # chunk of code, and it'd have to do a lot of bitwise arithmetic (which Ruby
-    # is not blazingly fast at).
-    ruby18_manually_clean_utf8(iconv_to_utf8(str))
-  end
-
-
-  # @todo we're not using this anymore, but I wanted to leave it around
-  #  for a little while just to make sure that the new code pans out.
-  # @api private
-  def self.iconv_to_utf8(str)
-    iconv = Iconv.new('UTF-8//IGNORE', 'UTF-8')
-
-    # http://po-ru.com/diary/fixing-invalid-utf-8-in-ruby-revisited/
-    iconv.iconv(str + " ")[0..-2]
-  end
-
-  # @api private
-  def self.get_char_len(byte)
-    Utf8CharLens[byte]
-  end
-
-  # Manually cleans a string by stripping any byte sequences that are
-  # not valid UTF-8 characters.  If you'd prefer for the invalid bytes to be
-  # replaced with the unicode replacement character rather than being stripped,
-  # you may pass `false` for the optional second parameter (`strip`, which
-  # defaults to `true`).
-  #
-  # @api private
-  def self.ruby18_manually_clean_utf8(str, strip = true)
-
-    # This is a hack to allow this code to work with either ruby 1.8 or 1.9,
-    # which is useful for debugging and benchmarking.  For more info see the
-    # comments in the #get_byte method below.
-    @has_get_byte = str.respond_to?(:getbyte)
-
-
-    i = 0
-    len = str.length
-    result = ""
-
-    while i < len
-      byte = get_byte(str, i)
-
-      i += 1
-
-      char_len = get_char_len(byte)
-      case char_len
-      when 0
-        result.concat(Utf8ReplacementChar) unless strip
-      when 1
-        result << byte
-      when 2..4
-        ruby18_handle_multibyte_char(result, byte, str, i,  char_len, strip)
-        i += char_len - 1
-      else
-        raise Puppet::DevError, "Unhandled UTF8 char length: '#{char_len}'"
-      end
-
-    end
-
-    result
-  end
-
-  # @api private
-  def self.ruby18_handle_multibyte_char(result_str, byte, str, i, char_len, strip = true)
-    # keeping an array of bytes for now because we need to do some
-    #  bitwise math on them.
-    char_additional_bytes = []
-
-    # If we don't have enough bytes left to read the full character, we
-    #  put on a replacement character and bail.
-    if i + (char_len - 1) > str.length
-      result_str.concat(Utf8ReplacementChar) unless strip
-      return
-    end
-
-    # we've already read the first byte, so we need to set up a range
-    #  from 0 to (n-2); e.g. if it's a 2-byte char, we will have a range
-    #  from 0 to 0 which will result in reading 1 more byte
-    (0..char_len - 2).each do |x|
-      char_additional_bytes << get_byte(str, i + x)
-    end
-
-    if (is_valid_multibyte_suffix(byte, char_additional_bytes))
-      result_str << byte
-      result_str.concat(char_additional_bytes.pack("c*"))
-    else
-      result_str.concat(Utf8ReplacementChar) unless strip
-    end
-  end
-
-  # @api private
-  def self.is_valid_multibyte_suffix(byte, additional_bytes)
-    # This is heinous, but the UTF-8 spec says that codepoints greater than
-    #  0x10FFFF are illegal.  The first character that is over that limit is
-    #  0xF490bfbf, so if the first byte is F4 then we have to check for
-    #  that condition.
-    if byte == 0xF4
-      val = additional_bytes.inject(0) { |result, b | (result << 8) + b}
-      if val >= 0x90bfbf
-        return false
-      end
-    end
-    additional_bytes.all? { |b| ((b & 0xC0) == 0x80) }
-  end
-
-  # @api private
-  def self.get_byte(str, index)
-    # This method is a hack to allow this code to work with either ruby 1.8
-    #  or 1.9.  In production this code path should never be exercised by
-    #  1.9 because it has a much more sane way to accomplish our goal, but
-    #  for testing, it is useful to be able to run the 1.8 codepath in 1.9.
-    if @has_get_byte
-      str.getbyte(index)
-    else
-      str[index]
-    end
-  end
-
 end
 end
 end

data/lib/puppet/util/puppetdb/command.rb

@@ -24,13 +24,11 @@ class Puppet::Util::Puppetdb::Command
   #   primitive (numeric type, string, array, or hash) that is natively supported
   #   by JSON serialization / deserialization libraries.
   def initialize(command, version, certname, payload)
-    @command = command
-    @version = version
-    @certname = certname
     profile("Format payload", [:puppetdb, :payload, :format]) do
-      @payload = Puppet::Util::Puppetdb::CharEncoding.utf8_string({
+      @checksum_payload = Puppet::Util::Puppetdb::CharEncoding.utf8_string({
         :command => command,
         :version => version,
+        :certname => certname,
         :payload => payload,
       # We use to_pson still here, to work around the support for shifting
       # binary data from a catalog to PuppetDB. Attempting to use to_json
@@ -44,21 +42,25 @@ class Puppet::Util::Puppetdb::Command
       # Puppet 4.1.0. We need a better answer to non-utf8 data end-to-end.
       }.to_pson, "Error encoding a '#{command}' command for host '#{certname}'")
     end
+    @command = Puppet::Util::Puppetdb::CharEncoding.coerce_to_utf8(command).gsub(" ", "_")
+    @version = version
+    @certname = Puppet::Util::Puppetdb::CharEncoding.coerce_to_utf8(certname)
+    @payload = Puppet::Util::Puppetdb::CharEncoding.coerce_to_utf8(payload.to_pson)
   end
 
-  attr_reader :command, :version, :certname, :payload
+  attr_reader :command, :version, :certname, :payload, :checksum_payload
 
   # Submit the command, returning the result hash.
   #
   # @return [Hash <String, String>]
   def submit
-    checksum = Digest::SHA1.hexdigest(payload)
+    checksum = Digest::SHA1.hexdigest(checksum_payload)
 
     for_whom = " for #{certname}" if certname
-
+    params = "checksum=#{checksum}&version=#{version}&certname=#{certname}&command=#{command}"
     begin
       response = profile("Submit command HTTP post", [:puppetdb, :command, :submit]) do
-        Http.action("#{CommandsUrl}?checksum=#{checksum}") do |http_instance, path|
+        Http.action("#{CommandsUrl}?#{params}", :command) do |http_instance, path|
           http_instance.post(path, payload, headers)
         end
       end

data/lib/puppet/util/puppetdb/config.rb

@@ -9,11 +9,14 @@ module Puppet::Util::Puppetdb
 
     def self.load(config_file = nil)
       defaults = {
-        :server                    => "puppetdb",
-        :port                      => 8081,
-        :soft_write_failure        => false,
-        :server_url_timeout        => 30,
+        :server_urls                 => "https://puppetdb:8081",
+        :soft_write_failure          => false,
+        :server_url_timeout          => 30,
         :include_unchanged_resources => false,
+        :min_successful_submissions => 1,
+        :submit_only_server_urls   => "",
+        :command_broadcast         => false,
+        :sticky_read_failover      => false
       }
 
       config_file ||= File.join(Puppet[:confdir], "puppetdb.conf")
@@ -22,7 +25,7 @@ module Puppet::Util::Puppetdb
         Puppet.debug("Configuring PuppetDB terminuses with config file #{config_file}")
         content = File.read(config_file)
       else
-        Puppet.debug("No #{config_file} file found; falling back to default server and port #{defaults[:server]}:#{defaults[:port]}")
+        Puppet.debug("No #{config_file} file found; falling back to default server_urls #{defaults[:server_urls]}")
         content = ''
       end
 
@@ -51,31 +54,53 @@ module Puppet::Util::Puppetdb
       main_section = result['main'] || {}
       # symbolize the keys
       main_section = main_section.inject({}) {|h, (k,v)| h[k.to_sym] = v ; h}
+
       # merge with defaults but filter out anything except the legal settings
       config_hash = defaults.merge(main_section).reject do |k, v|
-        !([:server,
-           :port,
+        !([:server_urls,
            :ignore_blacklisted_events,
            :include_unchanged_resources,
            :soft_write_failure,
-           :server_urls,
-           :server_url_timeout].include?(k))
+           :server_url_timeout,
+           :min_successful_submissions,
+           :submit_only_server_urls,
+           :command_broadcast,
+           :sticky_read_failover].include?(k))
       end
 
-      if config_hash[:server_urls]
-        uses_server_urls = true
-        config_hash[:server_urls] = config_hash[:server_urls].split(",").map {|s| s.strip}
-      else
-        uses_server_urls = false
-        config_hash[:server_urls] = ["https://#{config_hash[:server].strip}:#{config_hash[:port].to_s}"]
-      end
-      config_hash[:server_urls] = convert_and_validate_urls(config_hash[:server_urls])
+      parsed_urls = config_hash[:server_urls].split(",").map {|s| s.strip}
+      config_hash[:server_urls] = convert_and_validate_urls(parsed_urls)
 
       config_hash[:server_url_timeout] = config_hash[:server_url_timeout].to_i
       config_hash[:include_unchanged_resources] = Puppet::Util::Puppetdb.to_bool(config_hash[:include_unchanged_resources])
       config_hash[:soft_write_failure] = Puppet::Util::Puppetdb.to_bool(config_hash[:soft_write_failure])
 
-      self.new(config_hash, uses_server_urls)
+      config_hash[:submit_only_server_urls] = convert_and_validate_urls(config_hash[:submit_only_server_urls].split(",").map {|s| s.strip})
+      config_hash[:min_successful_submissions] = config_hash[:min_successful_submissions].to_i
+      config_hash[:command_broadcast] = Puppet::Util::Puppetdb.to_bool(config_hash[:command_broadcast])
+      config_hash[:sticky_read_failover] = Puppet::Util::Puppetdb.to_bool(config_hash[:sticky_read_failover])
+
+      if config_hash[:soft_write_failure] and config_hash[:min_successful_submissions] > 1
+        raise "soft_write_failure cannot be enabled when min_successful_submissions is greater than 1"
+      end
+
+      overlapping_server_urls = config_hash[:server_urls] & config_hash[:submit_only_server_urls]
+      if overlapping_server_urls.length > 0
+        overlapping_server_urls_strs = overlapping_server_urls.map { |u| u.to_s }
+        raise "Server URLs must be in either server_urls or submit_only_server_urls, not both. "\
+          "(#{overlapping_server_urls_strs.to_s} are in both)"
+      end
+
+      if config_hash[:min_successful_submissions] > 1 and not config_hash[:command_broadcast]
+        raise "command_broadcast must be set to true to use min_successful_submissions"
+      end
+
+      if config_hash[:min_successful_submissions] > config_hash[:server_urls].length
+        raise "min_successful_submissions (#{config_hash[:min_successful_submissions]}) must be less than "\
+          "or equal to the number of server_urls (#{config_hash[:server_urls].length})"
+      end
+
+      self.new(config_hash)
     rescue => detail
       Puppet.warning "Could not configure PuppetDB terminuses: #{detail}"
       Puppet.warning detail.backtrace if Puppet[:trace]
@@ -84,21 +109,8 @@ module Puppet::Util::Puppetdb
 
     # @!group Public instance methods
 
-    def initialize(config_hash = {}, uses_server_urls=nil)
+    def initialize(config_hash = {})
       @config = config_hash
-      if !uses_server_urls
-        Puppet.warning("Specification of server and port in puppetdb.conf is deprecated. Use the setting server_urls.")
-      end
-      # To provide accurate error messages to users about HTTP failures, we
-      # need to know whether they initially defined their config via the old
-      # server/port combo or the new server_urls. This boolean keeps track
-      # of how the user defined that config so that we can give them a
-      # better error message
-      @server_url_config = uses_server_urls
-    end
-
-    def server_url_config?
-      @server_url_config
     end
 
     def server_urls
@@ -117,6 +129,22 @@ module Puppet::Util::Puppetdb
       config[:soft_write_failure]
     end
 
+    def min_successful_submissions
+      config[:min_successful_submissions]
+    end
+
+    def submit_only_server_urls
+      config[:submit_only_server_urls]
+    end
+
+    def command_broadcast
+      config[:command_broadcast]
+    end
+
+    def sticky_read_failover
+      config[:sticky_read_failover]
+    end
+
     # @!group Private instance methods
 
     # @!attribute [r] count

data/lib/puppet/util/puppetdb/http.rb

@@ -3,14 +3,17 @@ require 'puppet/network/http_pool'
 require 'net/http'
 require 'timeout'
 require 'pp'
+require 'thread'
+require 'puppet/util/puppetdb/atom'
 
 module Puppet::Util::Puppetdb
   class Http
+    SERVER_URL_FAIL_MSG = "Failing over to the next PuppetDB server_url in the 'server_urls' list"
 
-    SERVER_URL_FAIL_MSG = "Failing over to the next PuppetDB url in the 'server_urls' list"
+    @@last_good_query_server_url_index = Atom.new(0)
 
-    # Concat two url snippets, taking into account a trailing/leading slash to
-    # ensure a correct url is constructed
+    # Concat two server_url snippets, taking into account a trailing/leading slash to
+    # ensure a correct server_url is constructed
     #
     # @param snippet1 [String] first URL snippet
     # @param snippet2 [String] second URL snippet
@@ -26,94 +29,199 @@ module Puppet::Util::Puppetdb
       end
     end
 
-    # Setup an http connection, provide a block that will do something with that http
-    # connection. The block should be a two argument block, accepting the connection (which
-    # you can call get or post on for example) and the properly constructed path, which
-    # will be the concatenated version of any url_prefix and the path passed in.
-    #
-    # @param path_suffix [String] path for the get/post of the http action
-    # @param http_callback [Proc] proc containing the code calling the action on the http connection
-    # @return [Response] returns http response
-    def self.action(path_suffix, &http_callback)
+    # Run the given block (cb) in a begin/rescue, catching common network
+    # exceptions and logging useful information about them. If an expected
+    # exception was caught, it's returned. An unexpected exception will be
+    # re-thrown. Returns nil on success.
+    def self.with_http_error_logging(server_url, route, &cb)
+      config = Puppet::Util::Puppetdb.config
 
+      begin
+        cb.call()
+      rescue Timeout::Error => e
+        Puppet.warning("Request to #{server_url.host} on #{server_url.port} at route #{route} timed out " \
+          "after #{config.server_url_timeout} seconds. #{SERVER_URL_FAIL_MSG}")
+        return e
+
+      rescue SocketError, OpenSSL::SSL::SSLError, SystemCallError, Net::ProtocolError, IOError, Net::HTTPNotFound => e
+        Puppet.warning("Error connecting to #{server_url.host} on #{server_url.port} at route #{route}, " \
+          "error message received was '#{e.message}'. #{SERVER_URL_FAIL_MSG}")
+        return e
+
+      rescue Puppet::Util::Puppetdb::InventorySearchError => e
+        Puppet.warning("Could not perform inventory search from PuppetDB at #{server_url.host}:#{server_url.port}: " \
+          "'#{e.message}' #{SERVER_URL_FAIL_MSG}")
+        return e
+
+      rescue Puppet::Util::Puppetdb::CommandSubmissionError => e
+        error = "Failed to submit '#{e.context[:command]}' command for '#{e.context[:for_whom]}' to PuppetDB " \
+          "at #{server_url.host}:#{server_url.port}: '#{e.message}'."
+        if config.soft_write_failure
+          Puppet.err error
+        else
+          Puppet.warning(error + " #{SERVER_URL_FAIL_MSG}")
+        end
+        return e
+
+      rescue Puppet::Util::Puppetdb::SoftWriteFailError => e
+        Puppet.warning("Failed to submit '#{e.context[:command]}' command for '#{e.context[:for_whom]}' to PuppetDB " \
+          "at #{server_url.host}:#{server_url.port}: '#{e.message}' #{SERVER_URL_FAIL_MSG}")
+        return e
+
+      rescue Puppet::Error => e
+        if e.message =~ /did not match server certificate; expected one of/
+          Puppet.warning("Error connecting to #{server_url.host} on #{server_url.port} at route #{route}, " \
+            "error message received was '#{e.message}'. #{SERVER_URL_FAIL_MSG}")
+          return e
+        else
+          raise
+        end
+      end
+
+      nil
+    end
+
+    # Check an http reponse from puppetdb; log a useful message if it looks like
+    # something went wrong. Return a symbol indicating the problem
+    # (:server_error, :notfound, or :other_404), or nil if there wasn't one.
+    def self.check_http_response(response, server_url, route)
+      if response.is_a? Net::HTTPServerError
+        Puppet.warning("Error connecting to #{server_url.host} on #{server_url.port} at route #{route}, " \
+          "error message received was '#{response.message}'. #{SERVER_URL_FAIL_MSG}")
+        :server_error
+      elsif response.is_a? Net::HTTPNotFound
+        if response.body && response.body.chars.first == "{"
+          # If it appears to be json, we've probably gotten an authentic 'not found' message.
+          Puppet.debug("HTTP 404 (probably normal) when connecting to #{server_url.host} on #{server_url.port} " \
+            "at route #{route}, error message received was '#{response.message}'. #{SERVER_URL_FAIL_MSG}")
+          :notfound
+        else
+          # But we can also get 404s when conneting to a puppetdb that's still starting or due to misconfiguration.
+          Puppet.warning("Error connecting to #{server_url.host} on #{server_url.port} at route #{route}, " \
+            "error message received was '#{response.message}'. #{SERVER_URL_FAIL_MSG}")
+          :other_404
+        end
+      else
+        nil
+      end
+    end
+
+    def self.raise_request_error(response, response_error, path_suffix)
+      server_url_strings = Puppet::Util::Puppetdb.config.server_urls.map {|server_url| server_url.to_s}.join(', ')
+      if response_error == :notfound
+        raise NotFoundError, "Failed to find '#{path_suffix}' on any of the following 'server_urls': #{server_url_strings}"
+      else
+        min_successful_submissions = Puppet::Util::Puppetdb.config.min_successful_submissions
+        raise Puppet::Error, "Failed to execute '#{path_suffix}' on at least #{min_successful_submissions} of the following 'server_urls': #{server_url_strings}"
+      end
+    end
+
+    def self.failover_action(path_suffix, server_urls, sticky, http_callback)
       response = nil
+      response_error = nil
       config = Puppet::Util::Puppetdb.config
-      server_url_config = config.server_url_config?
+      last_good_index = 0
+
+      if sticky
+        last_good_index = @@last_good_query_server_url_index.deref()
+      end
+
+      server_count = server_urls.length
+      server_try_order = (0...server_count).map { |i| (i + last_good_index) % server_count }
 
-      for url in Puppet::Util::Puppetdb.config.server_urls
-        begin
-          route = concat_url_snippets(url.request_uri, path_suffix)
-          http = Puppet::Network::HttpPool.http_instance(url.host, url.port)
-          request_timeout = config.server_url_timeout
+      for server_url_index in server_try_order
+        server_url = server_urls[server_url_index]
+        route = concat_url_snippets(server_url.request_uri, path_suffix)
 
-          response = timeout(request_timeout) do
+        request_exception = with_http_error_logging(server_url, route) {
+          http = Puppet::Network::HttpPool.http_instance(server_url.host, server_url.port)
+
+          response = Timeout.timeout(config.server_url_timeout) do
             http_callback.call(http, route)
           end
+        }
 
-          if response.is_a? Net::HTTPServerError
-            Puppet.warning("Error connecting to #{url.host} on #{url.port} at route #{route}, error message received was '#{response.message}'. #{SERVER_URL_FAIL_MSG if server_url_config}")
-            response = nil
-          elsif response.is_a? Net::HTTPNotFound
-            if response.body && response.body.chars.first == "{"
-              # If it appears to be json, we've probably gotten an authentic 'not found' message.
-              Puppet.debug("HTTP 404 (probably normal) when connecting to #{url.host} on #{url.port} at route #{route}, error message received was '#{response.message}'. #{SERVER_URL_FAIL_MSG if server_url_config}")
-              response = :notfound
-            else
-              # But we can also get 404s when conneting to a puppetdb that's still starting or due to misconfiguration.
-              Puppet.warning("Error connecting to #{url.host} on #{url.port} at route #{route}, error message received was '#{response.message}'. #{SERVER_URL_FAIL_MSG if server_url_config}")
-              response = nil
+        if request_exception.nil?
+          response_error = check_http_response(response, server_url, route)
+          if response_error.nil?
+            if server_url_index != server_try_order.first()
+              @@last_good_query_server_url_index.reset(server_url_index)
             end
-          else
             break
           end
-        rescue Timeout::Error => e
-          Puppet.warning("Request to #{url.host} on #{url.port} at route #{route} timed out after #{request_timeout} seconds. #{SERVER_URL_FAIL_MSG if server_url_config}")
+        end
+      end
+
+      if response.nil? or not(response_error.nil?)
+        raise_request_error(response, response_error, path_suffix)
+      end
+
+      response
+    end
+
+    def self.broadcast_action(path_suffix, server_urls, http_callback)
+      response = nil
+      response_error = nil
+      config = Puppet::Util::Puppetdb.config
+      successful_submit_count = 0
 
-        rescue SocketError, OpenSSL::SSL::SSLError, SystemCallError, Net::ProtocolError, IOError, Net::HTTPNotFound => e
-          Puppet.warning("Error connecting to #{url.host} on #{url.port} at route #{route}, error message received was '#{e.message}'. #{SERVER_URL_FAIL_MSG if server_url_config}")
+      for server_url in server_urls
+        route = concat_url_snippets(server_url.request_uri, path_suffix)
 
-        rescue Puppet::Util::Puppetdb::InventorySearchError => e
-          Puppet.warning("Could not perform inventory search from PuppetDB at #{url.host}:#{url.port}: '#{e.message}' #{SERVER_URL_FAIL_MSG if server_url_config}")
+        request_exception = with_http_error_logging(server_url, route) {
+          http = Puppet::Network::HttpPool.http_instance(server_url.host, server_url.port)
 
-        rescue Puppet::Util::Puppetdb::CommandSubmissionError => e
-          error = "Failed to submit '#{e.context[:command]}' command for '#{e.context[:for_whom]}' to PuppetDB at #{url.host}:#{url.port}: '#{e.message}'."
-          if config.soft_write_failure
-            Puppet.err error
-          else
-            Puppet.warning(error + " #{SERVER_URL_FAIL_MSG if server_url_config}")
+          response = Timeout.timeout(config.server_url_timeout) do
+            http_callback.call(http, route)
           end
-        rescue Puppet::Util::Puppetdb::SoftWriteFailError => e
-          Puppet.warning("Failed to submit '#{e.context[:command]}' command for '#{e.context[:for_whom]}' to PuppetDB at #{url.host}:#{url.port}: '#{e.message}' #{SERVER_URL_FAIL_MSG if server_url_config}")
-        rescue Puppet::Error => e
-          if e.message =~ /did not match server certificate; expected one of/
-            Puppet.warning("Error connecting to #{url.host} on #{url.port} at route #{route}, error message received was '#{e.message}'. #{SERVER_URL_FAIL_MSG if server_url_config}")
-          else
-            raise
+        }
+
+        if request_exception.nil?
+          response_error = check_http_response(response, server_url, route)
+          if response_error.nil?
+            successful_submit_count += 1
           end
         end
       end
 
-      if response.nil? or response == :notfound
-        if server_url_config
-          server_url_strings = Puppet::Util::Puppetdb.config.server_urls.map {|url| url.to_s}.join(', ')
-          if response == :notfound
-            raise NotFoundError, "Failed to find '#{path_suffix}' on any of the following 'server_urls': #{server_url_strings}"
-          else
-            raise Puppet::Error, "Failed to execute '#{path_suffix}' on any of the following 'server_urls': #{server_url_strings}"
-          end
-        else
-          uri = Puppet::Util::Puppetdb.config.server_urls.first
-          if response == :notfound
-            raise NotFoundError, "Failed to find '#{path_suffix}' on server: '#{uri.host}' and port: '#{uri.port}'"
-          else
-            raise Puppet::Error, "Failed to execute '#{path_suffix}' on server: '#{uri.host}' and port: '#{uri.port}'"
-          end
-        end
+      if successful_submit_count < config.min_successful_submissions
+        raise_request_error(response, response_error, path_suffix)
       end
 
       response
+    end
 
+    # Setup an http connection, provide a block that will do something with that http
+    # connection. The block should be a two argument block, accepting the connection (which
+    # you can call get or post on for example) and the properly constructed path, which
+    # will be the concatenated version of any url_prefix and the path passed in.
+    #
+    # @param path_suffix [String] path for the get/post of the http action
+    # @param request_type [Symbol] :query or :command
+    # @param http_callback [Proc] proc containing the code calling the action on the http connection
+    # @return [Response] returns http response
+    def self.action(path_suffix, request_mode, &http_callback)
+      config = Puppet::Util::Puppetdb.config
+
+      case request_mode
+      when :query
+        self.failover_action(path_suffix, config.server_urls, config.sticky_read_failover, http_callback)
+      when :command
+        submit_server_urls = config.server_urls + config.submit_only_server_urls
+        if config.command_broadcast
+          self.broadcast_action(path_suffix, submit_server_urls, http_callback)
+        else
+          self.failover_action(path_suffix, submit_server_urls, false, http_callback)
+        end
+      else
+        raise Puppet::Error, "Unknown request mode: #{request_mode}"
+      end
+    end
+
+    def self.reset_query_failover()
+      @@last_good_query_server_url_index.reset(0)
     end
+
   end
 
   class NotFoundError < Puppet::Error

data/lib/puppetdb/terminus/version.rb

@@ -1,6 +1,6 @@
 module PuppetDB
   module Terminus
-    VERSION          = "3.2.4"
+    VERSION          = "4.0.0"
     UPSTREAM_VERSION = VERSION.split(".")[0..2].join(".")
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: quixoten-puppetdb-terminus
 version: !ruby/object:Gem::Version
-  version: 3.2.4
+  version: 4.0.0
 platform: ruby
 authors:
 - Devin Christensen
@@ -50,10 +50,9 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- lib/puppet/application/storeconfigs.rb
 - lib/puppet/face/node/deactivate.rb
 - lib/puppet/face/node/status.rb
-- lib/puppet/face/storeconfigs.rb
+- lib/puppet/functions/puppetdb_query.rb
 - lib/puppet/indirector/catalog/puppetdb.rb
 - lib/puppet/indirector/facts/puppetdb.rb
 - lib/puppet/indirector/facts/puppetdb_apply.rb
@@ -61,6 +60,7 @@ files:
 - lib/puppet/indirector/resource/puppetdb.rb
 - lib/puppet/reports/puppetdb.rb
 - lib/puppet/util/puppetdb.rb
+- lib/puppet/util/puppetdb/atom.rb
 - lib/puppet/util/puppetdb/char_encoding.rb
 - lib/puppet/util/puppetdb/command.rb
 - lib/puppet/util/puppetdb/command_names.rb

data/lib/puppet/application/storeconfigs.rb

@@ -1,4 +0,0 @@
-require 'puppet/application/face_base'
-
-class Puppet::Application::Storeconfigs < Puppet::Application::FaceBase
-end

data/lib/puppet/face/storeconfigs.rb

@@ -1,193 +0,0 @@
-require 'puppet/util/puppetdb'
-require 'puppet/face'
-
-if Puppet::Util::Puppetdb.puppet3compat?
-  require 'tmpdir'
-
-  Puppet::Face.define(:storeconfigs, '0.0.1') do
-    copyright "Puppet Labs", 2011
-    license   "Apache 2 license"
-
-    summary "Interact with the storeconfigs database"
-    description <<-DESC
-    This subcommand interacts with the ActiveRecord storeconfigs database, and
-    can be used to export a dump of that data which is suitable for import by
-    PuppetDB.
-  DESC
-
-    action :export do
-      summary "Export the storeconfigs database"
-      description <<-DESC
-      Generate a dump of all catalogs from the storeconfigs database, as a
-      tarball which can be imported by PuppetDB. Only exported resources are
-      included; non-exported resources, edges, facts, or other data are
-      omitted. Returns the location of the output.
-    DESC
-
-      when_invoked do |options|
-
-        require 'puppet/rails'
-
-        tmpdir = Dir.mktmpdir
-        workdir = File.join(tmpdir, 'puppetdb-bak')
-        Dir.mkdir(workdir)
-
-        begin
-          Puppet::Rails.connect
-
-          timestamp = Time.now
-
-          # Fetch all nodes, including exported resources and their params
-          nodes = Puppet::Rails::Host.all(:include => {:resources => [:param_values, :puppet_tags]},
-                                          :conditions => {:resources => {:exported => true}})
-
-          catalogs = nodes.map { |node| node_to_catalog_hash(node, timestamp.iso8601(5)) }
-
-          catalog_dir = File.join(workdir, 'catalogs')
-          FileUtils.mkdir(catalog_dir)
-
-          catalogs.each do |catalog|
-            filename = File.join(catalog_dir, "#{catalog[:certname]}.json")
-
-            File.open(filename, 'w') do |file|
-              file.puts catalog.to_json
-            end
-          end
-
-          node_names = nodes.map(&:name).sort
-
-          File.open(File.join(workdir, 'export-metadata.json'), 'w') do |file|
-            metadata = {
-              'timestamp' => timestamp,
-              'command_versions' => {
-                'replace_catalog' => 6,
-              }
-            }
-
-            file.puts metadata.to_json
-          end
-
-          tarfile = destination_file(timestamp)
-
-          if tar = Puppet::Util.which('tar')
-            execute("cd #{tmpdir} && #{tar} -cf #{tarfile} puppetdb-bak")
-
-            FileUtils.rm_rf(workdir)
-
-            if gzip = Puppet::Util.which('gzip')
-              execute("#{gzip} #{tarfile}")
-              "#{tarfile}.gz"
-            else
-              Puppet.warning "Can't find the `gzip` command to compress the tarball; output will not be compressed"
-              tarfile
-            end
-          else
-            Puppet.warning "Can't find the `tar` command to produce a tarball; output will remain in the temporary working directory"
-            workdir
-          end
-        rescue => e
-          # Clean up if something goes wrong. We don't want to ensure this,
-          # because we want the directory to stick around in the case where they
-          # don't have tar.
-          FileUtils.rm_rf(workdir)
-          raise
-        end
-      end
-
-      when_rendering :console do |filename|
-        "Exported storeconfigs data to #{filename}"
-      end
-    end
-
-    # Returns the location to leave the output. This is really only here for testing. :/
-    def destination_file(timestamp)
-      File.expand_path("storeconfigs-#{timestamp.strftime('%Y%m%d%H%M%S')}.tar")
-    end
-
-    # Execute a command using Puppet's execution static method.
-    #
-    # @param command [Array<String>, String] the command to execute. If it is
-    #   an Array the first element should be the executable and the rest of the
-    #   elements should be the individual arguments to that executable.
-    # @return [Puppet::Util::Execution::ProcessOutput] output as specified by options
-    # @raise [Puppet::ExecutionFailure] if the executed chiled process did not exit with status == 0 and `failonfail` is
-    #   `true`.
-    def execute(command)
-      Puppet::Util::Execution.execute(command)
-    end
-
-    def node_to_catalog_hash(node, timestamp)
-      resources = node.resources.map { |resource| resource_to_hash(resource) }
-      edges = node.resources.map { |resource| resource_to_edge_hash(resource) }
-
-      {
-        :environment => "production",
-        :metadata => {
-          :api_version => 1,
-        },
-        :certname => node.name,
-        :version => node.last_compile || Time.now,
-        :edges => edges,
-        :resources => resources + [stage_main_hash],
-        :timestamp => timestamp,
-        :producer_timestamp => timestamp,
-      }
-    end
-
-    def resource_to_hash(resource)
-      parameters = resource.param_values.inject({}) do |params,param_value|
-        if params.has_key?(param_value.param_name.name)
-          value = [params[param_value.param_name.name],param_value.value].flatten
-        else
-          value = param_value.value
-        end
-        params.merge(param_value.param_name.name => value)
-      end
-
-      tags = resource.puppet_tags.map(&:name).uniq.sort
-
-      hash = {
-        :type       => resource.restype,
-        :title      => resource.title,
-        :exported   => true,
-        :parameters => parameters,
-        :tags       => tags,
-      }
-
-      hash[:file] = resource.file if resource.file
-      hash[:line] = resource.line if resource.line
-
-      hash
-    end
-
-    # The catalog *must* have edges, so everything is contained by Stage[main]!
-    def resource_to_edge_hash(resource)
-      {
-        'source' => {'type' => 'Stage', 'title' => 'main'},
-        'target' => {'type' => resource.restype, 'title' => resource.title},
-        'relationship' => 'contains',
-      }
-    end
-
-    def stage_main_hash
-      {
-        :type       => 'Stage',
-        :title      => 'main',
-        :exported   => false,
-        :parameters => {},
-        :tags       => ['stage', 'main'],
-      }
-    end
-  end
-else
-  Puppet::Face.define(:storeconfigs, '0.0.1') do
-    copyright "Puppet Labs", 2011
-    license   "Apache 2 license"
-
-    summary "storeconfigs is not supported on Puppet 4.0.0+"
-    description <<-DESC
-    Users needing this feature should migrate using Puppet 3.7.2 or a more recent
-    3.7 release.
-  DESC
-  end
-end