ruby-puppetdb 1.0.0.pre2

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

@@ -0,0 +1,37 @@
+module Puppet::Parser::Functions
+  newfunction(:pdbresourcequery_all, :type => :rvalue, :doc => "\
+    Perform a PuppetDB resource query
+
+    The first argument is the resource query.
+    Second argument is optional but allows you to specify the item you want
+    from the returned hash.
+
+    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.
+    $ret = pdbresourcequery_all(
+      ['and',
+        ['=','type','File'],
+        ['=',['parameter','owner'],'root']])
+
+    # Return an array of host names having those resources
+    $ret = pdbresourcequery_all(
+      ['and',
+        ['=','type','File'],
+        ['=',['parameter','owner'],'root']], 'certname')") do |args|
+
+    raise(Puppet::ParseError, "pdbresourcequery_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)
+
+    resq, info = args
+    ret = function_pdbquery(['resources', resq])
+    if info then
+      ret.collect {|x| x[info]}
+    else
+      ret
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Puppet::Parser::Functions
+  newfunction(:pdbstatusquery, :type => :rvalue, :doc => "\
+    Perform a PuppetDB node status query
+
+    The first argument is the node to get the status for.
+    Second argument is optional, if specified only return that specific bit of
+    status, one of 'name', 'deactivated', 'catalog_timestamp' and 'facts_timestamp'.
+
+    Returns an array of hashes or a array of strings if second argument is supplied.
+
+    Examples:
+    # Get status for foo.example.com
+    pdbstatusquery('foo.example.com')
+    # Get catalog_timestamp for foo.example.com
+    pdbstatusquery('foo.example.com', 'catalog_timestamp')") 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, status = args
+
+    ret = function_pdbquery(["status/nodes/#{node}"])
+    if status then
+      ret[status]
+    else
+      ret
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+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.
+
+  The query specified should conform to the following format:
+    (Type[title] and fact_name<operator>fact_value) or ...
+    Package[mysql-server] and cluster_id=my_first_cluster
+
+  The facts list provided should be an array of fact names.
+
+  The result is a hash that maps the name of the nodes to a hash of facts that
+  contains the facts specified.
+
+EOT
+) do |args|
+  query, facts = args
+
+  require 'puppet/util/puppetdb'
+  require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'puppetdb/connection'))
+
+  puppetdb = PuppetDB::Connection.new(Puppet::Util::Puppetdb.server, Puppet::Util::Puppetdb.port)
+  if query.is_a? String then
+    query = puppetdb.parse_query query
+  end
+  puppetdb.facts(facts, query)
+end

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

@@ -0,0 +1,27 @@
+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.
+
+  The query specified should conform to the following format:
+    (Type[title] and fact_name<operator>fact_value) or ...
+    Package["mysql-server"] and cluster_id=my_first_cluster
+
+  The second argument should be single fact (this argument is optional)
+
+EOT
+) do |args|
+  query, fact = args
+
+  require 'puppet/util/puppetdb'
+  require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'puppetdb/connection'))
+
+  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.to_a
+  else
+    query = puppetdb.parse_query query, :nodes if query.is_a? String
+    puppetdb.query(:nodes, query).collect { |n| n['name'] }
+  end
+end

data/lib/puppetdb.rb

@@ -0,0 +1,2 @@
+module PuppetDB
+end

data/lib/puppetdb/astnode.rb

@@ -0,0 +1,86 @@
+class PuppetDB::ASTNode
+  attr_accessor :type, :value, :children
+
+  def initialize(type, value, children=[])
+    @type = type
+    @value = value
+    @children = children
+  end
+
+  # Generate the the query code for a subquery
+  #
+  # @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 query if from_mode == to_mode
+    return ['in', (from_mode == :nodes) ? 'name' : 'certname',
+      ['extract', (to_mode == :nodes) ? 'name' : 'certname',
+        ["select-#{to_mode.to_s}", query]]]
+  end
+
+  # Go through the AST and optimize boolean expressions into triplets etc
+  # Changes the AST in place
+  #
+  # @return The optimized AST
+  def optimize
+    case @type
+    when :booleanop
+      @children.each do |c|
+        if c.type == :booleanop and c.value == @value
+          c.children.each { |cc| @children << cc }
+          @children.delete c
+        end
+      end
+    end
+    @children.each { |c| c.optimize }
+    return 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)
+    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 # we are trying to query for facts but are in node mode, do a subquery
+        return subquery(mode, :facts, ['and', ['=', 'name', @children[0].evaluate(mode)], [op, 'value', @children[1].evaluate(mode)]])
+      when :facts
+        return ['and', ['=', 'name', @children[0].evaluate(mode)], [op, 'value', @children[1].evaluate(mode)]]
+      when :resources
+        return [op, ['parameter', @children[0].evaluate(mode)], @children[1].evaluate(mode)]
+      end
+    when :string
+      return @value.to_s
+    when :number
+      return @value
+    when :boolean
+      return @value
+    when :resourcetitle
+      return ['=', 'title', @value]
+    when :resourcetype
+      return ['=', 'type', @value]
+    end
+  end
+
+  # Evaluate all children nodes
+  #
+  # @return [Array] The evaluate results of the children nodes
+  def evaluate_children(mode)
+    return children.collect { |c| c.evaluate mode }
+  end
+end

