ruby-puppetdb 1.6.1 → 2.0.0

data/lib/puppetdb.rb

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

data/lib/puppetdb/astnode.rb

@@ -1,16 +1,14 @@
 class PuppetDB::ASTNode
   attr_accessor :type, :value, :children
 
-  def initialize(type, value, children=[])
+  def initialize(type, value, children = [])
     @type = type
     @value = value
     @children = children
   end
 
-  def capitalize!
-    @value=@value.to_s.split("::").collect { |s| s.capitalize }.join("::")
-    @children.each { |c| c.capitalize! }
-    return self
+  def capitalize_class(name)
+    name.to_s.split('::').collect(&:capitalize).join('::')
   end
 
   # Generate the the query code for a subquery
@@ -26,9 +24,9 @@ class PuppetDB::ASTNode
     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]]]
+      return ['in', 'certname',
+              ['extract', 'certname',
+               ["select_#{to_mode}", query]]]
     end
   end
 
@@ -40,58 +38,108 @@ class PuppetDB::ASTNode
     case @type
     when :booleanop
       @children.each do |c|
-        if c.type == :booleanop and c.value == @value
+        if c.type == :booleanop && c.value == @value
           c.children.each { |cc| @children << cc }
           @children.delete c
         end
       end
     end
-    @children.each { |c| c.optimize }
-    return self
+    @children.each(&:optimize)
+    self
   end
 
   # Evalutate the node and all children
   #
   # @param mode [Symbol] The query mode we are evaluating for
   # @return [Array] the resulting PuppetDB query
-  def evaluate(mode = :nodes)
+  def evaluate(mode = [:nodes])
     case @type
-    when :booleanop
-      return [@value.to_s, *evaluate_children(mode)]
-    when :subquery
-      return subquery(mode, @value, *evaluate_children(@value))
-    when :exp
-      case @value
-      when :equals      then op = '='
-      when :greaterthan then op = '>'
-      when :lessthan    then op = '<'
-      when :match       then op = '~'
-      end
-
-      case mode
-      when :nodes,:facts # Do a subquery to match nodes matching the facts
-        return subquery(mode, :facts, ['and', ['=', 'name', @children[0].evaluate(mode)], [op, 'value', @children[1].evaluate(mode)]])
-      when :resources
-        paramname = @children[0].evaluate(mode)
-        case paramname
-        when "tag"
-          return [op, paramname, @children[1].evaluate(mode)]
+    when :comparison
+      left = @children[0].evaluate(mode)
+      right = @children[1].evaluate(mode)
+      if mode.last == :subquery
+        left = left[0] if left.length == 1
+        comparison(left, right)
+      elsif mode.last == :resources
+        if left[0] == 'tag'
+          comparison(left[0], right)
         else
-          return [op, ['parameter', paramname], @children[1].evaluate(mode)]
+          comparison(['parameter', left[0]], right)
         end
+      else
+        subquery(mode.last,
+                 :fact_contents,
+                 ['and', left, comparison('value', right)])
       end
+    when :boolean
+      value
     when :string
-      return @value.to_s
+      value
     when :number
-      return @value
-    when :boolean
-      return @value
-    when :resourcetitle
-      return [@value, 'title', @children[0].evaluate(mode)]
-    when :resourcetype
-      return ['=', 'type', @value]
-    when :resexported
-      return ['=', 'exported', @value]
+      value
+    when :date
+      require 'chronic'
+      ret = Chronic.parse(value, :guess => false).first.iso8601
+      fail "Failed to parse datetime: #{value}" if ret.nil?
+      ret
+    when :booleanop
+      [value.to_s, *evaluate_children(mode)]
+    when :subquery
+      mode.push :subquery
+      ret = subquery(mode.last, value + 's', children[0].evaluate(mode))
+      mode.pop
+      ret
+    when :regexp_node_match
+      mode.push :regexp
+      ret = ['~', 'certname', Regexp.escape(value.evaluate(mode))]
+      mode.pop
+      ret
+    when :identifier_path
+      if mode.last == :subquery || mode.last == :resources
+        evaluate_children(mode)
+      elsif mode.last == :regexp
+        evaluate_children(mode).join '.'
+      else
+        # Check if any of the children are of regexp type
+        # in that case we need to escape the others and use the ~> operator
+        if children.any? { |c| c.type == :regexp_identifier }
+          mode.push :regexp
+          ret = ['~>', 'path', evaluate_children(mode)]
+          mode.pop
+          ret
+        else
+          ['=', 'path', evaluate_children(mode)]
+        end
+      end
+    when :regexp_identifier
+      value
+    when :identifier
+      mode.last == :regexp ? Regexp.escape(value) : value
+    when :resource
+      mode.push :resources
+      regexp = value[:title].type == :regexp_identifier
+      if !regexp && value[:type].capitalize == 'Class'
+        title = capitalize_class(value[:title].evaluate)
+      else
+        title = value[:title].evaluate
+      end
+      ret = subquery(mode.last, :resources,
+                     ['and',
+                      ['=', 'type', capitalize_class(value[:type])],
+                      [regexp ? '~' : '=', 'title', title],
+                      ['=', 'exported', value[:exported]],
+                      *evaluate_children(mode)])
+      mode.pop
+      ret
+    end
+  end
+
+  # Helper method to produce a comparison expression
+  def comparison(left, right)
+    if @value[0] == '!'
+      ['not', [@value[1], left, right]]
+    else
+      [@value, left, right]
     end
   end
 
