ridley 0.7.0.beta → 0.7.0.rc1

data/lib/ridley/connection.rb

@@ -1,116 +1,24 @@
 module Ridley
   # @author Jamie Winsor <jamie@vialstudios.com>
-  class Connection
-    class << self
-      def sync(options, &block)
-        conn = new(options)
-        conn.sync(&block)
-      ensure
-        conn.terminate if conn && conn.alive?
-      end
-      
-      # @raise [ArgumentError]
-      #
-      # @return [Boolean]
-      def validate_options(options)
-        missing = (REQUIRED_OPTIONS - options.keys)
-
-        unless missing.empty?
-          missing.collect! { |opt| "'#{opt}'" }
-          raise ArgumentError, "Missing required option(s): #{missing.join(', ')}"
-        end
-
-        missing_values = options.slice(*REQUIRED_OPTIONS).select { |key, value| !value.present? }
-        unless missing_values.empty?
-          values = missing_values.keys.collect { |opt| "'#{opt}'" }
-          raise ArgumentError, "Missing value for required option(s): '#{values.join(', ')}'"
-        end
-      end
-
-      # A hash of default options to be used in the Connection initializer
-      #
-      # @return [Hash]
-      def default_options
-        {
-          thread_count: DEFAULT_THREAD_COUNT,
-          ssh: Hash.new
-        }
-      end
-    end
-
-    extend Forwardable
-
+  class Connection < Faraday::Connection
     include Celluloid
-    include Ridley::DSL
-    include Ridley::Logging
-
-    attr_reader :organization
 
-    attr_accessor :client_name
-    attr_accessor :client_key
-    attr_accessor :validator_client
-    attr_accessor :validator_path
-    attr_accessor :encrypted_data_bag_secret_path
+    VALID_OPTIONS = [
+      :params,
+      :headers,
+      :request,
+      :ssl,
+      :proxy
+    ]
 
-    attr_accessor :ssh
-    attr_accessor :thread_count
-
-    def_delegator :conn, :build_url
-    def_delegator :conn, :scheme
-    def_delegator :conn, :host
-    def_delegator :conn, :port
-    def_delegator :conn, :path_prefix
-
-    def_delegator :conn, :url_prefix=
-    def_delegator :conn, :url_prefix
-
-    def_delegator :conn, :get
-    def_delegator :conn, :put
-    def_delegator :conn, :post
-    def_delegator :conn, :delete
-    def_delegator :conn, :head
-
-    def_delegator :conn, :in_parallel
-
-    OPTIONS = [
-      :server_url,
-      :client_name,
-      :client_key,
-      :organization,
-      :validator_client,
-      :validator_path,
-      :encrypted_data_bag_secret_path,
-      :thread_count,
-      :ssl
-    ].freeze
-
-    REQUIRED_OPTIONS = [
-      :server_url,
-      :client_name,
-      :client_key
-    ].freeze
-
-    DEFAULT_THREAD_COUNT = 8
+    attr_reader :organization
+    attr_reader :client_key
+    attr_reader :client_name
 
-    # @option options [String] :server_url
-    #   URL to the Chef API
-    # @option options [String] :client_name
-    #   name of the client used to authenticate with the Chef API
-    # @option options [String] :client_key
-    #   filepath to the client's private key used to authenticate with the Chef API
-    # @option options [String] :organization
-    #   the Organization to connect to. This is only used if you are connecting to
-    #   private Chef or hosted Chef
-    # @option options [String] :validator_client (nil)
-    # @option options [String] :validator_path (nil)
-    # @option options [String] :encrypted_data_bag_secret_path (nil)
-    # @option options [Integer] :thread_count (DEFAULT_THREAD_COUNT)
-    # @option options [Hash] :ssh (Hash.new)
-    #   * :user (String) a shell user that will login to each node and perform the bootstrap command on (required)
-    #   * :password (String) the password for the shell user that will perform the bootstrap
-    #   * :keys (Array, String) an array of keys (or a single key) to authenticate the ssh user with instead of a password
-    #   * :timeout (Float) [5.0] timeout value for SSH bootstrap
-    #   * :sudo (Boolean) [true] bootstrap with sudo
+    # @param [String] :server_url
+    # @param [String] :client_name
+    # @param [String] :client_key
+    #
     # @option options [Hash] :params
     #   URI query unencoded key/value pairs
     # @option options [Hash] :headers
