ruby-puppetdb 1.6.1 → 2.0.0

data/lib/puppetdb/parser_helper.rb

@@ -0,0 +1,48 @@
+# Helper methods for the parser, included in the parser class
+require 'puppetdb'
+module PuppetDB::ParserHelper
+  # 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, endpoint = :nodes)
+    if query = scan_str(query)
+      query.optimize.evaluate [endpoint]
+    end
+  end
+
+  # Create a query for facts on nodes matching a query string
+  #
+  # @param query [String] the query string to parse
+  # @param facts [Array] an array of facts to get
+  # @return [Array] the PuppetDB query
+  def facts_query(query, facts = nil)
+    nodequery = parse(query, :facts)
+    if facts.nil?
+      nodequery
+    else
+      factquery = ['or', *facts.collect { |f| ['=', 'name', f] }]
+      if nodequery
+        ['and', nodequery, factquery]
+      else
+        factquery
+      end
+    end
+  end
+
+  # Turn an array of facts into a hash of nodes containing facts
+  #
+  # @param facts [Array] fact values
+  # @return [Hash] nodes as keys containing a hash of facts as value
+  def facts_hash(facts)
+    facts.reduce({}) do |ret, fact|
+      if ret.include? fact['certname']
+        ret[fact['certname']][fact['name']] = fact['value']
+      else
+        ret[fact['certname']] = { fact['name'] => fact['value'] }
+      end
+      ret
+    end
+  end
+end

data/spec/unit/puppetdb/parser_spec.rb

