ridley 0.7.0.rc1 → 0.7.0.rc3

data/.rbenv-version

@@ -1 +1,2 @@
-1.9.3-p286
+1.9.3-p327
+

data/lib/ridley.rb

@@ -3,6 +3,7 @@ require 'celluloid'
 require 'faraday'
 require 'addressable/uri'
 require 'multi_json'
+require 'solve'
 require 'active_support/inflector'
 require 'forwardable'
 require 'thread'
@@ -21,7 +22,7 @@ JSON.create_id = nil
 
 # @author Jamie Winsor <jamie@vialstudios.com>
 module Ridley
-  CHEF_VERSION = '10.16.4'.freeze
+  CHEF_VERSION = '11.4.0'.freeze
 
   autoload :Bootstrapper, 'ridley/bootstrapper'
   autoload :Client, 'ridley/client'

data/lib/ridley/client.rb

@@ -71,6 +71,8 @@ module Ridley
     def_delegator :connection, :client_name
     def_delegator :connection, :client_name=
 
+    attr_reader :options
+
     attr_accessor :validator_client
     attr_accessor :validator_path
     attr_accessor :encrypted_data_bag_secret_path
@@ -103,34 +105,34 @@ module Ridley
     #   URI, String, or Hash of HTTP proxy options
     def initialize(options = {})
       log.info { "Ridley starting..." }
