puppetdb-ruby 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+vendor
+.bundle
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+gem "httparty"
+
+group :test do
+  gem 'rspec'
+  gem 'mocha'
+end

data/LICENSE

@@ -0,0 +1,17 @@
+puppetdb-ruby
+
+Copyright (C) 2013 Puppet Labs Inc
+
+Puppet Labs can be contacted at: info@puppetlabs.com
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,57 @@
+# puppetdb-ruby
+
+a simple gem for interacting with the
+[PuppetDB](https://github.com/puppetlabs/puppetdb) API.
+
+## Installation
+
+gem install puppetdb-ruby
+
+## Usage
+
+```ruby
+require 'puppetdb'
+
+# Defaults to latest API version.
+
+# non-ssl
+client = PuppetDB::Client({:server => 'http://localhost:8080'})
+
+# ssl
+client = PuppetDB::Client({
+    :server => 'https://localhost:8081',
+    :pem    => {
+        :key     => "keyfile",
+        :cert    => "certfile",
+        :ca_file => "cafile"
+    }})
+
+response = client.request([:and,
+                 [:'=', ['fact', 'kernel'], 'Linux'],
+                 [:>, ['fact', 'uptime_days'], 30]]], {:limit => 10})
+nodes = response.data
+
+# queries are composable
+
+uptime = PuppetDB::Query[:>, ['fact', 'uptime_days'], 30]
+redhat = PuppetDB::Query[:'=', ['fact', 'osfamily'], 'RedHat']
+debian = PuppetDB::Query[:'=', ['fact', 'osfamily'], 'Debian']
+
+client.request uptime.and(debian)
+client.request uptime.and(redhat)
+client.request uptime.and(debian.or(redhat))
+```
+
+## tests
+
+bundle install
+bundle exec rspec
+
+## Authors
+
+Nathaniel Smith <nathaniel@puppetlabs.com>
+Lindsey Smith <lindsey@puppetlabs.com>
+
+## License
+
+See LICENSE.

data/lib/puppetdb.rb

@@ -0,0 +1,3 @@
+require File.join(File.dirname(__FILE__), 'puppetdb', 'client')
+require File.join(File.dirname(__FILE__), 'puppetdb', 'response')
+require File.join(File.dirname(__FILE__), 'puppetdb', 'query')

data/lib/puppetdb/client.rb

@@ -0,0 +1,111 @@
+require 'httparty'
+require 'logger'
+
+module PuppetDB
+  class APIError < Exception
+    attr_reader :code, :response
+    def initialize(response)
+      @response = response
+    end
+  end
+
+  class FixSSLConnectionAdapter < HTTParty::ConnectionAdapter
+    def attach_ssl_certificates(http, options)
+      http.cert    = OpenSSL::X509::Certificate.new(File.read(options[:pem]['cert']))
+      http.key     = OpenSSL::PKey::RSA.new(File.read(options[:pem]['key']))
+      http.ca_file = options[:pem]['ca_file']
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+    end
+  end
+
+  class Client
+    include HTTParty
+    attr_reader :use_ssl
+    attr_writer :logger
+
+    def hash_get(hash, key)
+      untouched = hash[key]
+      return untouched if untouched
+
+      sym = hash[key.to_sym()]
+      return sym if sym
+
+      str = hash[key.to_s()]
+      return str if str
+
+      nil
+    end
+
+    def hash_includes?(hash, *sought_keys)
+      sought_keys.each {|x| return false unless hash.include?(x)}
+      true
+    end
+
+    def debug(msg)
+      if @logger
+        @logger.debug(msg)
+      end
+    end
+
+    def initialize(settings, version=3)
+      @version = version
+
+      server = hash_get(settings, 'server')
+      pem    = hash_get(settings, 'pem')
+
+      scheme = URI.parse(server).scheme
+
+      unless ['http', 'https'].include? scheme
+        error_msg = "Configuration error: :server must specify a protocol of either http or https"
+        raise error_msg
+      end
+
+      @use_ssl = scheme == 'https'
+      if @use_ssl
+        unless pem && hash_includes?(pem, 'key', 'cert', 'ca_file')
+          error_msg = 'Configuration error: https:// specified but pem is missing or incomplete. It requires cert, key, and ca_file.'
+          raise error_msg
+        end
+
+        self.class.default_options = {:pem => pem}
+        self.class.connection_adapter(FixSSLConnectionAdapter)
+      end
+
+      self.class.base_uri(server + '/v' + version.to_s())
+    end
+
+    def raise_if_error(response)
+      if response.code.to_s() =~ /^[4|5]/
+        raise APIError.new(response)
+      end
+    end
+
+    def request(endpoint, query, opts={})
+      query = PuppetDB::Query.maybe_promote(query)
+      json_query = query.build()
+
+      path = "/" + endpoint
+
+      filtered_opts = {'query' => json_query}
+      opts.each do |k,v|
+        if k == :counts_filter
+          filtered_opts['counts-filter'] = JSON.dump(v)
+        else
+          filtered_opts[k.to_s.sub("_", "-")] = v
+        end
+      end
+
+      debug("#{path} #{json_query} #{opts}")
+
+      ret = self.class.get(path, :query => filtered_opts)
+      raise_if_error(ret)
+
+      total = ret.headers['X-Records']
+      if total.nil?
+        total = ret.parsed_response.length
+      end
+
+      Response.new(ret.parsed_response, total)
+    end
+  end
+end

data/lib/puppetdb/query.rb

@@ -0,0 +1,58 @@
+require 'json'
+
+module PuppetDB
+  class Query
+    attr_reader :sexpr
+
+    def initialize(query=[])
+      @sexpr = query
+    end
+
+    def self.[](*args)
+      Query.new(args)
+    end
+
+    def self.maybe_promote(query)
+      return Query.new(query) unless query.class == Query
+      query
+    end
+    
+    def empty?
+      @sexpr.empty?
+    end
+
+    def compose(query)
+      query = self.class.maybe_promote(query)
+
+      # If an operand is the empty query ([]), compose returns a copy
+      # of the non-empty operand. If both operands are empty, the
+      # empty query is returned. If both operands are non-empty, the
+      # compose continues.
+      if query.empty? && !self.empty?
+        Query.new(@sexpr)
+      elsif self.empty? && !query.empty?
+        Query.new(query.sexpr())
+      elsif self.empty? && query.empty?
+        Query.new([])
+      else
+        yield query
+      end
+    end
+
+    def and(query)
+      compose(query) { |q| Query.new([:and, @sexpr, q.sexpr()]) }
+    end
+
+    def or(query)
+      compose(query) { |q| Query.new([:or, @sexpr, q.sexpr()]) }
+    end
+
+    def push(query)
+      compose(query) { |q| Query.new(@sexpr.dup.push(q.sexpr())) }
+    end
+
+    def build
+      JSON.dump(@sexpr)
+    end
+  end
+end

data/lib/puppetdb/response.rb

@@ -0,0 +1,10 @@
+module PuppetDB
+  class Response
+    attr_reader :data, :total_records
+
+    def initialize(data, total_records=nil)
+      @data = data
+      @total_records = total_records
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+RSpec.configure do |conf|
+  conf.mock_framework = :mocha
+end

data/spec/unit/client_spec.rb

@@ -0,0 +1,179 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'puppetdb')
+
+def make_mock_response
+  m = mock()
+  m.stubs(:code).returns(200)
+  m.expects(:parsed_response).returns(['foo'])
+  m
+end
+
+def make_mock_query
+  m = mock()
+  m.expects(:build)
+  m.expects(:summarize_by).returns(m)
+  m
+end
+
+def expect_include_total(mock_query)
+  mock_query.expects(:include_total).with(true)
+  mock_query
+end
+
+describe 'raise_if_error' do
+  settings = {'server' => 'http://localhost:8080'}
+
+  it 'works with 4xx' do
+    response = mock()
+    response.stubs(:code).returns(400)
+
+    lambda { PuppetDB::Client.new(settings).raise_if_error(response) }.should raise_error
+  end
+
+  it 'works with 5xx' do
+    response = mock()
+    response.stubs(:code).returns(500)
+
+    lambda { PuppetDB::Client.new(settings).raise_if_error(response) }.should raise_error
+  end
+
+  it 'ignores 2xx' do
+    response = mock()
+    response.stubs(:code).returns(200)
+
+    lambda { PuppetDB::Client.new(settings).raise_if_error(response) }.should_not raise_error
+  end
+
+  it 'ignores 3xx' do
+    response = mock()
+    response.stubs(:code).returns(300)
+
+    lambda { PuppetDB::Client.new(settings).raise_if_error(response) }.should_not raise_error
+  end
+end
+
+describe 'SSL support' do
+  describe 'when http:// is specified' do
+    it 'does not use ssl' do
+      settings = {
+        'server' => 'http://localhost:8080'
+      }
+
+      r = PuppetDB::Client.new(settings)
+      expect(r.use_ssl).to eq(false)
+    end
+  end
+
+  describe 'when https:// is specified' do
+    it 'uses ssl' do
+      settings = {
+        'server' => 'https://localhost:8081',
+        'pem' => {
+          'cert'    => 'foo',
+          'key'     => 'bar',
+          'ca_file' => 'baz'
+        }
+      }
+
+      r = PuppetDB::Client.new(settings)
+      expect(r.use_ssl).to eq(true)
+    end
+
+    it 'does not tolerate lack of pem' do
+      settings = {
+        :server => 'https://localhost:8081'
+      }
+
+      lambda { PuppetDB::Client.new(settings) }.should raise_error
+    end
+
+    it 'does not tolerate lack of key' do
+      settings = {
+        'server' => 'https://localhost:8081',
+        'pem'    => {
+          'cert' => 'foo',
+          'ca_file' => 'bar'
+        }
+      }
+
+      lambda { PuppetDB::Client.new(settings) }.should raise_error
+    end
+
+    it 'does not tolerate lack of cert' do
+      settings = {
+        'server' => 'https://localhost:8081',
+        'pem'    => {
+          'key' => 'foo',
+          'ca_file' => 'bar'
+        }
+      }
+
+      lambda { PuppetDB::Client.new(settings) }.should raise_error
+    end
+
+    it 'does not tolerate lack of ca_file' do
+      settings = {
+        'server' => 'https://localhost:8081',
+        'pem'    => {
+          'key' => 'foo',
+          'cert' => 'bar'
+        }
+      }
+
+      lambda { PuppetDB::Client.new(settings) }.should raise_error
+    end
+  end
+
+  describe 'when a protocol is missing from config file' do
+    it 'raises an exception' do
+      settings = {
+        'server' => 'localhost:8080'
+      }
+
+      lambda { PuppetDB::Client.new(settings) }.should raise_error
+    end
+  end
+end
+
+describe 'request' do
+  settings = {:server => 'http://localhost'}
+
+  it 'works with array instead of Query' do
+    client = PuppetDB::Client.new(settings)
+
+    mock_response = mock()
+    mock_response.expects(:code).returns(200)
+    mock_response.expects(:headers).returns({'X-Records' => 0})
+    mock_response.expects(:parsed_response).returns([])
+
+    PuppetDB::Client.expects(:get).returns(mock_response).at_least_once.with() do |path, opts|
+      opts[:query] == {'query' => '[1,2,3]'}
+    end
+    client.request('/foo', [1,2,3])
+  end
+
+  it 'processes options correctly' do
+    client = PuppetDB::Client.new(settings)
+
+    mock_response = mock()
+    mock_response.expects(:code).returns(200)
+    mock_response.expects(:headers).returns({'X-Records' => 0})
+    mock_response.expects(:parsed_response).returns([])
+
+    PuppetDB::Client.expects(:get).returns(mock_response).at_least_once.with() do |path, opts|
+      opts == {
+        :query => {
+          'query'         => '[1,2,3]',
+          'limit'         => 10,
+          'counts-filter' => '[4,5,6]',
+          'foo-bar'       => 'foo'
+      }}
+    end
+
+    client.request('/foo', PuppetDB::Query[1,2,3], {
+                     :limit => 10,
+                     :counts_filter => [4,5,6],
+                     :foo_bar => "foo"
+                   })
+  end
+end