data/lib/puppetdb/connection.rb

@@ -0,0 +1,62 @@
+require 'puppetdb'
+
+class PuppetDB::Connection
+  require 'rubygems'
+  require 'puppet'
+  require 'puppetdb/parser'
+  require 'puppet/network/http_pool'
+  require 'uri'
+  require 'json'
+
+  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)
+    @parser.scan_str(query).optimize.evaluate endpoint
+  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)
+    q = ['and', ['in', 'certname', ['extract', 'certname', ['select-facts', nodequery]]], ['or', *facts.collect { |f| ['=', 'name', f]}]]
+    facts = {}
+    query(:facts, q, http).each do |fact|
+      if facts.include? fact['certname'] then
+        facts[fact['certname']][fact['name']] = fact['value']
+      else
+        facts[fact['certname']] = {fact['name'] => fact['value']}
+      end
+    end
+    facts
+  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)
+    http ||= Puppet::Network::HttpPool.http_instance(@host, @port, @use_ssl)
+    headers = { "Accept" => "application/json" }
+
+    uri = "/v2/#{endpoint.to_s}"
+    uri += URI.escape "?query=#{query.to_json}" unless query.nil? or query.empty?
+
+    resp, data = http.get(uri, headers)
+    raise Puppet::Error, "PuppetDB query error: [#{resp.code}] #{resp.msg}, query: #{query.to_json}" unless resp.kind_of?(Net::HTTPSuccess)
+    return PSON.parse(data)
+  end
+end

data/lib/puppetdb/grammar.y

@@ -0,0 +1,57 @@
+# vim: syntax=ruby
+
+
+class PuppetDB::Parser
+
+  token LPAREN RPAREN LBRACK RBRACK LBRACE RBRACE
+  token EQUALS NOTEQUALS MATCH LESSTHAN GREATERTHAN
+  token NOT AND OR
+  token NUMBER STRING BOOLEAN
+
+  prechigh
+    right NOT
+    left  EQUALS MATCH LESSTHAN GREATERTHAN
+    left  AND
+    left  OR
+  preclow
+
+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: restype				{ result = ASTNode.new :subquery, :resources, [val[0]] }
+             | restitle				{ result = ASTNode.new :subquery, :resources, [val[0]] }
+             | resparams			{ result = ASTNode.new :subquery, :resources, [val[0]] }
+             | restype restitle			{ result = ASTNode.new :subquery, :resources, [ASTNode.new(:booleanop, :and, [val[0], val[1]])] }
+             | restitle resparams		{ result = ASTNode.new :subquery, :resources, [ASTNode.new(:booleanop, :and, [val[0], val[1]])] }
+             | restype resparams		{ result = ASTNode.new :subquery, :resources, [ASTNode.new(:booleanop, :and, [val[0], val[1]])] }
+             | restype restitle resparams	{ result = ASTNode.new :subquery, :resources, [ASTNode.new(:booleanop, :and, [val[0], val[1], val[2]])] }
+
+  restype: STRING				{ result = ASTNode.new :resourcetype, val[0] }
+  restitle: LBRACK STRING RBRACK		{ result = ASTNode.new :resourcetitle, val[1] }
+  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] }
+
+end
+---- header ----
+require 'puppetdb'
+require 'puppetdb/lexer'
+require 'puppetdb/astnode'
+

data/lib/puppetdb/lexer.l

