ruby-puppetdb 1.6.1 → 2.0.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MzcxMDgxMjE5NzYzMDYzMTY2M2M5YjQwMzNhN2Q3MmRjYzMyNDg0NQ==
+    NjdkNGNlZjVmMjE3Mzc2YjJmM2ViMWEzZjdkNDllMzNiNWNlMTY3MA==
   data.tar.gz: !binary |-
-    YjAzZTlkZmM3ZWVlOGYxYzIyNDAwODE2MTAyYTExMmRiZTZhYzc1OA==
+    ZmJiM2NjYTljMTAwNDc3MzEyNDM5YjJmNmNhYzc1YTA4MzA5Yzk1NQ==
 SHA512:
   metadata.gz: !binary |-
-    NmQ5ZTk3YjZkZDRjZDgwZTcyNGRhOWM5YzhlMWY4ZDlhNDg0MzUwMDY4MThm
-    MmQxODIwY2Y3MjdiZDhlYjUzOTg1MGE5ZDI5M2E0ZDc3OTFkMjY5OTkzNTFh
-    NDM4YzZlODAxZWI3NmEwZTlkMTBmNGFiYmIzM2Q5NWMzYTAxMWQ=
+    MjZiNjBmZmJlMDc3N2M2YTY4YWQ1MjJlOTNlNmIwNjNiNDI1YjRlMWM4NjI4
+    MzA5ZmY1YjBjYTAzOGVhOTBmZjg1MDY2NzFlZjU2ZjJiN2YxYmRhOTM3ZmZm
+    ZjFjNzIyNTM4YTM0ZDQ0Zjk0ZmUzZDNlNGVhMThiYzFlN2M0MmU=
   data.tar.gz: !binary |-
-    M2RmNTFjZTUxY2JhMWY5YjU2YjM0YjhiYWI3MDk0OTM0ZGExYjk0YjkzYzBm
-    M2M5OGFlNDc1NDc0ZDc0YTNkZWMwM2MwNTEyN2RlZjA4YWQ4ZjVmZTA0YTc0
-    ZjBiMjY3MjNhY2I0MGFlYTRjM2VhNzVjMGRiNmMwYTJiNTE5N2E=
+    YTdhMmE3NTQ4NmYyN2QxZjAzYjA5NmNhMjUzODU4M2JhMDdjOTczYWUyYjA1
+    ZDU4M2FkMjRhMzliZjYwYzM4NWQ5MmMxNDhmNGU5NDZlZjZkYWQ1ZGJhY2Zk
+    YzA2YzRlYTQzZWQzYzg2NTZiZmVmYTkxYTg1NzdkN2U2MTIwZDQ=

data/bin/find-nodes

@@ -6,54 +6,67 @@ require 'optparse'
 require 'net/http'
 require 'net/https'
 
-options = {:puppetdb_host => "puppetdb",
-           :puppetdb_port => 443,
-           :fact => nil,
-           :query => nil}
+options = { host: 'puppetdb',
+            port: 443,
+            fact: nil,
+            query: nil,
+            ssl: true,
+            print: false }
 
 opt = OptionParser.new
 
-opt.on("--puppetdb [PUPPETDB]", "-p", "Host running PuppetDB (#{options[:puppetdb_host]})") do |v|
-  options[:puppetdb_host] = v
+opt.on('--host [PUPPETDB]', '-H', "Host running PuppetDB (#{options[:host]})") do |v|
+  options[:host] = v
 end
 
-opt.on("--port [PORT]", "-P", Integer, "Port PuppetDB is running on (#{options[:puppetdb_port]})") do |v|
-  options[:puppetdb_port] = v
+opt.on('--port [PORT]', '-p', Integer, "Port PuppetDB is running on (#{options[:port]})") do |v|
+  options[:port] = v
 end
 
-opt.on("--query [QUERY]", "-q", "Query String") do |v|
+opt.on('--query [QUERY]', '-q', 'Query String') do |v|
   options[:query] = v
 end
 
-opt.on("--facts [FACT]", "-f", "Comma separated list of facts") do |v|
+opt.on('--facts [FACT]', '-f', 'Comma separated list of facts') do |v|
   options[:facts] = v.split ','
 end
 
-opt.on("--timeout [SECONDS]", "-t", "PuppetDB read timeout") do |v|
+opt.on('--timeout [SECONDS]', '-t', 'PuppetDB read timeout') do |v|
   options[:timeout] = v.to_i
 end
 
+opt.on('--nossl', 'Disable SSL') do |v|
+  options[:ssl] = false
+end
+
+opt.on('--print', 'Only print query') do |v|
+  options[:print] = true
+end
+
 opt.parse!
 
 options[:query] ||= ARGV[0]
 
