ridley 0.11.0.rc1 → 0.11.1

data/.travis.yml

@@ -1,6 +1,7 @@
-script: "bundle exec thor spec:unit"
+script: "bundle exec thor spec:all"
 language: ruby
 rvm:
   - 1.9.2
   - 1.9.3
-  - jruby-19mode
+  - 2.0.0
+#  - jruby-19mode # temporarily disable until ChefZero works with JRuby

data/Gemfile

@@ -45,4 +45,5 @@ group :test do
   gem 'fuubar'
   gem 'json_spec'
   gem 'webmock'
+  gem 'chef-zero'
 end

data/Guardfile

@@ -12,10 +12,10 @@ guard 'yard', stdout: '/dev/null', stderr: '/dev/null' do
   watch(%r{ext/.+\.c})
 end
 
-guard 'rspec', cli: "--color --drb --format Fuubar --tag ~type:acceptance", all_on_start: false, all_after_pass: false do
+guard 'rspec', cli: "--color --drb --format Fuubar", all_on_start: false, all_after_pass: false do
   watch(%r{^spec/unit/.+_spec\.rb$})
   watch(%r{^spec/acceptance/.+_spec\.rb$})
-  
+
   watch(%r{^lib/(.+)\.rb$})          { |m| "spec/unit/#{m[1]}_spec.rb" }
   watch('spec/spec_helper.rb')       { "spec" }
   watch(%r{^spec/support/.+\.rb$})   { "spec" }

data/Thorfile

@@ -9,7 +9,7 @@ require 'ridley'
 class Default < Thor
   unless jruby?
     require 'thor/rake_compat'
-    
+
     include Thor::RakeCompat
     Bundler::GemHelper.install_tasks
 
@@ -40,7 +40,7 @@ class Default < Thor
 
     desc "unit", "run only unit tests"
     def unit
-      exec "rspec --color --format=documentation spec --tag ~type:acceptance" 
+      exec "rspec --color --format=documentation spec --tag ~type:acceptance"
     end
 
     desc "acceptance", "run only acceptance tests"

data/lib/ridley/chef.rb

@@ -5,6 +5,7 @@ module Ridley
   # site, and Chef Cookbooks
   module Chef
     autoload :Cookbook, 'ridley/chef/cookbook'
+    autoload :Chefignore, 'ridley/chef/chefignore'
     autoload :Digester, 'ridley/chef/digester'
   end
 end

data/lib/ridley/chef/chefignore.rb

@@ -0,0 +1,76 @@
+module Ridley::Chef
+  # Borrowed and modified from:
+  # {https://raw.github.com/opscode/chef/62f9b0e3be8e22eef092163c331b7d3f8d350f94/lib/chef/cookbook/chefignore.rb}
+  #
+  # Copyright:: Copyright (c) 2011 Opscode, Inc.
+  #
+  # 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.
+  class Chefignore
+    class << self
+      # Traverse a path in relative context to find a Chefignore file
+      #
+      # @param [String] path
+      #   path to traverse
+      #
+      # @return [String, nil]
+      def find_relative_to(path)
+        [
+          File.join(path, FILENAME),
+          File.join(path, 'cookbooks', FILENAME)
+        ].find { |f| File.exists?(f) }
+      end
+    end
+
+    FILENAME                = "chefignore".freeze
+    COMMENTS_AND_WHITESPACE = /^\s*(?:#.*)?$/
+
+    attr_reader :ignores
+
+    def initialize(ignore_file_or_repo)
+      @ignore_file = find_ignore_file(ignore_file_or_repo)
+      @ignores     = parse_ignore_file
+    end
+
+    def remove_ignores_from(file_list)
+      Array(file_list).inject([]) do |unignored, file|
+        ignored?(file) ? unignored : unignored << file
+      end
+    end
+
+    def ignored?(file_name)
+      @ignores.any? { |glob| File.fnmatch?(glob, file_name) }
+    end
+
+    private
+
+      def parse_ignore_file
+        ignore_globs = []
+
+        if File.exist?(@ignore_file) && File.readable?(@ignore_file)
+          File.foreach(@ignore_file) do |line|
+            ignore_globs << line.strip unless line =~ COMMENTS_AND_WHITESPACE
+          end
+        end
+
+        ignore_globs
+      end
+
+      def find_ignore_file(path)
+        if File.basename(path) =~ /#{FILENAME}/
+          path
+        else
+          File.join(path, FILENAME)
+        end
+      end
+  end
+end

data/lib/ridley/chef/cookbook.rb

@@ -29,20 +29,21 @@ module Ridley::Chef
       #   explicitly supply the name of the cookbook we are loading. This is useful if
       #   you are dealing with a cookbook that does not have well-formed metadata
       #
-      # @raise [IOError] if the path does not contain a metadata.rb file
+      # @raise [IOError] if the path does not contain a metadata.rb or metadata.json file
       #
       # @return [Ridley::Chef::Cookbook]
       def from_path(path, options = {})
         path     = Pathname.new(path)
-        metadata = Cookbook::Metadata.from_file(path.join('metadata.rb'))
-
-        name = if options[:name].present?
-          options[:name]
+        metadata = if path.join('metadata.rb').exist?
+          Cookbook::Metadata.from_file(path.join('metadata.rb'))
+        elsif path.join('metadata.json').exist?
+          Cookbook::Metadata.from_json(File.read(path.join('metadata.json')))
         else
-          metadata.name.empty? ? File.basename(path) : metadata.name
+          raise IOError, "no metadata.rb or metadata.json found at #{path}"
         end
 
-        new(name, path, metadata)
+        metadata.name(options[:name].presence || metadata.name.presence || File.basename(path))
+        new(metadata.name, path, metadata)
       end
     end
 
@@ -96,6 +97,7 @@ module Ridley::Chef
         root_files: Array.new
       )
       @frozen        = false