@@ -99,6 +147,6 @@ class PuppetDB::ASTNode
   #
   # @return [Array] The evaluate results of the children nodes
   def evaluate_children(mode)
-    return children.collect { |c| c.evaluate mode }
+    children.collect { |c| c.evaluate mode }
   end
 end

data/lib/puppetdb/connection.rb

@@ -9,79 +9,24 @@ class PuppetDB::Connection
 
   include Puppet::Util::Logging
 
-  def initialize(host='puppetdb', port=443, use_ssl=true)
+  def initialize(host = 'puppetdb', port = 443, use_ssl = true)
     @host = host
     @port = port
     @use_ssl = use_ssl
-    @parser = PuppetDB::Parser.new
   end
 
-  # Parse a query string into a PuppetDB query
-  #
-  # @param query [String] the query string to parse
-  # @param endpoint [Symbol] the endpoint for which the query should be evaluated
-  # @return [Array] the PuppetDB query
-  def parse_query(query, endpoint = :nodes)
-    if query = @parser.scan_str(query)
-      query.optimize.evaluate endpoint
-    end
-  end
-
-  # Get the listed facts for all nodes matching query
-  # return it as a hash of hashes
-  #
-  # @param facts [Array] the list of facts to fetch
-  # @param nodequery [Array] the query to find the nodes to fetch facts for
-  # @return [Hash] a hash of hashes with facts for each node mathing query
-  def facts(facts, nodequery, http = nil)
-    if facts.empty?
-      q = ['in', 'certname', ['extract', 'certname', ['select-facts', nodequery]]]
-    else
-      q = ['and', ['in', 'certname', ['extract', 'certname', ['select-facts', nodequery]]], ['or', *facts.collect { |f| ['=', 'name', f]}]]
-    end
-    facts = {}
-    query(:facts, q, http).each do |fact|
-      if facts.include? fact['certname']
-        facts[fact['certname']][fact['name']] = fact['value']
-      else
-        facts[fact['certname']] = { fact['name'] => fact['value'] }
+  def self.check_version
+    begin
+      require 'puppet/util/puppetdb'
+      unless Puppet::Util::Puppetdb.config.respond_to?('server_urls')
+        Puppet.warning <<-EOT
+It looks like you are using a PuppetDB version < 3.0.
+This version of puppetdbquery requires at least PuppetDB 3.0 to work.
+Downgrade to puppetdbquery 1.x to use it with PuppetDB 2.x.
+EOT
       end
+    rescue LoadError
     end
-    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
-  # @param grouphosts [Boolean] whether or not to group the results by the host they belong to
-  # @return [Hash|Array] a hash of hashes with resources for each node mathing query or array if grouphosts was false
-  def resources(nodequery, resquery, http=nil, grouphosts=true)
-    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 = {}
-    results = query(:resources, q, http)
-
-    if grouphosts
-      results.each do |resource|
-        unless resources.has_key? resource['certname']
-          resources[resource['certname']] = []
-        end
-        resources[resource['certname']] << resource
-      end
-    else
-      resources = results
-    end
-
-    return resources
   end
 
   # Execute a PuppetDB query
@@ -89,7 +34,7 @@ class PuppetDB::Connection
   # @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 = :v3)
+  def query(endpoint, query = nil, http = nil, version = :v4)
     require 'json'
 
     unless http
@@ -98,13 +43,13 @@ class PuppetDB::Connection
     end
     headers = { 'Accept' => 'application/json' }
 
-    uri = "/#{version}/#{endpoint}"
+    uri = "/pdb/query/#{version}/#{endpoint}"
     uri += URI.escape "?query=#{query.to_json}" unless query.nil? || query.empty?
 
     debug("PuppetDB query: #{query.to_json}")
 
     resp = http.get(uri, headers)
-    raise "PuppetDB query error: [#{resp.code}] #{resp.msg}, query: #{query.to_json}" unless resp.kind_of?(Net::HTTPSuccess)
+    fail "PuppetDB query error: [#{resp.code}] #{resp.msg}, query: #{query.to_json}" unless resp.is_a?(Net::HTTPSuccess)
     JSON.parse(resp.body)
   end
 end