-abort "Please specify a query" unless options[:query]
+abort 'Please specify a query' unless options[:query]
 
-puppetdb = PuppetDB::Connection.new(options[:puppetdb_host], options[:puppetdb_port])
-http = Net::HTTP.new(options[:puppetdb_host], options[:puppetdb_port])
-http.use_ssl = true
+puppetdb = PuppetDB::Connection.new(options[:host], options[:port])
+parser = PuppetDB::Parser.new
+http = Net::HTTP.new(options[:host], options[:port])
+http.use_ssl = options[:ssl]
 http.verify_mode = OpenSSL::SSL::VERIFY_NONE
 http.read_timeout = options[:timeout] if options[:timeout]
 
-if options[:facts]
-  query = puppetdb.parse_query(options[:query], :facts)
-  facts = puppetdb.facts(options[:facts], query, http)
-  facts.each_value do |host|
+if options[:print]
+  query = parser.parse(options[:query])
+  puts query.to_json
+elsif options[:facts]
+  query = parser.facts_query(options[:query], options[:facts])
+  parser.facts_hash(puppetdb.query(:facts, query, http)).each_value do |host|
     print options[:facts].collect { |f| host[f] if host.include? f }.join(',') + "\n"
   end
 else
-  query = puppetdb.parse_query(options[:query])
+  query = parser.parse(options[:query])
   results = puppetdb.query(:nodes, query, http)
-  hosts = results.collect { |host| host['name'] }
+  hosts = results.collect { |host| host['certname'] }
   hosts.each { |host| print host + "\n" }
 end

data/lib/hiera/backend/puppetdb_backend.rb

@@ -8,24 +8,27 @@ class Hiera
           # This is needed when we run from hiera cli
           Puppet.initialize_settings unless Puppet[:confdir]
           require 'puppet/util/puppetdb'
-          server = Puppet::Util::Puppetdb.server
-          port = Puppet::Util::Puppetdb.port
+          PuppetDB::Connection.check_version
+          uri = URI(Puppet::Util::Puppetdb.config.server_urls.first)
+          host = uri.host
+          port = uri.port
         rescue
-          server = 'puppetdb'
+          host = 'puppetdb'
           port = 443
         end
 
-        Hiera.debug("Hiera PuppetDB backend starting")
+        Hiera.debug('Hiera PuppetDB backend starting')
 
-        @puppetdb = PuppetDB::Connection.new(server, port)
+        @puppetdb = PuppetDB::Connection.new(host, port)
+        @parser = PuppetDB::Parser.new
       end
 
-      def lookup(key, scope, order_override, resolution_type)
-        return nil if key.end_with? "::_nodequery"
+      def lookup(key, scope, order_override, _resolution_type)
+        return nil if key.end_with? '::_nodequery'
 
         Hiera.debug("Looking up #{key} in PuppetDB backend")
 
-        if nodequery = Backend.lookup(key + "::_nodequery", nil, scope, order_override, :priority)
+        if nodequery = Backend.lookup(key + '::_nodequery', nil, scope, order_override, :priority)
           Hiera.debug("Found nodequery #{nodequery.inspect}")
 
           # Support specifying the query in a few different ways
@@ -38,11 +41,11 @@ class Hiera
             query = nodequery.to_s
           end
 
-          if fact then
-            query = @puppetdb.parse_query query, :facts if query.is_a? String
-            @puppetdb.facts([fact], query).each_value.collect { |facts| facts[fact] }.sort
+          if fact
+            query = @parser.facts_query query, [fact]
+            @puppetdb.query(:facts, query).collect { |f| f['value'] }.sort
           else
-            query = @puppetdb.parse_query query, :nodes if query.is_a? String
+            query = @parser.parse query, :nodes if query.is_a? String
             @puppetdb.query(:nodes, query).collect { |n| n['name'] }
           end
         end

data/lib/puppet/application/query.rb

@@ -2,11 +2,14 @@ require 'puppet/application/face_base'
 
 class Puppet::Application::Query < Puppet::Application::FaceBase
   def self.setting
+    use_ssl = true
     begin
       require 'puppet'
       require 'puppet/util/puppetdb'
-      host = Puppet::Util::Puppetdb.server || 'puppetdb'
-      port = Puppet::Util::Puppetdb.port || 8081
+      PuppetDB::Connection.check_version
+      uri = URI(Puppet::Util::Puppetdb.config.server_urls.first)
+      host = uri.host
+      port = uri.port
     rescue Exception => e
       Puppet.debug(e.message)
       host = 'puppetdb'