+      @chefignore    = Ridley::Chef::Chefignore.new(@path)
 
       load_files
     end
@@ -207,7 +209,12 @@ module Ridley::Chef
 
     private
 
+      # @return [Array]
       attr_reader :files
+      # @return [Ridley::Chef::Chefignore]
+      attr_reader :chefignore
+
+      def_delegator :chefignore, :ignored?
 
       def load_files
         load_shallow(:recipes, 'recipes', '*.rb')
@@ -225,6 +232,7 @@ module Ridley::Chef
         [].tap do |files|
           Dir.glob(path.join('*'), File::FNM_DOTMATCH).each do |file|
             next if File.directory?(file)
+            next if ignored?(file)
             @files << file
             @manifest[:root_files] << file_metadata(:root_files, file)
           end
@@ -236,6 +244,7 @@ module Ridley::Chef
           file_spec = path.join(category_dir, '**', glob)
           Dir.glob(file_spec, File::FNM_DOTMATCH).each do |file|
             next if File.directory?(file)
+            next if ignored?(file)
             @files << file
             @manifest[category] << file_metadata(category, file)
           end
@@ -245,6 +254,7 @@ module Ridley::Chef
       def load_shallow(category, *path_glob)
         [].tap do |files|
           Dir[path.join(*path_glob)].each do |file|
+            next if ignored?(file)
             @files << file
             @manifest[category] << file_metadata(category, file)
           end

data/lib/ridley/chef/cookbook/metadata.rb

@@ -26,6 +26,10 @@ module Ridley::Chef
         def from_hash(hash)
           new.from_hash(hash)
         end
+
+        def from_json(json)
+          new.from_json(json)
+        end
       end
 
       NAME              = 'name'.freeze
@@ -458,6 +462,10 @@ module Ridley::Chef
         self
       end
 
+      def from_json(json)
+        from_hash MultiJson.decode(json)
+      end
+
       private
 
         # Verify that the given array is an array of strings

data/lib/ridley/chef_objects/cookbook_object.rb

@@ -118,7 +118,27 @@ module Ridley
     #
     # @return [nil]
     def download_file(filetype, path, destination)
-      download_fun(filetype).call(path, destination)
+      files = case filetype.to_sym
+      when :attribute, :attributes; attributes
+      when :definition, :definitions; definitions
+      when :file, :files; files
+      when :library, :libraries; libraries
+      when :provider, :providers; providers
+      when :recipe, :recipes; recipes
+      when :resource, :resources; resources
+      when :root_file, :root_files; root_files
+      when :template, :templates; templates
+      else
+        raise Errors::UnknownCookbookFileType.new(filetype)
+      end
+
+      file  = files.find { |f| f[:path] == path }
+      return nil if file.nil?
+
+      destination = File.expand_path(destination)
+      log.debug { "downloading '#{filetype}' file: #{file} to: '#{destination}'" }
+
+      resource.connection.stream(file[:url], destination)
     end
 
     # A hash containing keys for all of the different cookbook filetypes with values
