ruby-puppetdb 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b8b23502fed021f532f01055c3ca02a633bd113a
-  data.tar.gz: 02b21821bbf0e4f9cd90db15c50ede416abb09cd
+  metadata.gz: 9edc345d8dbd3b6b42c2739f3e834da0e3e90497
+  data.tar.gz: a525eb44570248b3c24b580d8219bf56eb2b9bbc
 SHA512:
-  metadata.gz: b2c15fe26908deb2751fa3c08cacb8ff06fb934ca4c101f86e21ae3489d244269bc12b8f5628186e9e0f696bf2d5d99de3b7c03af4c0d46ed5d525cd7296b560
-  data.tar.gz: ac6703ed8f562b5bb7a6803c37d009a91e6cc18b478df6b238758d1d9bc2c66d78a10b7008828a75c9b0c5fd40d84ec2fd782a930f779b6896729a279e24782c
+  metadata.gz: a2d4eafc8d0a2a5337c4bb48b42652b7a26cdfe4031a991b7c4c6cf2dc3805cd8e12047955ad5454bc6b4354d7497f7e924f6f8c602ee98760eab541a73140bc
+  data.tar.gz: 20a5bbb90a78edd94c4bc9a213504a539e0303b031523a2baf41746e6c07f747331bc294bd7cbf9cc7fabbb9864a9287e1b68c4f9b2378cfb6e057ec05db805c

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

@@ -0,0 +1,38 @@
+Puppet::Parser::Functions.newfunction(:query_resources, :type => :rvalue, :arity => 2, :doc => <<-EOT
+
+  Accepts two arguments: a query used to discover nodes, and a
+  resource query for the resources that should be returned from
+  those hosts.
+
+  The result is a hash that maps the name of the nodes to a list of
+  resource entries.  This is a list because there's no single
+  reliable key for resource operations that's of any use to the end user.
+
+  Examples:
+
+    Returns the parameters and such for the ntp class for all CentOS nodes:
+
+      query_resources('operatingsystem=CentOS', 'Class["ntp"]')
+
+    Returns information on the apache user on all nodes that have apache installed on port 443:
+
+      query_resources('Class["apache"]{ port = 443 }', 'User["apache"]')
+
+    Returns the parameters and such for the apache class for all nodes:
+
+      query_resources(false, 'Class["apache"]')
+
+EOT
+) do |args|
+  nodequery, resquery = args
+
+  require 'puppet/util/puppetdb'
+  # This is also needed if the puppetdb library isn't pluginsynced to the master
+  $LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..'))
+  require 'puppetdb/connection'
+
+  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)
+end

data/lib/puppetdb.rb

@@ -1,4 +1,4 @@
 module PuppetDB
   # Current version of this module
-  VERSION = [1,4,0]
+  VERSION = [1,5,0]
 end

data/lib/puppetdb/astnode.rb

@@ -15,14 +15,21 @@ class PuppetDB::ASTNode
 
   # Generate the the query code for a subquery
   #
+  # As a special case, the from_mode of :none will not wrap the
+  # subquery at all, returning it as is.
+  #
   # @param from_mode [Symbol] the mode you want to subquery from
   # @param to_mode [Symbol] the mode you want to subquery to
   # @param query the query inside the subquery
   # @return [Array] the resulting subquery
   def subquery(from_mode, to_mode, query)
-    return ['in', (from_mode == :nodes) ? 'name' : 'certname',
-      ['extract', (to_mode == :nodes) ? 'name' : 'certname',
-        ["select-#{to_mode.to_s}", query]]]
+    if from_mode == :none
+      return query
+    else
+      return ['in', (from_mode == :nodes) ? 'name' : 'certname',
+        ['extract', (to_mode == :nodes) ? 'name' : 'certname',
+          ["select-#{to_mode.to_s}", query]]]
+    end
   end
 
   # Go through the AST and optimize boolean expressions into triplets etc

data/lib/puppetdb/connection.rb

@@ -46,12 +46,38 @@ class PuppetDB::Connection
     facts
   end
 
+  # Get the listed resources for all nodes matching query
+  # return it as a hash of hashes
+  #
+  # @param resquery [Array] a resources query for what resources to fetch
+  # @param nodequery [Array] the query to find the nodes to fetch resources for, optionally empty
+  # @return [Hash] a hash of hashes with resources for each node mathing query
+  def resources(nodequery, resquery, http=nil)
+    if resquery and ! resquery.empty?
+      if nodequery and ! nodequery.empty?
+        q = ['and', resquery, nodequery]
+      else
+        q = resquery
+      end
+    else
+      raise RuntimeError, "PuppetDB resources query error: at least one argument must be non empty; arguments were: nodequery: #{nodequery.inspect} and requery: #{resquery.inspect}"
+    end
+    resources = {}
+    query(:resources, q, http).each do |resource|
+      unless resources.has_key? resource['certname']
+        resources[resource['certname']] = []
+      end
+      resources[resource['certname']] << resource
+    end
+    return resources
+  end
+
   # Execute a PuppetDB query
   #
   # @param endpoint [Symbol] :resources, :facts or :nodes
   # @param query [Array] query to execute
   # @return [Array] the results of the query