@@ -121,63 +29,37 @@ module Ridley
     #   * :verify (Boolean) [true] set to false to disable SSL verification
     # @option options [URI, String, Hash] :proxy
     #   URI, String, or Hash of HTTP proxy options
-    def initialize(options = {})
-      log.info { "Ridley starting..." }
-      configure(options)
-    end
-
-    # Configure this instance of Ridley::Connection
-    #
-    # @param [Hash] options
-    def configure(options)
-      options = self.class.default_options.merge(options)
-      self.class.validate_options(options)
+    def initialize(server_url, client_name, client_key, options = {})
+      @client_name  = client_name
+      @client_key   = client_key
 
-      @client_name      = options[:client_name]
-      @client_key       = File.expand_path(options[:client_key])
-      @organization     = options[:organization]
-      @thread_count     = options[:thread_count]
-      @ssh              = options[:ssh]
-      @validator_client = options[:validator_client]
-      @validator_path   = options[:validator_path]
-      @encrypted_data_bag_secret_path = options[:encrypted_data_bag_secret_path]
+      options = options.reverse_merge(
+        builder: Faraday::Builder.new { |b|
+          b.request :chef_auth, client_name, client_key
+          b.response :chef_response
+          b.response :json
 
-      unless @client_key.present? && File.exist?(@client_key)
-        raise Errors::ClientKeyFileNotFound, "client key not found at: '#{@client_key}'"
-      end
+          b.adapter :net_http_persistent
+        }
+      )
 
-      faraday_options = options.slice(:params, :headers, :request, :ssl, :proxy)
-      uri_hash = Addressable::URI.parse(options[:server_url]).to_hash.slice(:scheme, :host, :port)
+      uri_hash = Addressable::URI.parse(server_url).to_hash.slice(:scheme, :host, :port)
 
       unless uri_hash[:port]
         uri_hash[:port] = (uri_hash[:scheme] == "https" ? 443 : 80)
       end
 
-      if org_match = options[:server_url].match(/.*\/organizations\/(.*)/)
-        @organization ||= org_match[1]
+      if org_match = server_url.match(/.*\/organizations\/(.*)/)
+        @organization = org_match[1]
       end
 
-      unless organization.nil?
-        uri_hash[:path] = "/organizations/#{organization}"
+      unless @organization.nil?
+        uri_hash[:path] = "/organizations/#{@organization}"
       end
 
       server_uri = Addressable::URI.new(uri_hash)
 
-      @conn = Faraday.new(server_uri, faraday_options) do |c|
-        c.request :chef_auth, client_name, client_key
-        c.response :chef_response
-        c.response :json
-
-        c.adapter :net_http_persistent
-      end
-    end
-
-    def sync(&block)
-      unless block
-        raise Errors::InternalError, "A block must be given to synchronously process requests."
-      end
-
-      evaluate(&block)
+      super(server_uri, options)
     end
 
     # @return [Symbol]
@@ -198,43 +80,5 @@ module Ridley
     def server_url
       self.url_prefix.to_s
     end
-
-    # The encrypted data bag secret for this connection.
-    #
-    # @raise [Ridley::Errors::EncryptedDataBagSecretNotFound]
-    #
-    # @return [String, nil]
-    def encrypted_data_bag_secret
-      return nil if encrypted_data_bag_secret_path.nil?
-
-      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
-
-    def finalize
-      log.info { "Ridley stopping..." }
-    end
-
-    private
-
-      attr_reader :conn
-
-      def evaluate(&block)
-        @self_before_instance_eval = eval("self", block.binding)
-        instance_eval(&block)
-      end
-
-      def method_missing(method, *args, &block)
-        if block_given?
-          @self_before_instance_eval ||= eval("self", block.binding)
-        end
-
-        if @self_before_instance_eval.nil?
-          super
-        end
-
-        @self_before_instance_eval.send(method, *args, &block)
-      end
   end
 end