@@ -0,0 +1,28 @@
+# vim: syntax=ruby
+
+require 'json'
+
+class PuppetDB::Lexer
+rule
+	\s			# whitespace no action
+	\(			{ [:LPAREN, text] }
+	\)			{ [:RPAREN, text] }
+	\[			{ [:LBRACK, text] }
+	\]			{ [:RBRACK, text] }
+	\{			{ [:LBRACE, text] }
+	\}			{ [:RBRACE, text] }
+	=			{ [:EQUALS, text] }
+	\!=			{ [:NOTEQUALS, text] }
+	~			{ [:MATCH, text] }
+	<			{ [:LESSTHAN, text] }
+	>			{ [:GREATERTHAN, text] }
+	not			{ [:NOT, text] }
+	and			{ [:AND, text] }
+	or			{ [:OR, text] }
+	true			{ [:BOOLEAN, true]}
+	false			{ [:BOOLEAN, false]}
+	-?\d+			{ [:NUMBER, text.to_i] }
+	-?\d+\.?(\d+)?		{ [:NUMBER, text.to_f] }
+	\"(\\.|[^\\"])*\"	{ [:STRING, JSON.load(text)] }
+	[\w_:]+			{ [:STRING, text] }
+end

data/lib/puppetdb/lexer.rb

@@ -0,0 +1,135 @@
+#--
+# DO NOT MODIFY!!!!
+# This file is automatically generated by rex 1.0.2
+# from lexical definition file "puppetdb/lexer.l".
+#++
+
+require 'racc/parser'
+# vim: syntax=ruby
+
+require 'json'
+
+module PuppetDB
+class Lexer < Racc::Parser
+  require 'strscan'
+
+  class ScanError < StandardError ; end
+
+  attr_reader :lineno
+  attr_reader :filename
+
+  def scan_setup ; end
+
+  def action &block
+    yield
+  end
+
+  def scan_str( str )
+    scan_evaluate  str
+    do_parse
+  end
+
+  def load_file( filename )
+    @filename = filename
+    open(filename, "r") do |f|
+      scan_evaluate  f.read
+    end
+  end
+
+  def scan_file( filename )
+    load_file  filename
+    do_parse
+  end
+
+  def next_token
+    @rex_tokens.shift
+  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/))
+          ;
+
+        when (text = ss.scan(/\(/))
+           @rex_tokens.push action { [:LPAREN, text] }
+
+        when (text = ss.scan(/\)/))
+           @rex_tokens.push action { [:RPAREN, text] }
+
+        when (text = ss.scan(/\[/))
+           @rex_tokens.push action { [:LBRACK, text] }
+
+        when (text = ss.scan(/\]/))
+           @rex_tokens.push action { [:RBRACK, text] }
+
+        when (text = ss.scan(/\{/))
+           @rex_tokens.push action { [:LBRACE, text] }
+
+        when (text = ss.scan(/\}/))
+           @rex_tokens.push action { [:RBRACE, text] }
+
+        when (text = ss.scan(/=/))
+           @rex_tokens.push action { [:EQUALS, text] }
+
+        when (text = ss.scan(/\!=/))
+           @rex_tokens.push action { [:NOTEQUALS, text] }
+
+        when (text = ss.scan(/~/))
+           @rex_tokens.push action { [:MATCH, text] }
+
+        when (text = ss.scan(/</))
+           @rex_tokens.push action { [:LESSTHAN, text] }
+
+        when (text = ss.scan(/>/))
+           @rex_tokens.push action { [:GREATERTHAN, text] }
+
+        when (text = ss.scan(/not/))
+           @rex_tokens.push action { [:NOT, text] }
+
+        when (text = ss.scan(/and/))
+           @rex_tokens.push action { [:AND, text] }
+
+        when (text = ss.scan(/or/))
+           @rex_tokens.push action { [:OR, text] }
+
+        when (text = ss.scan(/true/))
+           @rex_tokens.push action { [:BOOLEAN, true]}
+
+        when (text = ss.scan(/false/))
+           @rex_tokens.push action { [:BOOLEAN, false]}
+
+        when (text = ss.scan(/-?\d+/))
+           @rex_tokens.push action { [:NUMBER, text.to_i] }
+
+        when (text = ss.scan(/-?\d+\.?(\d+)?/))
+           @rex_tokens.push action { [:NUMBER, text.to_f] }
+
+        when (text = ss.scan(/\"(\\.|[^\\"])*\"/))
+           @rex_tokens.push action { [:STRING, JSON.load(text)] }
+
+        when (text = ss.scan(/[\w_:]+/))
+           @rex_tokens.push action { [:STRING, text] }
+
+        else
+          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
+    end  # until ss
+  end  # def scan_evaluate
+
+end # class
+end # module