ruby-puppetdb 1.0.0.pre2

data/Rakefile

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'rake'
+require 'rspec/core/rake_task'
+
+task :default => [:test]
+
+desc 'Run RSpec'
+RSpec::Core::RakeTask.new(:test) do |t|
+  t.pattern = 'spec/{unit}/**/*.rb'
+  t.rspec_opts = ['--color']
+end
+
+desc "Generate Lexer and Parser"
+task :generate => [:lexer, :parser]
+
+desc "Generate Parser"
+task :parser do
+    `racc lib/puppetdb/grammar.y -o lib/puppetdb/parser.rb --superclass='PuppetDB::Lexer'`
+end
+
+desc "Generate Lexer"
+task :lexer do
+    `rex lib/puppetdb/lexer.l -o lib/puppetdb/lexer.rb`
+end

data/bin/find-nodes

@@ -0,0 +1,56 @@
+#!/usr/bin/ruby
+
+require 'puppet'
+require 'rubygems'
+require 'puppetdb/connection'
+require 'optparse'
+require 'net/http'
+require 'net/https'
+
+Puppet.initialize_settings
+
+options = {:puppetdb_host => "puppetdb",
+           :puppetdb_port => 443,
+           :fact => nil,
+           :query => nil}
+
+opt = OptionParser.new
+
+opt.on("--puppetdb [PUPPETDB]", "-p", "Host running PuppetDB (#{options[:puppetdb_host]})") do |v|
+  options[:puppetdb_host] = v
+end
+
+opt.on("--port [PORT]", "-P", Integer, "Port PuppetDB is running on (#{options[:puppetdb_port]})") do |v|
+  options[:puppetdb_port] = v
+end
+
+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|
+  options[:facts] = v.split ','
+end
+
+opt.parse!
+
+options[:query] ||= ARGV[0]
+
+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
+http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+if options[:facts]
+  query = puppetdb.parse_query(options[:query], :facts)
+  facts = puppetdb.facts(options[:facts], query, http)
+  facts.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])
+  results = puppetdb.query(:nodes, query, http)
+  hosts = results.collect { |host| host['name'] }
+  hosts.each { |host| print host + "\n" }
+end

data/examples/nova_functions.pp

@@ -0,0 +1,16 @@
+# These examples use functions that ship with the
+# puppetlabs-nova module
+
+$rabbit_connection_hash = collect_rabbit_connection('fqdn', 'architecture=amd64')
+
+notice("rabbit host: ${rabbit_connection_hash[host]}")
+notice("rabbit port: ${rabbit_connection_hash[port]}")
+notice("rabbit user: ${rabbit_connection_hash[user]}")
+notice("rabbit password: ${rabbit_connection_hash[password]}")
+
+notice(collect_nova_db_connection('fqdn', 'architecture=amd64'))
+
+$vnc_proxy_host   = unique(query_nodes('Class[Nova::Vncproxy]', 'fqdn'))
+notice("vnc proxy host ${vnc_proxy_host}")
+
+# glance api servers

data/examples/query_node_examples.pp

@@ -0,0 +1,12 @@
+# query for all nodes that have the package mysql-server applied to them
+#$nodes = query_nodes('Package["mysql-server"]')
+# query for all nodes that have the package my-server applied
+# and that have the architecture of amd64
+#$nodes = query_nodes('Package["mysql-server"] and architecture=amd64')
+# return the fqdn fact for each node instead of the node_name
+# munge to be unique if you dont want duplicates to cause failures
+#$nodes = unique(query_nodes('Package["mysql-server"] and architecture=amd64', 'fqdn'))
+
+$nodes = unique(query_nodes('Package["mysql-server"] and architecture=amd64', 'fqdn'))
+
+notify { $nodes: }

data/examples/query_resource_examples.pp