data/lib/ridley/middleware/chef_auth.rb

@@ -4,6 +4,8 @@ module Ridley
   module Middleware
     # @author Jamie Winsor <jamie@vialstudios.com>
     class ChefAuth < Faraday::Middleware
+      include Ridley::Logging
+
       attr_reader :client_name
       attr_reader :client_key
 
@@ -26,7 +28,8 @@ module Ridley
         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]
 
-        Ridley.log.debug(env)
+        log.debug { "Performing Authenticated Chef Request: "}
+        log.debug { env }
 
         @app.call(env)
       end

data/lib/ridley/resource.rb

@@ -52,94 +52,88 @@ module Ridley
         attribute(:json_class, default: klass)
       end
 
-      # @param [Ridley::Connection] connection
+      # @param [Ridley::Client] client
       #
       # @return [Array<Object>]
-      def all(connection)
-        connection.get(self.resource_path).body.collect do |identity, location|
-          new(connection, self.chef_id => identity)
+      def all(client)
+        client.connection.get(self.resource_path).body.collect do |identity, location|
+          new(client, self.chef_id => identity)
         end
       end
       
-      # @param [Ridley::Connection] connection
+      # @param [Ridley::Client] client
       # @param [String, #chef_id] object
       #
       # @return [nil, Object]
-      def find(connection, object)
-        find!(connection, object)
+      def find(client, object)
+        find!(client, object)
       rescue Errors::HTTPNotFound
         nil
       end
 
-      # @param [Ridley::Connection] connection
+      # @param [Ridley::Client] client
       # @param [String, #chef_id] object
       #
       # @raise [Errors::HTTPNotFound]
       #   if a resource with the given chef_id is not found
       #
       # @return [Object]
-      def find!(connection, object)
+      def find!(client, object)
         chef_id = object.respond_to?(:chef_id) ? object.chef_id : object
-        new(connection, connection.get("#{self.resource_path}/#{chef_id}").body)
+        new(client, client.connection.get("#{self.resource_path}/#{chef_id}").body)
       end
 
-      # @param [Ridley::Connection] connection
+      # @param [Ridley::Client] client
       # @param [#to_hash] object
       #
       # @return [Object]
-      def create(connection, object)
-        resource = new(connection, object.to_hash)
-        new_attributes = connection.post(self.resource_path, resource.to_json).body
+      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
       end
 
-      # @param [Ridley::Connection] connection
+      # @param [Ridley::Client] client
       # @param [String, #chef_id] object
       #
       # @return [Object]
-      def delete(connection, object)
+      def delete(client, object)
         chef_id = object.respond_to?(:chef_id) ? object.chef_id : object
-        new(connection, connection.delete("#{self.resource_path}/#{chef_id}").body)
+        new(client, client.connection.delete("#{self.resource_path}/#{chef_id}").body)
       end
 
-      # @param [Ridley::Connection] connection
+      # @param [Ridley::Client] client
       #
       # @return [Array<Object>]
-      def delete_all(connection)
+      def delete_all(client)
         mutex = Mutex.new
         deleted = []
-        resources = all(connection)
-
-        connection.thread_count.times.collect do
-          Thread.new(connection, resources, deleted) do |connection, resources, deleted|
-            while resource = mutex.synchronize { resources.pop }
-              result = delete(connection, resource)
-              mutex.synchronize { deleted << result }
-            end
-          end
-        end.each(&:join)
-
-        deleted
+
+        all(client).collect do |resource|
+          Celluloid::Future.new {
+            delete(client, resource)
+          }
+        end.map(&:value)
       end
 