-  def query(endpoint, query=nil, http=nil, version=:v2)
+  def query(endpoint, query=nil, http=nil, version=:v3)
     require 'json'
 
     unless http then

data/lib/puppetdb/lexer.rb

@@ -1,6 +1,6 @@
 #--
 # DO NOT MODIFY!!!!
-# This file is automatically generated by rex 1.0.2
+# This file is automatically generated by rex 1.0.5
 # from lexical definition file "lib/puppetdb/lexer.l".
 #++
 
@@ -9,133 +9,136 @@ require 'racc/parser'
 
 require 'yaml'
 
-module PuppetDB
-class Lexer < Racc::Parser
+class PuppetDB::Lexer < Racc::Parser
   require 'strscan'
 
   class ScanError < StandardError ; end
 
-  attr_reader :lineno
-  attr_reader :filename
+  attr_reader   :lineno
+  attr_reader   :filename
+  attr_accessor :state
 
-  def scan_setup ; end
+  def scan_setup(str)
+    @ss = StringScanner.new(str)
+    @lineno =  1
+    @state  = nil
+  end
 
-  def action &block
+  def action
     yield
   end
 
-  def scan_str( str )
-    scan_evaluate  str
+  def scan_str(str)
+    scan_setup(str)
     do_parse
   end
+  alias :scan :scan_str
 
   def load_file( filename )
     @filename = filename
     open(filename, "r") do |f|
-      scan_evaluate  f.read
+      scan_setup(f.read)
     end
   end
 
   def scan_file( filename )
-    load_file  filename
+    load_file(filename)
     do_parse
   end
 
+
   def next_token
-    @rex_tokens.shift
+    return if @ss.eos?
+    
+    # skips empty actions
+    until token = _next_token or @ss.eos?; end
+    token
   end
 
-  def scan_evaluate( str )
-    scan_setup
-    @rex_tokens = []
-    @lineno  =  1
-    ss = StringScanner.new(str)
-    state = nil
-    until ss.eos?
-      text = ss.peek(1)
-      @lineno  +=  1  if text == "\n"
-      case state
-      when nil
-        case
-        when (text = ss.scan(/\s/))
-          ;
+  def _next_token
+    text = @ss.peek(1)
+    @lineno  +=  1  if text == "\n"
+    token = case @state
+    when nil
+      case
+      when (text = @ss.scan(/\s/))
+        ;
 
-        when (text = ss.scan(/\(/))
-           @rex_tokens.push action { [:LPAREN, text] }
+      when (text = @ss.scan(/\(/))
+         action { [:LPAREN, text] }
 
-        when (text = ss.scan(/\)/))
-           @rex_tokens.push action { [:RPAREN, text] }
+      when (text = @ss.scan(/\)/))
+         action { [:RPAREN, text] }
 
-        when (text = ss.scan(/\[/))
-           @rex_tokens.push action { [:LBRACK, text] }
+      when (text = @ss.scan(/\[/))
+         action { [:LBRACK, text] }
 
-        when (text = ss.scan(/\]/))
-           @rex_tokens.push action { [:RBRACK, text] }
+      when (text = @ss.scan(/\]/))
+         action { [:RBRACK, text] }
 
-        when (text = ss.scan(/\{/))
-           @rex_tokens.push action { [:LBRACE, text] }
+      when (text = @ss.scan(/\{/))
+         action { [:LBRACE, text] }
 
-        when (text = ss.scan(/\}/))
-           @rex_tokens.push action { [:RBRACE, text] }
+      when (text = @ss.scan(/\}/))
+         action { [:RBRACE, text] }
 
-        when (text = ss.scan(/=/))
-           @rex_tokens.push action { [:EQUALS, text] }
+      when (text = @ss.scan(/=/))
+         action { [:EQUALS, text] }
 
-        when (text = ss.scan(/\!=/))
-           @rex_tokens.push action { [:NOTEQUALS, text] }
+      when (text = @ss.scan(/\!=/))
+         action { [:NOTEQUALS, text] }
 
-        when (text = ss.scan(/~/))
-           @rex_tokens.push action { [:MATCH, text] }
+      when (text = @ss.scan(/~/))
+         action { [:MATCH, text] }
 
-        when (text = ss.scan(/</))
-           @rex_tokens.push action { [:LESSTHAN, text] }
+      when (text = @ss.scan(/</))
+         action { [:LESSTHAN, text] }
 
-        when (text = ss.scan(/>/))
-           @rex_tokens.push action { [:GREATERTHAN, text] }
+      when (text = @ss.scan(/>/))
+         action { [:GREATERTHAN, text] }
 