@@ -15,8 +18,11 @@ class Puppet::Application::Query < Puppet::Application::FaceBase
 
     Puppet.debug(host)
     Puppet.debug(port)
+    Puppet.debug("use_ssl=#{use_ssl}")
 
-    { :host => host,
-      :port => port }
+    { host: host,
+      port: port,
+      use_ssl: use_ssl
+    }
   end
 end

data/lib/puppet/face/query.rb

@@ -4,23 +4,28 @@ require 'puppet/util/colors'
 
 Puppet::Face.define(:query, '1.0.0') do
   require 'puppetdb/connection'
+  PuppetDB::Connection.check_version
 
   extend Puppet::Util::Colors
 
-  copyright "Puppet Labs & Erik Dalen", 2012..2013
-  license   "Apache 2 license; see COPYING"
+  copyright 'Erik Dalen & Puppet Labs', 2012..2015
+  license 'Apache 2 license; see COPYING'
 
-
-  option '--puppetdb_host PUPPETDB' do
-    summary "Host running PuppetDB. "
+  option '--host PUPPETDB' do
+    summary 'Host running PuppetDB. '
     default_to { Puppet::Application::Query.setting[:host] }
   end
 
-  option '--puppetdb_port PORT' do
+  option '--port PORT' do
     summary 'Port PuppetDB is running on'
     default_to { Puppet::Application::Query.setting[:port] }
   end
 
+  option '--no_ssl' do
+    summary 'Talk plain HTTP instead of HTTPS'
+    default_to { !Puppet::Application::Query.setting[:use_ssl] }
+  end
+
   action :facts do
     summary 'Serves as an interface to puppetdb allowing a user to query for a list of nodes'
 
@@ -28,7 +33,7 @@ Puppet::Face.define(:query, '1.0.0') do
       Here is a ton of more useful information :)
     EOT
 
-    arguments "<query>"
+    arguments '<query>'
 
     option '--facts FACTS' do
       summary 'facts to return that represent each host'
@@ -40,20 +45,20 @@ Puppet::Face.define(:query, '1.0.0') do
     end
 
     when_invoked do |query, options|
-      puppetdb = PuppetDB::Connection.new options[:puppetdb_host], options[:puppetdb_port]
-      puppetdb.facts(options[:facts].split(','), puppetdb.parse_query(query, :facts))
+      puppetdb = PuppetDB::Connection.new options[:host], options[:port], !options[:no_ssl]
+      parser = PuppetDB::Parser.new
+      factquery = parser.facts_query(query, options[:facts].split(','))
+      parser.facts_hash(puppetdb.query(factquery))
     end
-
   end
 
   action :nodes do
-
     summary 'Perform complex queries for nodes from PuppetDB'
     description <<-EOT
       Here is a ton of more useful information :)
     EOT
 
-    arguments "<query>"
+    arguments '<query>'
 
     option '--node_info BOOLEAN' do
       summary 'return full info about each node or just name'
@@ -64,16 +69,16 @@ Puppet::Face.define(:query, '1.0.0') do
     end
 
     when_invoked do |query, options|
-      puppetdb = PuppetDB::Connection.new options[:puppetdb_host], options[:puppetdb_port]
-      nodes = puppetdb.query(:nodes, puppetdb.parse_query(query, :nodes))
+      puppetdb = PuppetDB::Connection.new options[:host], options[:port], !options[:no_ssl]
+      parser = PuppetDB::Parser.new
+      nodes = puppetdb.query(:nodes, parser.parse(query, :nodes))
 
       if options[:node_info]
-        Hash[nodes.collect { |node| [node['name'], node.reject{|k,v| k == "name"}] }]
+        Hash[nodes.collect { |node| [node['certname'], node.reject { |k, _v| k == 'certname' }] }]
       else
-        nodes.collect { |node| node['name'] }
+        nodes.collect { |node| node['certname'] }
       end
     end
-
   end
 
   action :events do
@@ -83,7 +88,7 @@ Puppet::Face.define(:query, '1.0.0') do
       Get all avents for nodes matching the query specified.
     EOT
 
-    arguments "<query>"
+    arguments '<query>'
 
     option '--since SINCE' do
       summary 'Get events since this time'
@@ -114,30 +119,31 @@ Puppet::Face.define(:query, '1.0.0') do
         require 'chronic'
       rescue LoadError
         Puppet.err "Failed to load 'chronic' dependency. Install using `gem install chronic`"
-        raise $!
+        raise
       end
 