@@ -0,0 +1,129 @@
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
+require 'puppetdb/parser'
+
+describe PuppetDB::Parser do
+  context "Query parsing" do
+    let(:parser) { PuppetDB::Parser.new }
+    it "should handle empty queries" do
+      parser.parse('').should be_nil
+    end
+
+    it "should handle double quoted strings" do
+      parser.parse('foo="bar"').should eq ["in", "certname", ["extract", "certname", ["select_fact_contents", ["and", ["=", "path", ["foo"]], ["=", "value", "bar"]]]]]
+    end
+
+    it "should handle single quoted strings" do
+      parser.parse('foo=\'bar\'').should eq ["in", "certname", ["extract", "certname", ["select_fact_contents", ["and", ["=", "path", ["foo"]], ["=", "value", "bar"]]]]]
+    end
+
+    it "should handle precedence" do
+      parser.parse('foo=1 or bar=2 and baz=3').should eq ["or", ["in", "certname", ["extract", "certname", ["select_fact_contents", ["and", ["=", "path", ["foo"]], ["=", "value", 1]]]]], ["and", ["in", "certname", ["extract", "certname", ["select_fact_contents", ["and", ["=", "path", ["bar"]], ["=", "value", 2]]]]], ["in", "certname", ["extract", "certname", ["select_fact_contents", ["and", ["=", "path", ["baz"]], ["=", "value", 3]]]]]]]
+      parser.parse('(foo=1 or bar=2) and baz=3').should eq ["and", ["or", ["in", "certname", ["extract", "certname", ["select_fact_contents", ["and", ["=", "path", ["foo"]], ["=", "value", 1]]]]], ["in", "certname", ["extract", "certname", ["select_fact_contents", ["and", ["=", "path", ["bar"]], ["=", "value", 2]]]]]], ["in", "certname", ["extract", "certname", ["select_fact_contents", ["and", ["=", "path", ["baz"]], ["=", "value", 3]]]]]]
+    end
+
+    it "should parse resource queries for exported resources" do
+      parser.parse('@@file[foo]').should eq ["in", "certname", ["extract", "certname", ["select_resources", ["and", ["=", "type", "File"], ["=", "title", "foo"], ["=", "exported", true]]]]]
+    end
+
+    it "should parse resource queries with type, title and parameters" do
+      parser.parse('file[foo]{bar=baz}').should eq ["in", "certname", ["extract", "certname", ["select_resources", ["and", ["=", "type", "File"], ["=", "title", "foo"], ["=", "exported", false], ["=", ["parameter", "bar"], "baz"]]]]]
+    end
+
+    it "should parse resource queries with tags" do
+      parser.parse('file[foo]{tag=baz}').should eq ["in", "certname", ["extract", "certname", ["select_resources", ["and", ["=", "type", "File"], ["=", "title", "foo"], ["=", "exported", false], ["=", "tag", "baz"]]]]]
+    end
+
+    it "should handle precedence within resource parameter queries" do
+      parser.parse('file[foo]{foo=1 or bar=2 and baz=3}').should eq ["in", "certname", ["extract", "certname", ["select_resources", ["and", ["=", "type", "File"], ["=", "title", "foo"], ["=", "exported", false], ["or", ["=", ["parameter", "foo"], 1], ["and", ["=", ["parameter", "bar"], 2], ["=", ["parameter", "baz"], 3]]]]]]]
+      parser.parse('file[foo]{(foo=1 or bar=2) and baz=3}').should eq ["in", "certname", ["extract", "certname", ["select_resources", ["and", ["=", "type", "File"], ["=", "title", "foo"], ["=", "exported", false], ["and", ["or", ["=", ["parameter", "foo"], 1], ["=", ["parameter", "bar"], 2]], ["=", ["parameter", "baz"], 3]]]]]]
+    end
+
+    it "should capitalize class names" do
+      parser.parse('class[foo::bar]').should eq ["in", "certname", ["extract", "certname", ["select_resources", ["and", ["=", "type", "Class"], ["=", "title", "Foo::Bar"], ["=", "exported", false]]]]]
+    end
+
+    it "should parse resource queries with regeexp title matching" do
+      parser.parse('class[~foo]').should eq ["in", "certname", ["extract", "certname", ["select_resources", ["and", ["=", "type", "Class"], ["~", "title", "foo"], ["=", "exported", false]]]]]
+    end
+
+    it "should be able to negate expressions" do
+      parser.parse('not foo=bar').should eq ["not", ["in", "certname", ["extract", "certname", ["select_fact_contents", ["and", ["=", "path", ["foo"]], ["=", "value", "bar"]]]]]]
+    end
+
+    it "should handle single string expressions" do
+      parser.parse('foo.bar.com').should eq ["~", "certname", "foo\\.bar\\.com"]
+    end
+
+    it "should handle structured facts" do
+      parser.parse('foo.bar=baz').should eq ["in", "certname", ["extract", "certname", ["select_fact_contents", ["and", ["=", "path", ["foo", "bar"]], ["=", "value", "baz"]]]]]
+    end
+
+    it "should handle structured facts with array component" do
+      parser.parse('foo.bar.0=baz').should eq ["in", "certname", ["extract", "certname", ["select_fact_contents", ["and", ["=", "path", ["foo", "bar", 0]], ["=", "value", "baz"]]]]]
+    end
+
+    it "should handle structured facts with match operator" do
+      parser.parse('foo.bar.~".*"=baz').should eq ["in", "certname", ["extract", "certname", ["select_fact_contents", ["and", ["~>", "path", ["foo", "bar", ".*"]], ["=", "value", "baz"]]]]]
+    end
+
+    it "should handle structured facts with wildcard operator" do
+      parser.parse('foo.bar.*=baz').should eq ["in", "certname", ["extract", "certname", ["select_fact_contents", ["and", ["~>", "path", ["foo", "bar", ".*"]], ["=", "value", "baz"]]]]]
+    end
+
+    it "should handle #node subqueries" do
+      parser.parse('#node.catalog_environment=production').should eq ["in", "certname", ["extract", "certname", ["select_nodes", ["=", "catalog_environment", "production"]]]]
+    end
+
+    it "should handle #node subqueries with block of conditions" do
+      parser.parse('#node { catalog_environment=production }').should eq ["in", "certname", ["extract", "certname", ["select_nodes", ["=", "catalog_environment", "production"]]]]
+    end
+
+    it "should handle #node subquery combined with fact query" do
+      parser.parse('#node.catalog_environment=production and foo=bar').should eq ["and", ["in", "certname", ["extract", "certname", ["select_nodes", ["=", "catalog_environment", "production"]]]], ["in", "certname", ["extract", "certname", ["select_fact_contents", ["and", ["=", "path", ["foo"]], ["=", "value", "bar"]]]]]]
+    end
+
+    it "should escape non match parts on structured facts with match operator" do
+      parser.parse('"foo.bar".~".*"=baz').should eq ["in", "certname", ["extract", "certname", ["select_fact_contents", ["and", ["~>", "path", ["foo\\.bar", ".*"]], ["=", "value", "baz"]]]]]
+    end
+
+    it "should parse dates in queries" do
+      date = Time.new(2014,9,9).iso8601
+      parser.parse('#node.report_timestamp<@"Sep 9, 2014"').should eq ["in", "certname", ["extract", "certname", ["select_nodes", ["<", "report_timestamp", date]]]]
+    end
+  end
+
+  context "facts_query" do
+    let(:parser) { PuppetDB::Parser.new }
+    it 'should return a query for all if no facts are specified' do
+      parser.facts_query('kernel=Linux').should eq ["in", "certname", ["extract", "certname", ["select_fact_contents", ["and", ["=", "path", ["kernel"]], ["=", "value", "Linux"]]]]]
+    end
+
+    it 'should return a query for specific facts if they are specified' do
+      parser.facts_query('kernel=Linux', ['ipaddress']). should eq ["and", ["in", "certname", ["extract", "certname", ["select_fact_contents", ["and", ["=", "path", ["kernel"]], ["=", "value", "Linux"]]]]], ["or", ["=", "name", "ipaddress"]]]
+    end
+
+    it 'should return a query for matching facts on all nodes if query is missing' do
+      parser.facts_query('', ['ipaddress']).should eq ["or", ["=", "name", "ipaddress"]]
+    end
+  end
+
+  context 'facts_hash' do
+    let(:parser) { PuppetDB::Parser.new }
+    it 'should merge facts into a nested hash' do
+      parser.facts_hash([
+        {"certname"=>"ip-172-31-45-32.eu-west-1.compute.internal", "environment"=>"production", "name"=>"kernel", "value"=>"Linux"},
+        {"certname"=>"ip-172-31-33-234.eu-west-1.compute.internal", "environment"=>"production", "name"=>"kernel", "value"=>"Linux"},
+        {"certname"=>"ip-172-31-5-147.eu-west-1.compute.internal", "environment"=>"production", "name"=>"kernel", "value"=>"Linux"},
+        {"certname"=>"ip-172-31-45-32.eu-west-1.compute.internal", "environment"=>"production", "name"=>"fqdn", "value"=>"ip-172-31-45-32.eu-west-1.compute.internal"},
+        {"certname"=>"ip-172-31-33-234.eu-west-1.compute.internal", "environment"=>"production", "name"=>"fqdn", "value"=>"ip-172-31-33-234.eu-west-1.compute.internal"},
+        {"certname"=>"ip-172-31-5-147.eu-west-1.compute.internal", "environment"=>"production", "name"=>"fqdn", "value"=>"ip-172-31-5-147.eu-west-1.compute.internal"}
+      ]).should eq(
+        "ip-172-31-45-32.eu-west-1.compute.internal"=>{"kernel"=>"Linux", "fqdn"=>"ip-172-31-45-32.eu-west-1.compute.internal"},
+        "ip-172-31-33-234.eu-west-1.compute.internal"=>{"kernel"=>"Linux", "fqdn"=>"ip-172-31-33-234.eu-west-1.compute.internal"},
+        "ip-172-31-5-147.eu-west-1.compute.internal"=>{"kernel"=>"Linux", "fqdn"=>"ip-172-31-5-147.eu-west-1.compute.internal"}
+      )
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-puppetdb
 version: !ruby/object:Gem::Version