@@ -150,41 +170,5 @@ module Ridley
     def to_s
       "#{name}: #{manifest}"
     end
-
-    private
-
-      # Return a lambda for downloading a file from the cookbook of the given type
-      #
-      # @param [#to_sym] filetype
-      #
-      # @return [lambda]
-      #   a lambda which takes to parameters: target and path. Target is the URL to download from
-      #   and path is the location on disk to steam the contents of the remote URL to.
-      def download_fun(filetype)
-        collection = case filetype.to_sym
-        when :attribute, :attributes; method(:attributes)
-        when :definition, :definitions; method(:definitions)
-        when :file, :files; method(:files)
-        when :library, :libraries; method(:libraries)
-        when :provider, :providers; method(:providers)
-        when :recipe, :recipes; method(:recipes)
-        when :resource, :resources; method(:resources)
-        when :root_file, :root_files; method(:root_files)
-        when :template, :templates; method(:templates)
-        else
-          raise Errors::UnknownCookbookFileType.new(filetype)
-        end
-
-        ->(target, destination) {
-          files = collection.call # JW: always chaining .call.find results in a nil value. WHY?
-          file  = files.find { |f| f[:path] == target }
-          return nil if file.nil?
-
-          destination = File.expand_path(destination)
-          log.debug { "downloading '#{filetype}' file: #{file} to: '#{destination}'" }
-
-          connection.stream(file[:url], destination)
-        }
-      end
   end
 end

data/lib/ridley/chef_objects/data_bag_item_obect.rb

@@ -48,6 +48,15 @@ module Ridley
       mass_assign(decrypted_hash)
     end
 
+    # Decrypts an individual value stored inside the data bag item.
+    #
+    # @example
+    #   data_bag_item.decrypt_value("Xk0E8lV9r4BhZzcg4wal0X4w9ZexN3azxMjZ9r1MCZc=")
+    #     => {test: {database: {username: "test"}}}
+    #
+    # @param [String] an encrypted String value
+    #
+    # @return [Hash] a decrypted attribute value
     def decrypt_value(value)
       if encrypted_data_bag_secret.nil?
         raise Errors::EncryptedDataBagSecretNotSet

data/lib/ridley/client.rb

@@ -234,7 +234,7 @@ module Ridley
     #
     # @return [Hash]
     def search(index, query = nil, options = {})
-      @resources_registry[:search_resource].run(index, query, options)
+      @resources_registry[:search_resource].run(index, query, @resources_registry, options)
     end
 
     # Return the array of all possible search indexes for the including connection
@@ -257,7 +257,7 @@ module Ridley
     def encrypted_data_bag_secret
       return nil if encrypted_data_bag_secret_path.nil?
 
-      IO.read(encrypted_data_bag_secret_path).chomp
+      ::IO.read(encrypted_data_bag_secret_path).chomp
     rescue Errno::ENOENT => e
       raise Errors::EncryptedDataBagSecretNotFound, "Encrypted data bag secret provided but not found at '#{encrypted_data_bag_secret_path}'"
     end

data/lib/ridley/connection.rb

@@ -14,8 +14,11 @@ module Ridley
       :proxy
     ]
 
+    # @return [String]
     attr_reader :organization
+    # @return [String]
     attr_reader :client_key
+    # @return [String]
     attr_reader :client_name
     # @return [Integer]
     #   how many retries to attempt on HTTP requests
@@ -95,7 +98,7 @@ module Ridley
     # Override Faraday::Connection#run_request to catch exceptions from {Ridley::Middleware} that
     # we expect. Caught exceptions are re-raised with Celluloid#abort so we don't crash the connection.
     def run_request(*args)
-      super
+      defer { super }
     rescue Errors::HTTPError, Faraday::Error => ex
       abort(ex)
     end
@@ -129,13 +132,16 @@ module Ridley
       local = Tempfile.new('ridley-stream')
       local.binmode
 