-      puppetdb = PuppetDB::Connection.new options[:puppetdb_host], options[:puppetdb_port]
-      nodes = puppetdb.query(:nodes, puppetdb.parse_query(query, :nodes)).collect { |n| n['name']}
-      starttime = Chronic.parse(options[:since], :context => :past, :guess => false).first.getutc.strftime('%FT%T.000Z')
-      endtime = Chronic.parse(options[:until], :context => :past, :guess => false).last.getutc.strftime('%FT%T.000Z')
+      puppetdb = PuppetDB::Connection.new options[:host], options[:port], !options[:no_ssl]
+      parser = PuppetDB::Parser.new
+      nodes = puppetdb.query(:nodes, parser.parse(query, :nodes)).collect { |n| n['certname'] }
+      starttime = Chronic.parse(options[:since], context: :past, guess: false).first.getutc.strftime('%FT%T.000Z')
+      endtime = Chronic.parse(options[:until], context: :past, guess: false).last.getutc.strftime('%FT%T.000Z')
 
       events = []
       # Event API doesn't support subqueries at the moment and
       # we can't do too big queries, so fetch events for some nodes at a time
       nodes.each_slice(20) do |nodeslice|
-        eventquery = ['and', ['>', 'timestamp', starttime], ['<', 'timestamp', endtime], ['or', *nodeslice.collect { |n| ['=', 'certname', n]}]]
+        eventquery = ['and', ['>', 'timestamp', starttime], ['<', 'timestamp', endtime], ['or', *nodeslice.collect { |n| ['=', 'certname', n] }]]
         eventquery << ['=', 'status', options[:status]] if options[:status] != 'all'
-        events.concat puppetdb.query(:events, eventquery, nil, :v3)
+        events.concat puppetdb.query(:events, eventquery)
       end
 
       events.sort_by do |e|
-        "#{e['timestamp']}+#{e['resource-type']}+#{e['resource-title']}+#{e['property']}"
+        "#{e['timestamp']}+#{e['resource_type']}+#{e['resource_title']}+#{e['property']}"
       end.each do |e|
-        out="#{e['certname']}: #{e['timestamp']}: #{e['resource-type']}[#{e['resource-title']}]"
-        out+="/#{e['property']}" if e['property']
-        out+=" (#{e['old-value']} -> #{e['new-value']})" if e['old-value'] && e['new-value']
-        out+=": #{e['message']}" if e['message']
+        out = "#{e['certname']}: #{e['timestamp']}: #{e['resource_type']}[#{e['resource_title']}]"
+        out += "/#{e['property']}" if e['property']
+        out += " (#{e['old_value']} -> #{e['new_value']})" if e['old_value'] && e['new_value']
+        out += ": #{e['message']}" if e['message']
         out.chomp!
         case e['status']
         when 'failure'
@@ -145,7 +151,7 @@ Puppet::Face.define(:query, '1.0.0') do
         when 'success'
           puts colorize(:green, out)
         when 'skipped'
-          puts colorize(:hyellow, out) unless e['resource-type'] == 'Schedule'
+          puts colorize(:hyellow, out) unless e['resource_type'] == 'Schedule'
         when 'noop'
           puts out
         end

data/lib/puppet/parser/functions/query_facts.rb