-  version: 1.6.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Erik Dalen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-09 00:00:00.000000000 Z
+date: 2015-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -171,13 +171,6 @@ files:
 - lib/hiera/backend/puppetdb_backend.rb
 - lib/puppet/application/query.rb
 - lib/puppet/face/query.rb
-- lib/puppet/parser/functions/pdbfactquery.rb
-- lib/puppet/parser/functions/pdbnodequery.rb
-- lib/puppet/parser/functions/pdbnodequery_all.rb
-- lib/puppet/parser/functions/pdbquery.rb
-- lib/puppet/parser/functions/pdbresourcequery.rb
-- lib/puppet/parser/functions/pdbresourcequery_all.rb
-- 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
@@ -188,18 +181,11 @@ files:
 - lib/puppetdb/lexer.rb
 - lib/puppetdb/lexer.rex
 - lib/puppetdb/parser.rb
-- lib/puppetdb/util.rb
+- lib/puppetdb/parser_helper.rb
 - spec/spec_helper.rb
-- spec/unit/puppet/parser/functions/pdbfactquery_spec.rb
-- spec/unit/puppet/parser/functions/pdbnodequery_all_spec.rb
-- spec/unit/puppet/parser/functions/pdbnodequery_spec.rb
-- spec/unit/puppet/parser/functions/pdbquery_spec.rb
-- spec/unit/puppet/parser/functions/pdbresourcequery_all_spec.rb
-- spec/unit/puppet/parser/functions/pdbresourcequery_spec.rb
-- spec/unit/puppet/parser/functions/pdbstatusquery_spec.rb
 - spec/unit/puppet/parser/functions/query_facts_spec.rb
 - spec/unit/puppet/parser/functions/query_nodes_spec.rb