-      retryable(tries: retries, on: OpenURI::HTTPError, sleep: retry_interval) do
-        open(target, 'rb', headers) do |remote|
-          local.write(remote.read)
+      defer {
+        retryable(tries: retries, on: OpenURI::HTTPError, sleep: retry_interval) do
+          open(target, 'rb', headers) do |remote|
+            local.write(remote.read)
+          end
         end
-      end
 
-      local.flush
+        local.flush
+      }
+
       FileUtils.mv(local.path, destination)
     rescue OpenURI::HTTPError => ex
       abort(ex)

data/lib/ridley/errors.rb

@@ -115,17 +115,31 @@ module Ridley
     class HTTP5XXError < HTTPError; end
 
     # 3XX
+    class HTTPMultipleChoices < HTTP3XXError; register_error(300); end
     class HTTPMovedPermanently < HTTP3XXError; register_error(301); end
     class HTTPFound < HTTP3XXError; register_error(302); end
+    class HTTPSeeOther < HTTP3XXError; register_error(303); end
+    class HTTPNotModified < HTTP3XXError; register_error(304); end
+    class HTTPUseProxy < HTTP3XXError; register_error(305); end
+    class HTTPTemporaryRedirect < HTTP3XXError; register_error(307); end
 
     # 4XX
     class HTTPBadRequest < HTTP4XXError; register_error(400); end
     class HTTPUnauthorized < HTTP4XXError; register_error(401); end
+    class HTTPPaymentRequired < HTTP4XXError; register_error(402); end
     class HTTPForbidden < HTTP4XXError; register_error(403); end
     class HTTPNotFound < HTTP4XXError; register_error(404); end
     class HTTPMethodNotAllowed < HTTP4XXError; register_error(405); end
+    class HTTPNotAcceptable < HTTP4XXError; register_error(406); end
+    class HTTPProxyAuthenticationRequired < HTTP4XXError; register_error(407); end
     class HTTPRequestTimeout < HTTP4XXError; register_error(408); end
     class HTTPConflict < HTTP4XXError; register_error(409); end
+    class HTTPGone < HTTP4XXError; register_error(410); end
+    class HTTPLengthRequired < HTTP4XXError; register_error(411); end
+    class HTTPPreconditionFailed < HTTP4XXError; register_error(412); end
+    class HTTPRequestEntityTooLarge < HTTP4XXError; register_error(413); end
+    class HTTPRequestURITooLong < HTTP4XXError; register_error(414); end
+    class HTTPUnsupportedMediaType < HTTP4XXError; register_error(415); end
 
     # 5XX
     class HTTPInternalServerError < HTTP5XXError; register_error(500); end

data/lib/ridley/host_connector.rb

@@ -42,6 +42,7 @@ module Ridley
       #   the host to attempt to connect to
       # @option options [Hash] :ssh
       #   * :port (Fixnum) the ssh port to connect on the node the bootstrap will be performed on (22)
+      #   * :timeout (Float) [5.0] timeout value for testing SSH connection
       # @option options [Hash] :winrm
       #   * :port (Fixnum) the winrm port to connect on the node the bootstrap will be performed on (5985)
       # @param block [Proc]
@@ -50,7 +51,9 @@ module Ridley
       # @return [Ridley::HostConnector] a class under Ridley::HostConnector
       def best_connector_for(host, options = {}, &block)
         ssh_port, winrm_port = parse_port_options(options)
-        if connector_port_open?(host, ssh_port)
+        timeout = options[:ssh] && options[:ssh][:timeout]
+
+        if connector_port_open?(host, ssh_port, timeout)
           host_connector = Ridley::HostConnector::SSH
         elsif connector_port_open?(host, winrm_port)
           host_connector = Ridley::HostConnector::WinRM
@@ -72,10 +75,14 @@ module Ridley
       #   the host to attempt to connect to
       # @param  port [Fixnum]
       #   the port to attempt to connect on
+      # @param  timeout [Float]
+      #   the number of seconds to wait (default: 3)
       #
       # @return [Boolean]
-      def connector_port_open?(host, port)
-        Timeout::timeout(3) do
+      def connector_port_open?(host, port, timeout = nil)
+        timeout ||= 3
+
+        Timeout::timeout(timeout) do
           socket = TCPSocket.new(host, port)
           socket.close
         end