-        when (text = ss.scan(/not(?![\w_:])/))
-           @rex_tokens.push action { [:NOT, text] }
+      when (text = @ss.scan(/not(?![\w_:])/))
+         action { [:NOT, text] }
 
-        when (text = ss.scan(/and(?![\w_:])/))
-           @rex_tokens.push action { [:AND, text] }
+      when (text = @ss.scan(/and(?![\w_:])/))
+         action { [:AND, text] }
 
-        when (text = ss.scan(/or(?![\w_:])/))
-           @rex_tokens.push action { [:OR, text] }
+      when (text = @ss.scan(/or(?![\w_:])/))
+         action { [:OR, text] }
 
-        when (text = ss.scan(/true(?![\w_:])/))
-           @rex_tokens.push action { [:BOOLEAN, true]}
+      when (text = @ss.scan(/true(?![\w_:])/))
+         action { [:BOOLEAN, true]}
 
-        when (text = ss.scan(/false(?![\w_:])/))
-           @rex_tokens.push action { [:BOOLEAN, false]}
+      when (text = @ss.scan(/false(?![\w_:])/))
+         action { [:BOOLEAN, false]}
 
-        when (text = ss.scan(/-?\d+\.\d+/))
-           @rex_tokens.push action { [:NUMBER, text.to_f] }
+      when (text = @ss.scan(/-?\d+\.\d+/))
+         action { [:NUMBER, text.to_f] }
 
-        when (text = ss.scan(/-?\d+/))
-           @rex_tokens.push action { [:NUMBER, text.to_i] }
+      when (text = @ss.scan(/-?\d+/))
+         action { [:NUMBER, text.to_i] }
 
-        when (text = ss.scan(/\"(\\.|[^\\"])*\"/))
-           @rex_tokens.push action { [:STRING, YAML.load(text)] }
+      when (text = @ss.scan(/\"(\\.|[^\\"])*\"/))
+         action { [:STRING, YAML.load(text)] }
 
-        when (text = ss.scan(/\'(\\.|[^\\'])*\'/))
-           @rex_tokens.push action { [:STRING, YAML.load(text)] }
+      when (text = @ss.scan(/\'(\\.|[^\\'])*\'/))
+         action { [:STRING, YAML.load(text)] }
 
-        when (text = ss.scan(/[\w_:]+/))
-           @rex_tokens.push action { [:STRING, text] }
+      when (text = @ss.scan(/[\w_:]+/))
+         action { [:STRING, text] }
 
-        when (text = ss.scan(/@@/))
-           @rex_tokens.push action { [:EXPORTED, text] }
-
-        else
-          text = ss.string[ss.pos .. -1]
-          raise  ScanError, "can not match: '" + text + "'"
-        end  # if
+      when (text = @ss.scan(/@@/))
+         action { [:EXPORTED, text] }
 
       else
-        raise  ScanError, "undefined state: '" + state.to_s + "'"
-      end  # case state
-    end  # until ss
-  end  # def scan_evaluate
+        text = @ss.string[@ss.pos .. -1]
+        raise  ScanError, "can not match: '" + text + "'"
+      end  # if
+
+    else
+      raise  ScanError, "undefined state: '" + state.to_s + "'"
+    end  # case state
+    token
+  end  # def _next_token
 
 end # class
-end # module

data/lib/puppetdb/{lexer.l → lexer.rex}

@@ -1,6 +1,7 @@
 # vim: syntax=ruby
 
 require 'yaml'
+require 'puppetdb'
 
 class PuppetDB::Lexer
 macro

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-puppetdb
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Dan Bode
@@ -9,34 +9,34 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-11 00:00:00.000000000 Z
+date: 2014-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: chronic
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
@@ -57,84 +57,84 @@ dependencies:
   name: rspec-expectations
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: puppetlabs_spec_helper
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: puppet
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: racc
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rex
+  name: rexical
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: A higher level query language for PuppetDB.
@@ -159,11 +159,12 @@ files:
 - lib/puppet/parser/functions/pdbstatusquery.rb
 - lib/puppet/parser/functions/query_facts.rb
 - lib/puppet/parser/functions/query_nodes.rb
+- lib/puppet/parser/functions/query_resources.rb
 - lib/puppetdb/astnode.rb
 - lib/puppetdb/connection.rb
-- lib/puppetdb/grammar.y
-- lib/puppetdb/lexer.l
+- lib/puppetdb/grammar.racc
 - lib/puppetdb/lexer.rb
+- lib/puppetdb/lexer.rex
 - lib/puppetdb/parser.rb
 - lib/puppetdb/util.rb
 - lib/puppetdb.rb
@@ -191,12 +192,12 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
@@ -220,4 +221,3 @@ test_files:
 - examples/nova_functions.pp
 - examples/query_node_examples.pp
 - examples/query_resource_examples.pp
-has_rdoc: