ridley 1.2.6 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 66fa18198fe4d78a634471ef130b70993c6f43d4
-  data.tar.gz: f3239d671df40092749c36fda2c18969c8305161
+  metadata.gz: 29775148101ee7b5606bf8147c419def65765b13
+  data.tar.gz: fe10a06b4db60f71fb8832d4b59d62a83c2e6c17
 SHA512:
-  metadata.gz: 7c4af448f66cfc6c9928a046eb45bfec8fa9dea14bdb35d6fe6400a0ced7d7592d9063db6a5e91cbf665f1022fab1ee21a81d4c582a7dcddb5baf8012f544975
-  data.tar.gz: 9d632f851f012f1f955762319afb6a80e76e95a549283513fd3498c78e550426543bcdcd54d8ecff4fb6c426e0c2073d123a4ff34f755717094f9307d1d5d232
+  metadata.gz: ba1cc8948844efbc746b227791f349210494ff9a4c9a21ebbc8a722eccf09fb8e7b9c4f203eee3cab2ad8161b74e94f34a673ad673e4d58b33ed06e520648d2e
+  data.tar.gz: b62e6e914f5696c5806dd1f0befe0713ffed69d95bc5cd6e88c7942ecb53fb0ac68672117dffeb5431d85cd96c3f60c462ab165a50658aeec199a02d1a86576d

data/.travis.yml

@@ -4,7 +4,6 @@ env:
   - TEST_SUITE=unit
   - TEST_SUITE=acceptance
 rvm:
-  - 1.9.2
   - 1.9.3
   - 2.0.0
   - jruby-19mode

data/README.md

@@ -40,6 +40,55 @@ Ridley exposes a number of functions that return resources which you can use to
 
 For more information scroll down to the Manipulating Chef Resources section of this README.
 
+You can also tell Ridley to read the values from your Chef config (knife.rb):
+
+```ruby
+ridley = Ridley.from_chef_config('/path/to/knife.rb')
+ridley.role.all #=> [
+  #<Ridley::RoleObject chef_id:motherbrain_srv ...>,
+  #<Ridley::RoleObject chef_id:motherbrain_proxy ...>
+]
+```
+
+The mapping between Chef Config values and Ridley values is:
+
+<table>
+  <thead>
+    <tr>
+      <th>Ridley</th>
+      <th>Chef</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>validator_client</td>
+      <td>validation_client_name</td>
+    </tr>
+    <tr>
+      <td>validator_path</td>
+      <td>validation_key</td>
+    </tr>
+    <tr>
+      <td>client_name</td>
+      <td>node_name</td>
+    </tr>
+    <tr>
+      <td>server_url</td>
+      <td>chef_server_url</td>
+    </tr>
+  </tbody>
+</table>
+
+Additionally, you can leave the path blank and Ridley will perform a "knife.rb search" the same way Chef does:
+
+```ruby
+ridley = Ridley.from_chef_config
+ridley.role.all #=> [
+  #<Ridley::RoleObject chef_id:motherbrain_srv ...>,
+  #<Ridley::RoleObject chef_id:motherbrain_proxy ...>
+]
+```
+
 If you don't want to instantiate and manage a connection object you can use `Ridley.open` to open a connection, do some work, and it will be closed for you after the block executes.
 
     Ridley.open(server_url: "https://api.opscode.com", ...) do |r|

data/lib/ridley.rb

@@ -27,6 +27,26 @@ module Ridley
       Client.new(*args)
     end
 
+    # Create a new Ridley connection from the Chef config (knife.rb)
+    #
+    # @param [#to_s] filepath
+    #   the path to the Chef Config
+    #
+    # @param [hash] options
+    #   list of options to pass to the Ridley connection (@see {Ridley::Client#new})
+    #
+    # @return [Ridley::Client]
+    def from_chef_config(filepath = nil, options = {})
+      config = Ridley::Chef::Config.new(filepath).to_hash
+
+      config[:validator_client] = config.delete(:validation_client_name)
+      config[:validator_path]   = config.delete(:validation_key)
+      config[:client_name]      = config.delete(:node_name)
+      config[:server_url]       = config.delete(:chef_server_url)
+
+      Client.new(config.merge(options))
+    end
+
     def open(*args, &block)
       Client.open(*args, &block)
     end

data/lib/ridley/chef.rb

@@ -3,6 +3,7 @@ module Ridley
   # site, and Chef Cookbooks
   module Chef
     require_relative 'chef/cookbook'
+    require_relative 'chef/config'
     require_relative 'chef/chefignore'
     require_relative 'chef/digester'
   end

data/lib/ridley/chef/config.rb

@@ -0,0 +1,86 @@
+require 'buff/config/ruby'
+require 'socket'
+
+module Ridley::Chef
+  class Config < Buff::Config::Ruby
+    class << self
+      # Return the most sensible path to the Chef configuration file. This can
+      # be configured by setting a value for the 'RIDLEY_CHEF_CONFIG' environment
+      # variable.
+      #
+      # @return [String, nil]
+      def location
+        possibles = []
+
+        possibles << ENV['RIDLEY_CHEF_CONFIG'] if ENV['RIDLEY_CHEF_CONFIG']
+        possibles << File.join(ENV['KNIFE_HOME'], 'knife.rb') if ENV['KNIFE_HOME']
+        possibles << File.join(working_dir, 'knife.rb') if working_dir
+
+        # Ascending search for .chef directory siblings
+        Pathname.new(working_dir).ascend do |file|
+          sibling_chef = File.join(file, '.chef')
+          possibles << File.join(sibling_chef, 'knife.rb')
+        end if working_dir
+
+        possibles << File.join(ENV['HOME'], '.chef', 'knife.rb') if ENV['HOME']
+        possibles.compact!
+
+        location = possibles.find { |loc| File.exists?(File.expand_path(loc)) }
+
+        File.expand_path(location) unless location.nil?
+      end
+
+      private
+
+        # The current working directory
+        #
+        # @return [String]
+        def working_dir
+          ENV['PWD'] || Dir.pwd
+        end
+    end
+
+    set_assignment_mode :carefree
+
+    attribute :node_name,
+      default: Socket.gethostname
+    attribute :chef_server_url,
+      default: 'http://localhost:4000'
+    attribute :client_key,
+      default: platform_specific_path('/etc/chef/client.pem')
+    attribute :validation_key,
+      default: platform_specific_path('/etc/chef/validation.pem')
+    attribute :validation_client_name,
+      default: 'chef-validator'
+
+    attribute :cookbook_copyright,
+      default: 'YOUR_NAME'
+    attribute :cookbook_email,
+      default: 'YOUR_EMAIL'
+    attribute :cookbook_license,
+      default: 'reserved'
+
+    attribute :knife,
+      default: {}
+
+    # Prior to Chef 11, the cache implementation was based on
+    # moneta and configured via cache_options[:path]. Knife configs
+    # generated with Chef 11 will have `syntax_check_cache_path`, but older
+    # configs will have `cache_options[:path]`. `cache_options` is marked
+    # deprecated in chef/config.rb but doesn't currently trigger a warning.
+    # See also: CHEF-3715
+    attribute :syntax_check_cache_path,
+      default: Dir.mktmpdir
+    attribute :cache_options,
+      default: { path: defined?(syntax_check_cache_path) ? syntax_check_cache_path : Dir.mktmpdir }
+
+    # Create a new Chef Config object.
+    #
+    # @param [#to_s] path
+    #   the path to the configuration file
+    # @param [Hash] options
+    def initialize(path, options = {})
+      super(path || self.class.location, options)
+    end
+  end
+end

data/lib/ridley/client.rb

@@ -199,7 +199,7 @@ module Ridley
     # Perform a search the Chef Server
     #
     # @param [#to_sym, #to_s] index
-    # @param [#to_s] query_string
+    # @param [#to_s] query
     #
     # @option options [String] :sort
     #   a sort string such as 'name DESC'
@@ -208,7 +208,7 @@ module Ridley
     # @option options [Integer] :start
     #   the result number to start from
     #
-    # @return [Hash]
+    # @return [Array<ChefObject>, Hash]
     def search(index, query = nil, options = {})
       @resources_registry[:search_resource].run(index, query, @resources_registry, options)
     end
@@ -216,8 +216,8 @@ module Ridley
     # Return the array of all possible search indexes for the including connection
     #
     # @example
-    #   conn = Ridley.new(...)
-    #   conn.search_indexes =>
+    #   ridley = Ridley.new(...)
+    #   ridley.search_indexes #=>
     #     [:client, :environment, :node, :role, :"ridley-two", :"ridley-one"]
     #
     # @return [Array<Symbol, String>]
@@ -225,6 +225,35 @@ module Ridley
       @resources_registry[:search_resource].indexes
     end
 
+    # Perform a partial search the Chef Server. Partial objects or a smaller hash will be returned resulting
+    # in a faster response for larger response sets. Specify the attributes you want returned with the
+    # attributes parameter.
+    #
+    # @param [#to_sym, #to_s] index
+    # @param [#to_s] query
+    # @param [Array] attributes
+    #   an array of strings in dotted hash notation representing the attributes to return
+    #
+    # @option options [String] :sort
+    #   a sort string such as 'name DESC'
+    # @option options [Integer] :rows
+    #   how many rows to return
+    # @option options [Integer] :start
+    #   the result number to start from
+    #
+    # @example
+    #   ridley = Ridley.new(...)
+    #   ridley.partial_search(:node, "chef_environment:RESET", [ 'ipaddress', 'some.application.setting' ]) #=>
+    #     [
+    #       #<Ridley::NodeObject: chef_id:"reset.riotgames.com" normal:
+    #         { "ipaddress" => "192.168.1.1", "some" => { "application" => { "setting" => "value" } } } ...>
+    #     ]
+    #
+    # @return [Array<ChefObject>, Hash]
+    def partial_search(index, query = nil, attributes = [], options = {})
+      @resources_registry[:search_resource].partial(index, query, Array(attributes), @resources_registry, options)
+    end
+
     # The encrypted data bag secret for this connection.
     #
     # @raise [Ridley::Errors::EncryptedDataBagSecretNotFound]

data/lib/ridley/connection.rb

@@ -156,7 +156,7 @@ module Ridley
 
       local.flush
 
-      FileUtils.cp(local.path, destination)
+      FileUtils.mv(local.path, destination)
     rescue OpenURI::HTTPError => ex
       abort(ex)
     ensure

data/lib/ridley/host_connector/winrm.rb

@@ -47,10 +47,10 @@ module Ridley
         end
 
         HostConnector::Response.new(host).tap do |response|
-          command_uploaders << command_uploader = CommandUploader.new(connection)
-          command = get_command(command, command_uploader)
-
           begin
+            command_uploaders << command_uploader = CommandUploader.new(connection)
+            command = get_command(command, command_uploader)
+
             log.info "Running WinRM Command: '#{command}' on: '#{host}' as: '#{user}'"
 
             defer {

data/lib/ridley/resources/cookbook_resource.rb

@@ -1,7 +1,5 @@
 module Ridley
   class CookbookResource < Ridley::Resource
-    task_class TaskThread
-
     set_resource_path "cookbooks"
     represented_by Ridley::CookbookObject
 

data/lib/ridley/resources/search_resource.rb

@@ -20,12 +20,42 @@ module Ridley
         end
       end
 
+      # Builds and returns a query parameter string for the search API
+      #
+      # @param [String] query_string
+      #
+      # @option options [String] :sort
+      #   a sort string such as 'name DESC'
+      # @option options [Integer] :rows
+      #   how many rows to return
+      # @option options [Integer] :start
+      #   the result number to start from
+      #
+      # @example
+      #   build_param_string("*:*", rows: 5) #=> "?q=*:*&rows=5"
+      #
+      # @return [String]
+      def build_param_string(query_string, options = {})
+        query = build_query(query_string, options)
+        param = "?q=#{escape(query[:q])}"
+        param += "&sort=#{escape(query[:sort])}" if query[:sort]
+        param += "&start=#{escape(query[:start])}" if query[:start]
+        param += "&rows=#{escape(query[:rows])}" if query[:rows]
+        param
+      end
+
       # @param [#to_s] index
       #
       # @return [String]
       def query_uri(index)
         "#{resource_path}/#{index}"
       end
+
+      private
+
+        def escape(str)
+          str && URI.escape(str.to_s)
+        end
     end
 
     set_resource_path "search"
@@ -79,20 +109,76 @@ module Ridley
     def run(index, query_string, resources_registry, options = {})
       query_uri = self.class.query_uri(index)
       query     = self.class.build_query(query_string, options)
-      response  = request(:get, query_uri, query)
-
-      case index.to_sym
-      when :node
-        response[:rows].collect { |row| Ridley::NodeObject.new(resources_registry[:node_resource], row) }
-      when :role
-        response[:rows].collect { |row| Ridley::RoleObject.new(resources_registry[:role_resource], row) }
-      when :client
-        response[:rows].collect { |row| Ridley::ClientObject.new(resources_registry[:client_resource], row) }
-      when :environment
-        response[:rows].collect { |row| Ridley::EnvironmentObject.new(resources_registry[:environment_resource], row) }
-      else
-        response[:rows]
+
+      handle_response(index, resources_registry, request(:get, query_uri, query))
+    end
+
+    # Perform a partial search on the Chef server
+    #
+    # @param [#to_sym, #to_s] index
+    # @param [#to_s] query_string
+    # @param [Array] attributes
+    #   an array of strings in dotted hash notation representing the attributes to return
+    #
+    # @option options [String] :sort
+    #   a sort string such as 'name DESC'
+    # @option options [Integer] :rows
+    #   how many rows to return
+    # @option options [Integer] :start
+    #   the result number to start from
+    #
+    # @return [Array<ChefObject>, Hash]
+    def partial(index, query_string, attributes, resources_registry, options = {})
+      query_uri    = self.class.query_uri(index)
+      param_string = self.class.build_param_string(query_string, options)
+
+      chef_id = chef_id_for_index(index)
+
+      body = Hash.new.tap do |body|
+        body[chef_id] = [ chef_id ] if chef_id
+        attributes.collect { |attr| body[attr] = attr.split('.') }
       end
+
+      handle_partial(index, resources_registry, request(:post, "#{query_uri}#{param_string}", JSON.generate(body)))
     end
+
+    private
+
+      def chef_id_for_index(index)
+        chef_id = index.to_sym == :node ? Ridley::NodeObject.chef_id : nil
+      end
+
+      def handle_partial(index, registry, response)
+        chef_id = chef_id_for_index(index)
+
+        case index.to_sym
+        when :node
+          response[:rows].collect do |item|
+            attributes = Hash.new
+            item[:data].each do |key, value|
+              next if key.to_s == chef_id.to_s
+              attributes.deep_merge!(Hash.from_dotted_path(key, value))
+            end
+            registry[:node_resource].new(name: item[:data][chef_id], normal: attributes)
+          end
+        else
+          response[:rows]
+        end
+      end
+
+      def handle_response(index, registry, response)
+        case index.to_sym
+        when :node
+          response[:rows].collect { |row| NodeObject.new(registry[:node_resource], row) }
+        when :role
+          response[:rows].collect { |row| RoleObject.new(registry[:role_resource], row) }
+        when :client
+          response[:rows].collect { |row| ClientObject.new(registry[:client_resource], row) }
+        when :environment
+          response[:rows].collect { |row| EnvironmentObject.new(registry[:environment_resource], row) }
+        else
+          response[:rows]
+        end
+      end
   end
 end

data/lib/ridley/version.rb

@@ -1,3 +1,3 @@
 module Ridley
-  VERSION = "1.2.6"
+  VERSION = "1.3.0"
 end

data/ridley.gemspec

@@ -19,6 +19,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'addressable'
   s.add_dependency 'varia_model',             '~> 0.1'
+  s.add_dependency 'buff-config',             '~> 0.2'
   s.add_dependency 'buff-extensions',         '~> 0.3'
   s.add_dependency 'buff-shell_out',          '~> 0.1'
   s.add_dependency 'celluloid',               '~> 0.14.0'
@@ -34,5 +35,5 @@ Gem::Specification.new do |s|
   s.add_dependency 'solve',                   '>= 0.4.4'
   s.add_dependency 'winrm',                   '~> 1.1.0'
 
-  s.add_development_dependency "buff-ruby_engine", "~> 0.1"
+  s.add_development_dependency 'buff-ruby_engine', '~> 0.1'
 end

data/spec/unit/ridley/resources/search_resource_spec.rb

@@ -49,6 +49,44 @@ describe Ridley::SearchResource do
       end
     end
 
+    describe "::build_param_string" do
+      let(:query) { "*:*" }
+      let(:options) { Hash.new }
+
+      subject { described_class.build_param_string(query, options) }
+
+      it "returns a string containing the query string" do
+        expect(subject).to eq("?q=#{query}")
+      end
+
+      context "when the :start option is given" do
+        let(:start) { 10 }
+        let(:options) { { start: start } }
+
+        it "contains the start query param" do
+          expect(subject).to eq("?q=#{query}&start=#{start}")
+        end
+      end
+
+      context "when the :sort option is given" do
+        let(:sort) { "DESC" }
+        let(:options) { { sort: sort } }
+
+        it "contains the sort query param" do
+          expect(subject).to eq("?q=#{query}&sort=#{sort}")
+        end
+      end
+
+      context "when the :rows option is given" do
+        let(:rows) { 20 }
+        let(:options) { { rows: rows } }
+
+        it "contains the rows query param" do
+          expect(subject).to eq("?q=#{query}&rows=#{rows}")
+        end
+      end
+    end
+
     describe "::query_uri" do
       it "returns a URI path containing the search resource path and index" do
         subject.query_uri(:nodes).should eql("search/nodes")

data/spec/unit/ridley_spec.rb

@@ -14,5 +14,103 @@ describe Ridley do
         subject.new(config).should eql(client)
       end
     end
+
+    describe "from_chef_config" do
+      let(:chef_config) do
+        %(
+          node_name                "username"
+          client_key               "username.pem"
+          validation_client_name   "validator"
+          validation_key           "validator.pem"
+          chef_server_url          "https://api.opscode.com"
+          cache_options(:path => "~/.chef/checksums")
+          syntax_check_cache_path  "/foo/bar"
+        )
+      end
+
+      let(:client) { double('client') }
+      let(:path) { tmp_path.join('config.rb').to_s }
+
+      before do
+        Ridley::Client.stub(:new).and_return(client)
+        File.open(path, 'w') { |f| f.write(chef_config) }
+      end
+
+      it "creates a Ridley connection from the Chef config" do
+        Ridley::Client.should_receive(:new).with({
+          client_key: 'username.pem',
+          client_name: 'username',
+          validator_client: 'validator',
+          validator_path: 'validator.pem',
+          server_url: 'https://api.opscode.com',
+
+          cookbook_copyright: 'YOUR_NAME',
+          cookbook_email: 'YOUR_EMAIL',
+          cookbook_license: 'reserved',
+
+          knife: {},
+
+          syntax_check_cache_path: "/foo/bar",
+          cache_options: { path: "~/.chef/checksums" },
+        }).and_return(nil)
+
+        subject.from_chef_config(path)
+      end
+
+      it "allows the user to override attributes" do
+        Ridley::Client.should_receive(:new).with({
+          client_key: 'bacon.pem',
+          client_name: 'bacon',
+          validator_client: 'validator',
+          validator_path: 'validator.pem',
+          server_url: 'https://api.opscode.com',
+
+          cookbook_copyright: 'YOUR_NAME',
+          cookbook_email: 'YOUR_EMAIL',
+          cookbook_license: 'reserved',
+
+          knife: {},
+
+          syntax_check_cache_path: "/foo/bar",
+          cache_options: { path: "~/.chef/checksums" },
+        })
+
+        subject.from_chef_config(path, client_key: 'bacon.pem', client_name: 'bacon')
+      end
+
+      context "when the config location isn't explicitly specified" do
+        before do
+          dot_chef = tmp_path.join('.chef')
+          knife_rb = dot_chef.join('knife.rb')
+
+          FileUtils.mkdir_p(dot_chef)
+          File.open(knife_rb, 'w') { |f| f.write(chef_config) }
+        end
+
+        it "does a knife.rb search" do
+          Ridley::Client.should_receive(:new).with({
+            client_key: 'username.pem',
+            client_name: 'username',
+            validator_client: 'validator',
+            validator_path: 'validator.pem',
+            server_url: 'https://api.opscode.com',
+
+            cookbook_copyright: 'YOUR_NAME',
+            cookbook_email: 'YOUR_EMAIL',
+            cookbook_license: 'reserved',
+
+            knife: {},
+
+            syntax_check_cache_path: "/foo/bar",
+            cache_options: { path: "~/.chef/checksums" },
+          }).and_return(nil)
+
+          Dir.chdir(tmp_path) do
+            ENV['PWD'] = Dir.pwd
+            subject.from_chef_config
+          end
+        end
+      end
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ridley
 version: !ruby/object:Gem::Version
-  version: 1.2.6
+  version: 1.3.0
 platform: ruby
 authors:
 - Jamie Winsor
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-05 00:00:00.000000000 Z
+date: 2013-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -39,6 +39,20 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: buff-config
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: buff-extensions
   requirement: !ruby/object:Gem::Requirement
@@ -273,6 +287,7 @@ files:
 - lib/ridley/bootstrap_context/windows.rb
 - lib/ridley/chef.rb
 - lib/ridley/chef/chefignore.rb
+- lib/ridley/chef/config.rb
 - lib/ridley/chef/cookbook.rb
 - lib/ridley/chef/cookbook/metadata.rb
 - lib/ridley/chef/cookbook/syntax_check.rb
@@ -418,7 +433,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.7
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: A reliable Chef API client with a clean syntax