-- spec/unit/puppetdb/connection_spec.rb
+- spec/unit/puppetdb/parser_spec.rb
 homepage: https://github.com/dalen/puppet-puppetdbquery
 licenses:
 - Apache v2
@@ -225,17 +211,10 @@ signing_key:
 specification_version: 4
 summary: Query functions for PuppetDB
 test_files:
-- spec/spec_helper.rb
-- spec/unit/puppetdb/connection_spec.rb
-- spec/unit/puppet/parser/functions/query_facts_spec.rb
-- spec/unit/puppet/parser/functions/pdbfactquery_spec.rb
-- spec/unit/puppet/parser/functions/pdbstatusquery_spec.rb
-- spec/unit/puppet/parser/functions/pdbnodequery_all_spec.rb
-- spec/unit/puppet/parser/functions/pdbquery_spec.rb
+- spec/unit/puppetdb/parser_spec.rb
 - spec/unit/puppet/parser/functions/query_nodes_spec.rb
-- spec/unit/puppet/parser/functions/pdbresourcequery_spec.rb
-- spec/unit/puppet/parser/functions/pdbresourcequery_all_spec.rb
-- spec/unit/puppet/parser/functions/pdbnodequery_spec.rb
+- spec/unit/puppet/parser/functions/query_facts_spec.rb
+- spec/spec_helper.rb
 - examples/query_resource_examples.pp
 - examples/query_node_examples.pp
 - examples/nova_functions.pp

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

@@ -1,31 +0,0 @@
-module Puppet::Parser::Functions
-  newfunction(:pdbfactquery, :type => :rvalue, :doc => "\
-    Perform a PuppetDB fact query
-
-    The first argument is the node to get facts for.
-    Second argument is optional, if specified only return that specific fact.
-
-    Examples:
-    # Get hash of facts for foo.example.com
-    pdbfactquery('foo.example.com')
-    # Get the uptime fact for foo.example.com
-    pdbfactquery('foo.example.com', 'uptime')") do |args|
-
-    raise(Puppet::ParseError, "pdbquery(): Wrong number of arguments " +
-                "given (#{args.size} for 1 or 2)") if args.size < 1 or args.size > 2
-
-    Puppet::Parser::Functions.autoloader.load(:pdbquery) unless Puppet::Parser::Functions.autoloader.loaded?(:pdbquery)
-
-    node, fact = args
-    if node.is_a?(Array) then
-      node.collect { |n| function_pdbfactquery([n,fact]) }
-    else
-      facts = function_pdbquery(["facts/#{args[0]}"])['facts']
-      if fact then
-        facts[fact]
-      else
-        facts
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-module Puppet::Parser::Functions
-  newfunction(:pdbnodequery, :type => :rvalue, :doc => "\
-    Perform a PuppetDB node query
-
-    The first argument is the node query, it has to be an array.
-    Second argument is optional but allows you to specify a resource query
-    that the nodes returned also have to match.
-
-    This function excludes any deactivated hosts.
-
-    Returns a array of strings with the certname of the nodes (fqdn by default).
-
-    # Return an array of active nodes with an uptime more than 30 days
-    $ret = pdbnodequery(['>',['fact','uptime_days'],30])
-
-    # Return an array of active nodes with an uptime more than 30 days and
-    # having the class 'apache'
-    $ret = pdbnodequery(['>',['fact','uptime_days'],30], ['and',['=','type','Class'],['=','title','Apache']])") do |args|
-
-    raise(Puppet::ParseError, "pdbquery(): Wrong number of arguments " +
-                "given (#{args.size} for 1 or 2)") if args.size < 1 or args.size > 2
-
-    Puppet::Parser::Functions.autoloader.load(:pdbquery) unless Puppet::Parser::Functions.autoloader.loaded?(:pdbquery)
-    Puppet::Parser::Functions.autoloader.load(:pdbresourcequery) unless Puppet::Parser::Functions.autoloader.loaded?(:pdbresourcequery)
-
-    nodeq, resq = args
-
-    nodeqnodes = function_pdbquery(['nodes', ['and',['=',['node','active'],true],nodeq] ])
-
-    if resq then
-      resqnodes = function_pdbresourcequery([resq, 'certname'])
-      nodeqnodes & resqnodes
-    else
-      # No resource query to worry about, just return the nodequery
-      nodeqnodes
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-module Puppet::Parser::Functions
-  newfunction(:pdbnodequery_all, :type => :rvalue, :doc => "\
-    Perform a PuppetDB node query
-
-    The first argument is the node query.
-    Second argument is optional but allows you to specify a resource query
-    that the nodes returned also have to match.
-
-    Returns a array of strings with the certname of the nodes (fqdn by default).
-
-    # Return an array of both active and deactivaded nodes with an uptime more than 30 days
-    $ret = pdbnodequery_all(['and',['>',['fact','uptime_days'],30]])
-
-    # Return an array of both active and deactivated nodes with an uptime more
-    # than 30 days and having the class 'apache'
-    $ret = pdbnodequery_all(
-      ['>',['fact','uptime_days'],30],
-      ['and',
-        ['=','type','Class'],
-        ['=','title','Apache']])") do |args|
-
-    raise(Puppet::ParseError, "pdbquery_all(): Wrong number of arguments " +
-                "given (#{args.size} for 1 or 2)") if args.size < 1 or args.size > 2
-
-    Puppet::Parser::Functions.autoloader.load(:pdbquery) unless Puppet::Parser::Functions.autoloader.loaded?(:pdbquery)
-    Puppet::Parser::Functions.autoloader.load(:pdbresourcequery_all) unless Puppet::Parser::Functions.autoloader.loaded?(:pdbresourcequery_all)
-
-    nodeq, resq = args
-
-    nodeqnodes = function_pdbquery(['nodes', nodeq])
-
-    if resq then
-      resqnodes = function_pdbresourcequery_all([resq, 'certname'])
-      nodeqnodes & resqnodes
-    else
-      # No resource query to worry about, just return the nodequery
-      nodeqnodes
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-module Puppet::Parser::Functions
-  newfunction(:pdbquery, :type => :rvalue, :doc => "\
-    Perform a PuppetDB query
-
-    The first argument is the URL path that should be queried, for
-    example 'nodes' or 'status/nodes/<nodename>'.
-    The second argument if supplied if the query parameter, if it is
-    a string it is assumed to be JSON formatted and sent as is,
-    anything else is converted to JSON and then sent.
-
-    Example: pdbquery('nodes', ['=', ['node', 'active'], true ])") do |args|
-
-    raise(Puppet::ParseError, "pdbquery(): Wrong number of arguments " +
-      "given (#{args.size} for 1 or 2)") if args.size < 1 or args.size > 2
-
-    require 'puppet/network/http_pool'
-    require 'uri'
-    require 'puppet/util/puppetdb'
-    require 'puppet/indirector/rest'
-
-    # Query type (URL path)
-    t, q = args
-
-    # Query contents
-    if q then
-      # Convert to JSON if it isn't already
-      q=q.to_pson unless q.is_a? String
-      params = URI.escape("?query=#{q}")
-    else
-      params = ''
-    end
-
-    conn = Puppet::Network::HttpPool.http_instance(Puppet::Util::Puppetdb.server, Puppet::Util::Puppetdb.port, use_ssl = true)
-    response = conn.get("/v1/#{t}#{params}", { "Accept" => "application/json",})
-
-    unless response.kind_of?(Net::HTTPSuccess)
-      raise Puppet::ParseError, "PuppetDB query error: [#{response.code}] #{response.msg}"
-    end
-    PSON.load(response.body)
-  end
-end

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

@@ -1,39 +0,0 @@
-module Puppet::Parser::Functions
-  newfunction(:pdbresourcequery, :type => :rvalue, :doc => "\
-    Perform a PuppetDB resource query
-
-    The first argument is the resource query, it has to be an array.
-    Second argument is optional but allows you to specify the item you want
-    from the returned hash.
-
-    This function excludes any deactivated hosts.
-
-    Returns an array of hashes or array of strings if second argument is provided.
-
-    Examples:
-    # Return an array of hashes describing all files that are owned by root on active hosts.
-    $ret = pdbresourcequery(
-      ['and',
-        ['=','type','File'],
-        ['=',['parameter','owner'],'root']])
-
-    # Return an array of host names having those resources
-    $ret = pdbresourcequery(
-      ['and',
-        ['=','type','File'],
-        ['=',['parameter','owner'],'root']], 'certname')") do |args|
-
-    raise(Puppet::ParseError, "pdbresourcequery(): Wrong number of arguments " +
-                "given (#{args.size} for 1 or 2)") if args.size < 1 or args.size > 2
-
-    Puppet::Parser::Functions.autoloader.load(:pdbquery) unless Puppet::Parser::Functions.autoloader.loaded?(:pdbquery)
-
-    resq, info = args
-    ret = function_pdbquery(['resources', ['and',['=',['node','active'],true],resq] ])
-    if info then
-      ret.collect {|x| x[info]}
-    else
-      ret
-    end
-  end
-end