data/spec/unit/query_spec.rb

@@ -0,0 +1,179 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'puppetdb')
+
+def make_mock_response
+  m = mock()
+  m.stubs(:code).returns(200)
+  m.expects(:parsed_response).returns(['foo'])
+  m
+end
+
+def make_mock_query
+  m = mock()
+  m.expects(:build)
+  m.expects(:summarize_by).returns(m)
+  m
+end
+
+def expect_include_total(mock_query)
+  mock_query.expects(:include_total).with(true)
+  mock_query
+end
+
+describe 'raise_if_error' do
+  settings = {'server' => 'http://localhost:8080'}
+
+  it 'works with 4xx' do
+    response = mock()
+    response.stubs(:code).returns(400)
+
+    lambda { PuppetDB::Client.new(settings).raise_if_error(response) }.should raise_error
+  end
+
+  it 'works with 5xx' do
+    response = mock()
+    response.stubs(:code).returns(500)
+
+    lambda { PuppetDB::Client.new(settings).raise_if_error(response) }.should raise_error
+  end
+
+  it 'ignores 2xx' do
+    response = mock()
+    response.stubs(:code).returns(200)
+
+    lambda { PuppetDB::Client.new(settings).raise_if_error(response) }.should_not raise_error
+  end
+
+  it 'ignores 3xx' do
+    response = mock()
+    response.stubs(:code).returns(300)
+
+    lambda { PuppetDB::Client.new(settings).raise_if_error(response) }.should_not raise_error
+  end
+end
+
+describe 'SSL support' do
+  describe 'when http:// is specified' do
+    it 'does not use ssl' do
+      settings = {
+        'server' => 'http://localhost:8080'
+      }
+
+      r = PuppetDB::Client.new(settings)
+      expect(r.use_ssl).to eq(false)
+    end
+  end
+
+  describe 'when https:// is specified' do
+    it 'uses ssl' do
+      settings = {
+        'server' => 'https://localhost:8081',
+        'pem' => {
+          'cert'    => 'foo',
+          'key'     => 'bar',
+          'ca_file' => 'baz'
+        }
+      }
+
+      r = PuppetDB::Client.new(settings)
+      expect(r.use_ssl).to eq(true)
+    end
+
+    it 'does not tolerate lack of pem' do
+      settings = {
+        :server => 'https://localhost:8081'
+      }
+
+      lambda { PuppetDB::Client.new(settings) }.should raise_error
+    end
+
+    it 'does not tolerate lack of key' do
+      settings = {
+        'server' => 'https://localhost:8081',
+        'pem'    => {
+          'cert' => 'foo',
+          'ca_file' => 'bar'
+        }
+      }
+
+      lambda { PuppetDB::Client.new(settings) }.should raise_error
+    end
+
+    it 'does not tolerate lack of cert' do
+      settings = {
+        'server' => 'https://localhost:8081',
+        'pem'    => {
+          'key' => 'foo',
+          'ca_file' => 'bar'
+        }
+      }
+
+      lambda { PuppetDB::Client.new(settings) }.should raise_error
+    end
+
+    it 'does not tolerate lack of ca_file' do
+      settings = {
+        'server' => 'https://localhost:8081',
+        'pem'    => {
+          'key' => 'foo',
+          'cert' => 'bar'
+        }
+      }
+
+      lambda { PuppetDB::Client.new(settings) }.should raise_error
+    end
+  end
+
+  describe 'when a protocol is missing from config file' do
+    it 'raises an exception' do
+      settings = {
+        'server' => 'localhost:8080'
+      }
+
+      lambda { PuppetDB::Client.new(settings) }.should raise_error
+    end
+  end
+end
+
+describe 'request' do
+  settings = {:server => 'http://localhost'}
+
+  it 'works with array instead of Query' do
+    client = PuppetDB::Client.new(settings)
+
+    mock_response = mock()
+    mock_response.expects(:code).returns(200)
+    mock_response.expects(:headers).returns({'X-Records' => 0})
+    mock_response.expects(:parsed_response).returns([])
+
+    PuppetDB::Client.expects(:get).returns(mock_response).at_least_once.with() do |path, opts|
+      opts[:query] == {'query' => '[1,2,3]'}
+    end
+    client.request('/foo', [1,2,3])
+  end
+
+  it 'processes options correctly' do
+    client = PuppetDB::Client.new(settings)
+
+    mock_response = mock()
+    mock_response.expects(:code).returns(200)
+    mock_response.expects(:headers).returns({'X-Records' => 0})
+    mock_response.expects(:parsed_response).returns([])
+
+    PuppetDB::Client.expects(:get).returns(mock_response).at_least_once.with() do |path, opts|
+      opts == {
+        :query => {
+          'query'         => '[1,2,3]',
+          'limit'         => 10,
+          'counts-filter' => '[4,5,6]',
+          'foo-bar'       => 'foo'
+      }}
+    end
+
+    client.request('/foo', PuppetDB::Query[1,2,3], {
+                     :limit => 10,
+                     :counts_filter => [4,5,6],
+                     :foo_bar => "foo"
+                   })
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: puppetdb-ruby
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Nathaniel Smith
+- Lindsey Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: info@puppetlabs.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- lib/puppetdb.rb
+- lib/puppetdb/client.rb
+- lib/puppetdb/query.rb
+- lib/puppetdb/response.rb
+- spec/spec_helper.rb
+- spec/unit/client_spec.rb
+- spec/unit/query_spec.rb
+homepage: https://github.com/puppetlabs/puppetdb-ruby
+licenses:
+- apache
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Simple Ruby client library for PuppetDB API
+test_files: []