data/lib/puppetdb/grammar.racc

@@ -4,7 +4,9 @@
 class PuppetDB::Parser
 
   token LPAREN RPAREN LBRACK RBRACK LBRACE RBRACE
-  token EQUALS NOTEQUALS MATCH LESSTHAN GREATERTHAN
+  token EQUALS NOTEQUALS MATCH NOTMATCH
+  token LESSTHAN LESSTHANEQ GREATERTHAN GREATERTHANEQ
+  token AT HASH ASTERISK DOT
   token NOT AND OR
   token NUMBER STRING BOOLEAN EXPORTED
 
@@ -15,48 +17,81 @@ class PuppetDB::Parser
     left  OR
   preclow
 
+  options no_result_var
+
 rule
-  query:
-     |exp
-
-  exp: LPAREN exp RPAREN			{ result = val[1] }
-     | NOT exp					{ result = ASTNode.new :booleanop, :not, [val[1]] }
-     | exp AND exp				{ result = ASTNode.new :booleanop, :and, [val[0], val[2]] }
-     | exp OR exp				{ result = ASTNode.new :booleanop, :or, [val[0], val[2]] }
-     | string EQUALS string			{ result = ASTNode.new :exp, :equals, [val[0], val[2]] }
-     | string EQUALS boolean			{ result = ASTNode.new :exp, :equals, [val[0], val[2]] }
-     | string EQUALS number			{ result = ASTNode.new :exp, :equals, [val[0], val[2]] }
-     | string GREATERTHAN number		{ result = ASTNode.new :exp, :greaterthan, [val[0], val[2]] }
-     | string LESSTHAN number			{ result = ASTNode.new :exp, :lessthan, [val[0], val[2]] }
-     | string MATCH string			{ result = ASTNode.new :exp, :match, [val[0], val[2]] }
-     | string NOTEQUALS number			{ result = ASTNode.new :booleanop, :not, [ASTNode.new(:exp, :equals, [val[0], val[2]])] }
-     | string NOTEQUALS boolean			{ result = ASTNode.new :booleanop, :not, [ASTNode.new(:exp, :equals, [val[0], val[2]])] }
-     | string NOTEQUALS string			{ result = ASTNode.new :booleanop, :not, [ASTNode.new(:exp, :equals, [val[0], val[2]])] }
-     | ressubquery
-
-  ressubquery: resexp				{ result = ASTNode.new :subquery, :resources, [ASTNode.new(:booleanop, :and, [ASTNode.new(:resexported, false), *val[0]])] }
-             | resexported resexp	        { result = ASTNode.new :subquery, :resources, [ASTNode.new(:booleanop, :and, [ASTNode.new(:resexported, true), *val[1]])] }
-
-  resexp: restype				{ result = [val[0]] }
-        | restitle				{ result = [val[0]] }
-        | resparams				{ result = [val[0]] }
-        | restype restitle			{ result = val[0].value == "Class" ? [val[0], val[1].capitalize!] : [val[0], val[1]] }
-        | restitle resparams			{ result = [val[0], val[1]] }
-        | restype resparams			{ result = [val[0], val[1]] }
-        | restype restitle resparams		{ result = val[0].value == "Class" ? [val[0], val[1].capitalize!, val[2]] : [val[0], val[1], val[2]] }
-
-  resexported: EXPORTED
-  restype: STRING				{ result = ASTNode.new(:resourcetype, val[0]).capitalize! }
-  restitle: LBRACK STRING RBRACK		{ result = ASTNode.new :resourcetitle, '=', [ASTNode.new(:string, val[1])] }
-  restitle: LBRACK MATCH STRING RBRACK		{ result = ASTNode.new :resourcetitle, '~', [ASTNode.new(:string, val[2])] }
-  resparams: LBRACE exp RBRACE			{ result = val[1] }
-
-  string: STRING				{ result = ASTNode.new :string, val[0] }
-  number: NUMBER				{ result = ASTNode.new :number, val[0] }
-  boolean: BOOLEAN				{ result = ASTNode.new :boolean, val[0] }
+  query
+    : expression
+    |
+
+  expression
+    : identifier_path             { ASTNode.new :regexp_node_match, val[0] }
+    |            NOT expression   { ASTNode.new :booleanop, :not, [val[1]] }
+    | expression AND expression   { ASTNode.new :booleanop, :and, [val[0], val[2]] }
+    | expression OR  expression   { ASTNode.new :booleanop, :or, [val[0], val[2]] }
+    | LPAREN expression RPAREN    { val[1] }
+    | resource_expression
+    | comparison_expression
+    | subquery
+
+  literal
+    : boolean                     { ASTNode.new :boolean, val[0] }
+    | string                      { ASTNode.new :string, val[0] }
+    | integer                     { ASTNode.new :number, val[0] }
+    | float                       { ASTNode.new :number, val[0] }
+    | AT string                   { ASTNode.new :date, val[1] }
+
+  comparison_op
+    : MATCH
+    | NOTMATCH
+    | EQUALS
+    | NOTEQUALS
+    | GREATERTHAN
+    | GREATERTHANEQ
+    | LESSTHAN
+    | LESSTHANEQ
+
+  comparison_expression
+    : identifier_path comparison_op literal { ASTNode.new :comparison, val[1], [val[0], val[2]] }
+
+  identifier
+    : string                      { ASTNode.new :identifier, val[0] }
+    | integer                     { ASTNode.new :identifier, val[0] }
+    | MATCH string                { ASTNode.new :regexp_identifier, val[1] }
+    | ASTERISK                    { ASTNode.new :regexp_identifier, '.*' }
+
+  identifier_path
+    : identifier                     { ASTNode.new :identifier_path, nil, [val[0]] }
+    | identifier_path DOT identifier { val[0].children.push val[2]; val[0] }
+
+  subquery
+    : HASH string DOT comparison_expression { ASTNode.new :subquery, val[1], [val[3]] }
+    | HASH string block_expression          { ASTNode.new :subquery, val[1], [val[2]] }
+
+  block_expression
+    : LBRACE expression RBRACE    { val[1] }
+
+  resource_expression
+    : string LBRACK identifier RBRACK
+      { ASTNode.new :resource, {:type => val[0], :title => val[2], :exported => false} }
+    | string LBRACK identifier RBRACK block_expression
+      { ASTNode.new :resource, {:type => val[0], :title => val[2], :exported => false}, [val[4]] }
+    | EXPORTED string LBRACK identifier RBRACK
+      { ASTNode.new :resource, {:type => val[1], :title => val[3], :exported => true} }
+    | EXPORTED string LBRACK identifier RBRACK block_expression
+      { ASTNode.new :resource, {:type => val[1], :title => val[3], :exported => true}, [val[5]] }
+
+  boolean: BOOLEAN
+  integer: NUMBER
+  string: STRING
+  float: NUMBER DOT NUMBER        { "#{val[0]}.#{val[2]}".to_f }
 
 end