@@ -0,0 +1,48 @@
+#
+# I need to be able to query for how to connect to things:
+
+
+# I need to query the following things
+#   sql_connection
+#     mysql://nova:${nova_db_password}@${controller_node_internal}/nova
+#   rabbit_host
+#   rabbit_password
+#   rabbit_user
+
+# for the rabbitmq host
+
+# this syntax is a little strange ...
+# it makes the resource look a little extraneous
+$rabbit_resources = query_resource('Class[Nova::Rabbitmq]')
+
+$rabbit_class      = $rabbit_resources['Class[Nova::Rabbitmq]']
+$rabbit_params     = $rabbit_class['parameters']
+
+# check that only one host has been found
+$rabbit_host      = unique(query_nodes('Class[Nova::Rabbitmq]', 'fqdn') )
+notice("rabbit host: ${rabbit_host}")
+
+$rabbit_port      = $rabbit_params['port']
+notice("rabbit port: ${rabbit_port}")
+$rabbit_user      = $rabbit_params['userid']
+notice("rabbit user: ${rabbit_user}")
+$rabbit_password  = $rabbit_params['password']
+notice("rabbit password: ${rabbit_password}")
+
+# return the fqdn of the host that has applied
+$vnc_proxy_host   = unique(query_nodes('Class[Nova::Vncproxy]', 'fqdn')) 
+notice("vnc proxy host ${vnc_proxy_host}")
+# check the size of this thing and make some decisions
+
+# figure out sql connection
+$nova_db_host      = unique(query_nodes('Class[Nova::Db::Mysql]', 'fqdn')) 
+$nova_db_resources = query_resource('Class[Nova::Db::Mysql]', 'architecture=amd64')
+$nova_db_class     = $nova_db_resources['Class[Nova::Db::Mysql]']
+$nova_db_params    = $nova_db_class['parameters']
+$nova_db_name      = $nova_db_params['dbname']
+$nova_db_user      = $nova_db_params['user']
+$nova_db_password  = $nova_db_params['password']
+
+$nova_sql_conn = "mysql://${nova_db_user}:${nova_db_password}@${nova_db_host}/${nova_db_name}"
+
+notice("nova sql connection: ${nova_sql_conn}")

data/lib/puppet/application/query.rb

@@ -0,0 +1,22 @@
+require 'puppet/application/face_base'
+
+class Puppet::Application::Query < Puppet::Application::FaceBase
+  def self.setting
+    begin
+      require 'puppet'
+      require 'puppet/util/puppetdb'
+      host = Puppet::Util::Puppetdb.server || 'puppetdb'
+      port = Puppet::Util::Puppetdb.port || 8081
+    rescue Exception => e
+      Puppet.debug(e.message)
+      host = 'puppetdb'
+      port = 8081
+    end
+
+    Puppet.debug(host)
+    Puppet.debug(port)
+
+    { :host => host,
+      :port => port }
+  end
+end

data/lib/puppet/face/query.rb

@@ -0,0 +1,60 @@
+require 'puppet/application/query'
+require 'puppet/face'
+Puppet::Face.define(:query, '1.0.0') do
+  require 'puppetdb/connection'
+
+  copyright "Puppet Labs & Erik Dalén", 2012..2013
+  license   "Apache 2 license; see COPYING"
+
+
+  option '--puppetdb_host PUPPETDB' do
+    summary "Host running PuppetDB. "
+    default_to { Puppet::Application::Query.setting[:host] }
+  end
+
+  option '--puppetdb_port PORT' do
+    summary 'Port PuppetDB is running on'
+    default_to { Puppet::Application::Query.setting[:port] }
+  end
+
+  action :facts do
+    summary 'Serves as an interface to puppetdb allowing a user to query for a list of nodes'
+
+    description <<-EOT
+      Here is a ton of more useful information :)
+    EOT
+
+    arguments "<query>"
+
+    option '--facts FACTS' do
+      summary 'facts to return that represent each host'
+      description <<-EOT
+        Filter for the fact subcommand can be used to specify the facts to filter for.
+        It accepts either a string or a comma delimited list of facts.
+      EOT
+      default_to { '' }
+    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))
+    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>"
+
+    when_invoked do |query, options|
+      puppetdb = PuppetDB::Connection.new options[:puppetdb_host], options[:puppetdb_port]
+      puppetdb.query(:nodes, puppetdb.parse_query(query, :nodes))
+    end
+
+  end
+end

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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,39 @@
+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