@@ -1,4 +1,4 @@
-Puppet::Parser::Functions.newfunction(:query_facts, :type => :rvalue, :arity => 2, :doc => <<-EOT
+Puppet::Parser::Functions.newfunction(:query_facts, type: :rvalue, arity: 2, doc: <<-EOT
 
   accepts two arguments, a query used to discover nodes, and a list of facts
   that should be returned from those hosts.
@@ -13,10 +13,11 @@ Puppet::Parser::Functions.newfunction(:query_facts, :type => :rvalue, :arity =>
   contains the facts specified.
 
 EOT
-) do |args|
+                                     ) do |args|
   query, facts = args
 
   require 'puppet/util/puppetdb'
+
   # This is needed if the puppetdb library isn't pluginsynced to the master
   $LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..'))
   begin
@@ -25,7 +26,11 @@ EOT
     $LOAD_PATH.shift
   end
 
-  puppetdb = PuppetDB::Connection.new(Puppet::Util::Puppetdb.server, Puppet::Util::Puppetdb.port)
-  query = puppetdb.parse_query query, :facts if query.is_a? String
+  PuppetDB::Connection.check_version
+
+  uri = URI(Puppet::Util::Puppetdb.config.server_urls.first)
+  puppetdb = PuppetDB::Connection.new(uri.host, uri.port)
+  parser = PuppetDB::Parser.new
+  query = parser.parse query, :facts if query.is_a? String
   puppetdb.facts(facts, query)
 end

data/lib/puppet/parser/functions/query_nodes.rb

@@ -1,4 +1,4 @@
-Puppet::Parser::Functions.newfunction(:query_nodes, :type => :rvalue, :arity => -2, :doc => <<-EOT
+Puppet::Parser::Functions.newfunction(:query_nodes, type: :rvalue, arity: -2, doc: <<-EOT
 
   accepts two arguments, a query used to discover nodes, and a optional
   fact that should be returned.
@@ -10,10 +10,11 @@ Puppet::Parser::Functions.newfunction(:query_nodes, :type => :rvalue, :arity =>
   The second argument should be single fact (this argument is optional)
 
 EOT
-) do |args|
+                                     ) do |args|
   query, fact = args
 
   require 'puppet/util/puppetdb'
+
   # This is needed if the puppetdb library isn't pluginsynced to the master
   $LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..'))
   begin
@@ -22,12 +23,16 @@ EOT
     $LOAD_PATH.shift
   end
 
-  puppetdb = PuppetDB::Connection.new(Puppet::Util::Puppetdb.server, Puppet::Util::Puppetdb.port)
-  if fact then
-    query = puppetdb.parse_query query, :facts if query.is_a? String
-    puppetdb.facts([fact], query).each_value.collect { |facts| facts[fact] }
+  PuppetDB::Connection.check_version
+
+  uri = URI(Puppet::Util::Puppetdb.config.server_urls.first)
+  puppetdb = PuppetDB::Connection.new(uri.host, uri.port)
+  parser = PuppetDB::Parser.new
+  if fact
+    query = parser.facts_query query, [fact]
+    puppetdb.query(:facts, query).collect { |f| f['value'] }
   else
-    query = puppetdb.parse_query query, :nodes if query.is_a? String
-    puppetdb.query(:nodes, query).collect { |n| n['name'] }
+    query = parser.parse query, :nodes if query.is_a? String
+    puppetdb.query(:nodes, query).collect { |n| n['certname'] }
   end
 end

data/lib/puppet/parser/functions/query_resources.rb

@@ -1,4 +1,4 @@
-Puppet::Parser::Functions.newfunction(:query_resources, :type => :rvalue, :arity => -3, :doc => <<-EOT
+Puppet::Parser::Functions.newfunction(:query_resources, type: :rvalue, arity: -3, doc: <<-EOT
 
   Accepts two or three arguments: a query used to discover nodes, a
   resource query for the resources that should be returned from
@@ -29,7 +29,7 @@ Puppet::Parser::Functions.newfunction(:query_resources, :type => :rvalue, :arity
       query_resources(false, 'Class["apache"]', false)
 
 EOT
-) do |args|
+                                     ) do |args|
   nodequery, resquery, grouphosts = args
 
   require 'puppet/util/puppetdb'
@@ -41,8 +41,37 @@ EOT
     $LOAD_PATH.shift
   end
 
-  puppetdb = PuppetDB::Connection.new(Puppet::Util::Puppetdb.server, Puppet::Util::Puppetdb.port)
-  nodequery = puppetdb.parse_query nodequery, :facts if nodequery and nodequery.is_a? String and ! nodequery.empty?
-  resquery = puppetdb.parse_query resquery, :none if resquery and resquery.is_a? String and ! resquery.empty?
-  return puppetdb.resources(nodequery, resquery, nil, grouphosts)
+  PuppetDB::Connection.check_version
+
+  uri = URI(Puppet::Util::Puppetdb.config.server_urls.first)
+  puppetdb = PuppetDB::Connection.new(uri.host, uri.port)
+  parser = PuppetDB::Parser.new
+  nodequery = parser.parse nodequery, :facts if nodequery and nodequery.is_a? String
+  resquery = parser.parse resquery, :none if resquery and resquery.is_a? String
+
+  # Construct query
+  if resquery && !resquery.empty?
+    if nodequery && !nodequery.empty?
+      q = ['and', resquery, nodequery]
+    else
+      q = resquery
+    end
+  else
+    fail "PuppetDB resources query error: at least one argument must be non empty; arguments were: nodequery: #{nodequery.inspect} and requery: #{resquery.inspect}"
+  end
+
+  # Fetch the results
+  results = puppetdb.query(:resources, q)
+
+  # If grouphosts is true create a nested hash with nodes and resources
+  if grouphosts
+    results.reduce({}) do |ret, resource|
+      unless ret.key? resource['certname']
+        ret[resource['certname']] = []
+      end
+      ret[resource['certname']] << resource
+    end
+  else
+    results
+  end
 end