-      options = options.reverse_merge(
+      @options = options.reverse_merge(
         ssh: Hash.new
       ).deep_symbolize_keys
-      self.class.validate_options(options)
+      self.class.validate_options(@options)
 
-      @ssh              = options[:ssh]
-      @validator_client = options[:validator_client]
+      @ssh              = @options[:ssh]
+      @validator_client = @options[:validator_client]
 
-      options[:client_key] = File.expand_path(options[:client_key])
+      @options[:client_key] = File.expand_path(@options[:client_key])
 
-      if options[:validator_path]
-        @validator_path = File.expand_path(options[:validator_path])
+      if @options[:validator_path]
+        @validator_path = File.expand_path(@options[:validator_path])
       end
 
-      if options[:encrypted_data_bag_secret_path]
-        @encrypted_data_bag_secret_path = File.expand_path(options[:encrypted_data_bag_secret_path])
+      if @options[:encrypted_data_bag_secret_path]
+        @encrypted_data_bag_secret_path = File.expand_path(@options[:encrypted_data_bag_secret_path])
       end
 
-      unless options[:client_key].present? && File.exist?(options[:client_key])
-        raise Errors::ClientKeyFileNotFound, "client key not found at: '#{options[:client_key]}'"
+      unless @options[:client_key].present? && File.exist?(@options[:client_key])
+        raise Errors::ClientKeyFileNotFound, "client key not found at: '#{@options[:client_key]}'"
       end
 
       super(Celluloid::Registry.new)
       pool(Ridley::Connection, size: 4, args: [
-        options[:server_url],
-        options[:client_name],
-        options[:client_key],
-        options.slice(*Connection::VALID_OPTIONS)
+        @options[:server_url],
+        @options[:client_name],
+        @options[:client_key],
+        @options.slice(*Connection::VALID_OPTIONS)
       ], as: :connection_pool)
     end
 

data/lib/ridley/connection.rb

@@ -1,3 +1,6 @@
+require 'open-uri'
+require 'tempfile'
+
 module Ridley
   # @author Jamie Winsor <jamie@vialstudios.com>
   class Connection < Faraday::Connection
@@ -15,9 +18,9 @@ module Ridley
     attr_reader :client_key
     attr_reader :client_name
 
-    # @param [String] :server_url
-    # @param [String] :client_name
-    # @param [String] :client_key
+    # @param [String] server_url
+    # @param [String] client_name
+    # @param [String] client_key
     #
     # @option options [Hash] :params
     #   URI query unencoded key/value pairs
@@ -77,8 +80,52 @@ module Ridley
       api_type == :foss
     end
 
+    # 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
+    rescue Errors::HTTPError => ex
+      abort(ex)
+    end
+
     def server_url
       self.url_prefix.to_s
     end
+
+    # Stream the response body of a remote URL to a file on the local file system
+    #
+    # @param [String] target
+    #   a URL to stream the response body from
+    # @param [String] destination
+    #   a location on disk to stream the content of the response body to
+    def stream(target, destination)
+      FileUtils.mkdir_p(File.dirname(destination))
+
+      target  = Addressable::URI.parse(target)
+      headers = Middleware::ChefAuth.authentication_headers(
+        client_name,
+        client_key,
+        http_method: "GET",
+        host: target.host,
+        path: target.path
+      )
+
+      unless ssl[:verify]
+        headers.merge!(ssl_verify_mode: OpenSSL::SSL::VERIFY_NONE)
+      end
+
+      local = Tempfile.new('ridley-stream')
+      local.binmode
+
+      open(target, 'rb', headers) do |remote|
+        local.write(remote.read)
+      end
+      
+      FileUtils.mv(local.path, destination)
+    rescue OpenURI::HTTPError => ex
+      abort(ex)
+    ensure
+      local.close(true) unless local.nil?
+    end
   end
 end

data/lib/ridley/errors.rb

@@ -5,6 +5,7 @@ module Ridley
     class InternalError < RidleyError; end
     class ArgumentError < InternalError; end
 
+    class ResourceNotFound < RidleyError; end
     class ValidatorNotFound < RidleyError; end
 
     class InvalidResource < RidleyError
@@ -20,6 +21,18 @@ module Ridley
       alias_method :to_s, :message
     end
 
+    class UnknownCookbookFileType < RidleyError
+      attr_reader :type
+
+      def initialize(type)
+        @type = type
+      end
+
+      def to_s
+        "filetype: '#{type}'"
+      end
+    end
+
     class BootstrapError < RidleyError; end
     class ClientKeyFileNotFound < BootstrapError; end
     class EncryptedDataBagSecretNotFound < BootstrapError; end

data/lib/ridley/middleware/chef_auth.rb

@@ -4,6 +4,45 @@ module Ridley
   module Middleware
     # @author Jamie Winsor <jamie@vialstudios.com>
     class ChefAuth < Faraday::Middleware
+      class << self
+        include Mixlib::Authentication
+
+        # Generate authentication headers for a request to a Chef Server
+        #
+        # @param [String] client_name
+        # @param [String] client_key
+        #
+        # @option options [String] :host
+        #
+        # @see {#signing_object} for options
+        def authentication_headers(client_name, client_key, options = {})
+          rsa_key = OpenSSL::PKey::RSA.new(File.read(client_key))
+          headers = signing_object(client_name, options).sign(rsa_key).merge(host: options[:host])
+          headers.inject({}) { |memo, kv| memo["#{kv[0].to_s.upcase}"] = kv[1];memo }
+        end
+
+        # Create a signing object for a Request to a Chef Server
+        #
+        # @param [String] client_name
+        #
+        # @option options [String] :http_method
+        # @option options [String] :path
+        # @option options [String] :body
+        # @option options [Time] :timestamp
+        #
+        # @return [SigningObject]
+        def signing_object(client_name, options = {})
+          options = options.reverse_merge(
+            body: String.new,
+            timestamp: Time.now.utc.iso8601
+          )
+          options[:user_id]       = client_name
+          options[:proto_version] = "1.0"
+
+          SignedHeaderAuth.signing_object(options)
+        end
+      end
+
       include Ridley::Logging
 
       attr_reader :client_name
@@ -12,24 +51,23 @@ module Ridley
       def initialize(app, client_name, client_key)
         super(app)
         @client_name = client_name
-        @client_key = OpenSSL::PKey::RSA.new(File.read(client_key))
+        @client_key  = client_key
       end
 
       def call(env)
-        sign_obj = Mixlib::Authentication::SignedHeaderAuth.signing_object(
+        signing_options = {
           http_method: env[:method],
-          host: env[:url].host,
+          host: env[:url].host || "localhost",
           path: env[:url].path,
-          body: env[:body] || '',
-          timestamp: Time.now.utc.iso8601,
-          user_id: client_name
-        )
-        authentication_headers = sign_obj.sign(client_key)
+          body: env[:body] || ''
+        }
+        authentication_headers = self.class.authentication_headers(client_name, client_key, signing_options)
+
         env[:request_headers] = default_headers.merge(env[:request_headers]).merge(authentication_headers)
         env[:request_headers] = env[:request_headers].merge('Content-Length' => env[:body].bytesize.to_s) if env[:body]
 
-        log.debug { "Performing Authenticated Chef Request: "}
-        log.debug { env }
+        log.debug { "==> performing authenticated Chef request as '#{client_name}'"}
+        log.debug { "request env: #{env}"}
 
         @app.call(env)
       end

data/lib/ridley/middleware/chef_response.rb

@@ -14,12 +14,14 @@ module Ridley
         end
       end
 
+      include Ridley::Logging
+
       def on_complete(env)
-        Ridley.log.debug("Handling Chef Response")
-        Ridley.log.debug(env)
+        log.debug { "==> handling Chef response" }
+        log.debug { "request env: #{env}" }
         
         unless self.class.success?(env)
-          Ridley.log.debug("Error encounted in Chef Response")
+          log.debug { "** error encounted in Chef response" }
           raise Errors::HTTPError.fabricate(env)
         end
       end

data/lib/ridley/middleware/parse_json.rb

@@ -51,7 +51,7 @@ module Ridley
         # @return [String]
         def response_type(env)
           if env[:response_headers][CONTENT_TYPE].nil?
-            log.debug "Response did not specify a content type."
+            log.debug { "response did not specify a content type" }
             return "text/html"
           end
 
@@ -98,10 +98,10 @@ module Ridley
         log.debug(env)
 
         if self.class.json_response?(env)
-          log.debug("Parsing Chef Response body as JSON")
+          log.debug { "==> parsing Chef response body as JSON" }
           env[:body] = self.class.parse(env[:body])
         else
-          log.debug("Chef Response did not contain a JSON body")
+          log.debug { "==> Chef response did not contain a JSON body" }
         end
       end
     end

data/lib/ridley/resource.rb

@@ -67,7 +67,7 @@ module Ridley
       # @return [nil, Object]
       def find(client, object)
         find!(client, object)
-      rescue Errors::HTTPNotFound
+      rescue Errors::ResourceNotFound
         nil
       end
 
@@ -81,6 +81,8 @@ module Ridley
       def find!(client, object)
         chef_id = object.respond_to?(:chef_id) ? object.chef_id : object
         new(client, client.connection.get("#{self.resource_path}/#{chef_id}").body)
+      rescue Errors::HTTPNotFound => ex
+        raise Errors::ResourceNotFound, ex
       end
 
       # @param [Ridley::Client] client
@@ -90,7 +92,7 @@ module Ridley
       def create(client, object)
         resource = new(client, object.to_hash)
         new_attributes = client.connection.post(self.resource_path, resource.to_json).body
-        resource.attributes = resource.attributes.deep_merge(new_attributes)
+        resource.mass_assign(resource._attributes_.deep_merge(new_attributes))
         resource
       end
 
@@ -147,7 +149,7 @@ module Ridley
     def save
       raise Errors::InvalidResource.new(self.errors) unless valid?
 
-      mass_assign(self.class.create(client, self).attributes)
+      mass_assign(self.class.create(client, self)._attributes_)
       true
     rescue Errors::HTTPConflict
       self.update
@@ -164,7 +166,7 @@ module Ridley
     def update
       raise Errors::InvalidResource.new(self.errors) unless valid?
 
-      mass_assign(self.class.update(client, self).attributes)
+      mass_assign(self.class.update(client, self)._attributes_)
       true
     end
 
@@ -172,7 +174,7 @@ module Ridley
     #
     # @return [Object]
     def reload
-      mass_assign(self.class.find(client, self).attributes)
+      mass_assign(self.class.find(client, self)._attributes_)
       self
     end
 
@@ -182,7 +184,7 @@ module Ridley
     end
 
     def to_s
-      self.attributes
+      "#{self.chef_id}: #{self._attributes_}"
     end
 
     # @param [Object] other

data/lib/ridley/resources/client_resource.rb

@@ -67,7 +67,7 @@ module Ridley
     # of connection. Only OHC/OPC requires the json_class attribute is not present.
     def to_json
       if client.connection.hosted?
-        attributes.except(:json_class).to_json
+        to_hash.except(:json_class).to_json
       else
         super
       end

data/lib/ridley/resources/cookbook_resource.rb

@@ -2,16 +2,87 @@ module Ridley
   # @author Jamie Winsor <jamie@vialstudios.com>
   class CookbookResource < Ridley::Resource
     class << self
+      # List all of the cookbooks and their versions present on the remote
+      #
+      # @example return value
+      #   {
+      #     "ant" => [
+      #       "0.10.1"
+      #     ],
+      #     "apache2" => [
+      #       "1.4.0"
+      #     ]
+      #   } 
+      #
+      # @param [Ridley::Client] client
+      #
+      # @return [Hash]
+      #   a hash containing keys which represent cookbook names and values which contain
+      #   an array of strings representing the available versions
+      def all(client)
+        response = client.connection.get(self.resource_path).body
+        
+        {}.tap do |cookbooks|
+          response.each do |name, details|
+            cookbooks[name] = details["versions"].collect { |version| version["version"] }
+          end
+        end
+      end
+
       def create(*args)
         raise NotImplementedError
       end
 
-      def delete(*args)
-        raise NotImplementedError
+      # Delete a cookbook of the given name and version on the remote Chef server
+      #
+      # @param [Ridley::Client] client
+      # @param [String] name
+      # @param [String] version
+      #
+      # @option options [Boolean] purge (false)
+      #
+      # @return [Boolean]
+      def delete(client, name, version, options = {})
+        options = options.reverse_merge(purge: false)
+        url = "#{self.resource_path}/#{name}/#{version}"
+        url += "?purge=true" if options[:purge]
+
+        client.connection.delete(url).body
+        true
+      rescue Errors::HTTPNotFound
+        true
       end
 
-      def delete_all(*args)
-        raise NotImplementedError
+      # Delete all of the versions of a given cookbook on the remote Chef server
+      #
+      # @param [Ridley::Client] client
+      # @param [String] name
+      #   name of the cookbook to delete
+      #
+      # @option options [Boolean] purge (false)
+      def delete_all(client, name, options = {})
+        versions(client, name).each do |version|
+          delete(client, name, version, options)
+        end
+      end
+
+      # Download the entire cookbook
+      #
+      # @param [Ridley::Client] client
+      # @param [String] name
+      # @param [String] version
+      # @param [String] destination (Dir.mktmpdir)
+      #   the place to download the cookbook too. If no value is provided the cookbook
+      #   will be downloaded to a temporary location
+      #
+      # @return [String]
+      #   the path to the directory the cookbook was downloaded to
+      def download(client, name, version, destination = Dir.mktmpdir)
+        cookbook = find(client, name, version)
+        
+        unless cookbook.nil?
+          cookbook.download(destination)
+        end
       end
 
       # @param [Ridley::Client] client
@@ -19,7 +90,7 @@ module Ridley
       # @param [String] version
       #
       # @return [nil, CookbookResource]
-      def find(client, object, version = nil)
+      def find(client, object, version)
         find!(client, object, version)
       rescue Errors::HTTPNotFound
         nil
@@ -33,15 +104,40 @@ module Ridley
       #   if a resource with the given chef_id is not found
       #
       # @return [CookbookResource]
-      def find!(client, object, version = nil)
-        chef_id   = object.respond_to?(:chef_id) ? object.chef_id : object
-        fetch_uri = "#{self.resource_path}/#{chef_id}"
-        
-        unless version.nil?
-          fetch_uri = File.join(fetch_uri, version)
-        end
+      def find!(client, object, version)
+        chef_id = object.respond_to?(:chef_id) ? object.chef_id : object
+        new(client, client.connection.get("#{self.resource_path}/#{chef_id}/#{version}").body)
+      end
+
+      # Return the latest version of the given cookbook found on the remote Chef server
+      #
+      # @param [Ridley::Client] client
+      # @param [String] name
+      #
+      # @return [String, nil]
+      def latest_version(client, name)
+        ver = versions(client, name).collect do |version|
+          Solve::Version.new(version)
+        end.sort.last
 
-        new(client, client.connection.get(fetch_uri).body)
+        ver.nil? ? nil : ver.to_s
+      end
+
+      # Return the version of the given cookbook which best stasifies the given constraint
+      #
+      # @param [Ridley::Client] client
+      # @param [String] name
+      #   name of the cookbook
+      # @param [String, Solve::Constraint] constraint
+      #   constraint to solve for
+      #
+      # @return [CookbookResource, nil]
+      #   returns the cookbook resource for the best solution or nil if no solution exists
+      def satisfy(client, name, constraint)
+        version = Solve::Solver.satisfy_best(constraint, versions(client, name)).to_s
+        find(client, name, version)
+      rescue Solve::Errors::NoSolutionError
+        nil
       end
 
       # Save a new Cookbook Version of the given name, version with the
@@ -71,8 +167,39 @@ module Ridley
       def update(*args)
         raise NotImplementedError
       end
+
+      # Return a list of versions for the given cookbook present on the remote Chef server
+      #
+      # @param [Ridley::Client] client
+      # @param [String] name
+      #
+      # @example
+      #   versions(client, "nginx") => [ "1.0.0", "1.2.0" ]
+      #
+      # @return [Array<String>]
+      def versions(client, name)
+        response = client.connection.get("#{self.resource_path}/#{name}").body
+
+        response[name]["versions"].collect do |cb_ver|
+          cb_ver["version"]
+        end
+      end
     end
 
+    include Ridley::Logging
+
+    FILE_TYPES = [
+      :resources,
+      :providers,
+      :recipes,
+      :definitions,
+      :libraries,
+      :attributes,
+      :files,
+      :templates,
+      :root_files
+    ].freeze
+
     set_chef_id "name"
     set_chef_type "cookbook"
     set_chef_json_class "Chef::Cookbook"
@@ -81,41 +208,166 @@ module Ridley
     attribute :name,
       required: true
 
-    # Broken until resolved: https://github.com/reset/chozo/issues/17
-    # attribute :attributes,
-    #   type: Array
+    attribute :attributes,
+      type: Array,
+      default: Array.new
 
     attribute :cookbook_name,
       type: String
 
     attribute :definitions,
-      type: Array
+      type: Array,
+      default: Array.new
 
     attribute :files,
-      type: Array
+      type: Array,
+      default: Array.new
 
     attribute :libraries,
-      type: Array
+      type: Array,
+      default: Array.new
 
     attribute :metadata,
       type: Hashie::Mash
 
     attribute :providers,
-      type: Array
+      type: Array,
+      default: Array.new
 
     attribute :recipes,
-      type: Array
+      type: Array,
+      default: Array.new
 
     attribute :resources,
-      type: Array
+      type: Array,
+      default: Array.new
 
     attribute :root_files,
-      type: Array
+      type: Array,
+      default: Array.new
 
     attribute :templates,
-      type: Array
+      type: Array,
+      default: Array.new
 
     attribute :version,
       type: String
+
+    # Download the entire cookbook
+    #
+    # @param [String] destination (Dir.mktmpdir)
+    #   the place to download the cookbook too. If no value is provided the cookbook
+    #   will be downloaded to a temporary location
+    #
+    # @return [String]
+    #   the path to the directory the cookbook was downloaded to
+    def download(destination = Dir.mktmpdir)
+      destination = File.expand_path(destination)
+      log.debug { "downloading cookbook: '#{name}'" }
+
+      FILE_TYPES.each do |filetype|
+        next unless manifest.has_key?(filetype)
+
+        manifest[filetype].each do |file|
+          file_destination = File.join(destination, file[:path].gsub('/', File::SEPARATOR))
+          FileUtils.mkdir_p(File.dirname(file_destination))
+          download_file(filetype, file[:name], file_destination)
+        end
+      end
+
+      destination
+    end
+
+    # Download a single file from a cookbook
+    #
+    # @param [#to_sym] filetype
+    #   the type of file to download. These are broken up into the following types in Chef:
+    #     - attribute (unsupported until resolved https://github.com/reset/chozo/issues/17)
+    #     - definition
+    #     - file
+    #     - library
+    #     - provider
+    #     - recipe
+    #     - resource
+    #     - root_file
+    #     - template
+    #   these types are where the files are stored in your cookbook's structure. For example, a
+    #   recipe would be stored in the recipes directory while a root_file is stored at the root
+    #   of your cookbook
+    # @param [String] name
+    #   name of the file to download
+    # @param [String] destination
+    #   where to download the file to
+    #
+    # @return [nil]
+    def download_file(filetype, name, destination)
+      download_fun(filetype).call(name, destination)
+    end
+
+    # A hash containing keys for all of the different cookbook filetypes with values
+    # representing each file of that type this cookbook contains
+    #
+    # @example
+    #   {
+    #     root_files: [
+    #       {
+    #         :name => "afile.rb",
+    #         :path => "files/ubuntu-9.10/afile.rb",
+    #         :checksum => "2222",
+    #         :specificity => "ubuntu-9.10"
+    #       },
+    #     ],
+    #     templates: [ manifest_record1, ... ],
+    #     ...
+    #   }
+    #
+    # @return [Hash]
+    def manifest
+      {}.tap do |manifest|
+        FILE_TYPES.each do |filetype|
+          manifest[filetype] = get_attribute(filetype)
+        end
+      end
+    end
+
+    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[:name] == target }
+          return nil if file.nil?
+
+          destination = File.expand_path(destination)
+          log.debug { "downloading '#{filetype}' file: #{file} to: '#{destination}'" }
+
+          client.connection.stream(file[:url], destination)
+        }
+      end
   end
 end