----- header ----
+---- inner
+  include PuppetDB::ParserHelper
+
+---- header
 require 'puppetdb'
 require 'puppetdb/lexer'
 require 'puppetdb/astnode'
+require 'puppetdb/parser_helper'

data/lib/puppetdb/lexer.rb

@@ -1,13 +1,14 @@
 #--
 # DO NOT MODIFY!!!!
 # This file is automatically generated by rex 1.0.5
-# from lexical definition file "lib/puppetdb/lexer.l".
+# from lexical definition file "lib/puppetdb/lexer.rex".
 #++
 
 require 'racc/parser'
 # vim: syntax=ruby
 
 require 'yaml'
+require 'puppetdb'
 
 class PuppetDB::Lexer < Racc::Parser
   require 'strscan'
@@ -91,12 +92,30 @@ class PuppetDB::Lexer < Racc::Parser
       when (text = @ss.scan(/~/))
          action { [:MATCH, text] }
 
+      when (text = @ss.scan(/\!~/))
+         action { [:NOTMATCH, text] }
+
       when (text = @ss.scan(/</))
          action { [:LESSTHAN, text] }
 
+      when (text = @ss.scan(/<=/))
+         action { [:LESSTHANEQ, text] }
+
       when (text = @ss.scan(/>/))
          action { [:GREATERTHAN, text] }
 
+      when (text = @ss.scan(/>=/))
+         action { [:GREATERTHANEQ, text] }
+
+      when (text = @ss.scan(/\*/))
+         action { [:ASTERISK, text] }
+
+      when (text = @ss.scan(/\#/))
+         action { [:HASH, text] }
+
+      when (text = @ss.scan(/\./))
+         action { [:DOT, text] }
+
       when (text = @ss.scan(/not(?![\w_:])/))
          action { [:NOT, text] }
 
@@ -112,9 +131,6 @@ class PuppetDB::Lexer < Racc::Parser
       when (text = @ss.scan(/false(?![\w_:])/))
          action { [:BOOLEAN, false]}
 
-      when (text = @ss.scan(/-?\d+\.\d+/))
-         action { [:NUMBER, text.to_f] }
-
       when (text = @ss.scan(/-?\d+/))
          action { [:NUMBER, text.to_i] }
 
@@ -130,6 +146,9 @@ class PuppetDB::Lexer < Racc::Parser
       when (text = @ss.scan(/@@/))
          action { [:EXPORTED, text] }
 
+      when (text = @ss.scan(/@/))
+         action { [:AT, text] }
+
       else
         text = @ss.string[@ss.pos .. -1]
         raise  ScanError, "can not match: '" + text + "'"