-      # @param [Ridley::Connection] connection
+      # @param [Ridley::Client] client
       # @param [#to_hash] object
       #
       # @return [Object]
-      def update(connection, object)
-        resource = new(connection, object.to_hash)
-        new(connection, connection.put("#{self.resource_path}/#{resource.chef_id}", resource.to_json).body)
+      def update(client, object)
+        resource = new(client, object.to_hash)
+        new(client, client.connection.put("#{self.resource_path}/#{resource.chef_id}", resource.to_json).body)
       end
     end
 
     include Chozo::VariaModel
     include Comparable
 
-    # @param [Ridley::Connection] connection
+    # @param [Ridley::Client] client
     # @param [Hash] new_attrs
-    def initialize(connection, new_attrs = {})
-      @connection = connection
+    def initialize(client, new_attrs = {})
+      @client = client
       mass_assign(new_attrs)
     end
 
@@ -153,7 +147,7 @@ module Ridley
     def save
       raise Errors::InvalidResource.new(self.errors) unless valid?
 
-      mass_assign(self.class.create(connection, self).attributes)
+      mass_assign(self.class.create(client, self).attributes)
       true
     rescue Errors::HTTPConflict
       self.update
@@ -170,7 +164,7 @@ module Ridley
     def update
       raise Errors::InvalidResource.new(self.errors) unless valid?
 
-      mass_assign(self.class.update(connection, self).attributes)
+      mass_assign(self.class.update(client, self).attributes)
       true
     end
 
@@ -178,7 +172,7 @@ module Ridley
     #
     # @return [Object]
     def reload
-      mass_assign(self.class.find(connection, self).attributes)
+      mass_assign(self.class.find(client, self).attributes)
       self
     end
 
@@ -215,6 +209,6 @@ module Ridley
 
     private
 
-      attr_reader :connection
+      attr_reader :client
   end
 end

data/lib/ridley/resources.rb

@@ -0,0 +1,3 @@
+Dir["#{File.dirname(__FILE__)}/resources/*.rb"].sort.each do |path|
+  require "ridley/resources/#{File.basename(path, '.rb')}"
+end

data/lib/ridley/resources/{client.rb → client_resource.rb}

@@ -1,21 +1,21 @@
 module Ridley
   # @author Jamie Winsor <jamie@vialstudios.com>
-  class Client < Ridley::Resource
+  class ClientResource < Ridley::Resource
     class << self
       # Retrieves a client from the remote connection matching the given chef_id
       # and regenerates it's private key. An instance of the updated object will
       # be returned and have a value set for the 'private_key' accessor.
       #
-      # @param [Ridley::Connection] connection
-      # @param [String, #chef_id] client
+      # @param [Ridley::Client] client
+      # @param [String, #chef_id] chef_client
       #
       # @raise [Errors::HTTPNotFound]
       #   if a client with the given chef_id is not found
       # @raise [Errors::HTTPError]
       #
-      # @return [Ridley::Client]
-      def regenerate_key(connection, client)
-        obj = find!(connection, client)
+      # @return [Ridley::ClientResource]
+      def regenerate_key(client, chef_client)
+        obj = find!(client, chef_client)
         obj.regenerate_key
         obj
       end
@@ -66,24 +66,11 @@ module Ridley
     # Override to_json to reflect to massage the returned attributes based on the type
     # of connection. Only OHC/OPC requires the json_class attribute is not present.
     def to_json
-      if connection.hosted?
+      if client.connection.hosted?
         attributes.except(:json_class).to_json
       else
         super
       end
     end
   end
-
-  module DSL
-    # Coerces instance functions into class functions on Ridley::Client. This coercion
-    # sends an instance of the including class along to the class function.
-    #
-    # @see Ridley::ChainLink
-    #
-    # @return [Ridley::ChainLink]
-    #   a context object to delegate instance functions to class functions on Ridley::Client
-    def client
-      ChainLink.new(self, Ridley::Client)
-    end
-  end
 end