ridley 0.7.0.beta → 0.7.0.rc1

data/lib/ridley/resources/{environment.rb → environment_resource.rb}

@@ -1,16 +1,16 @@
 module Ridley
   # @author Jamie Winsor <jamie@vialstudios.com>
-  class Environment < Ridley::Resource    
+  class EnvironmentResource < Ridley::Resource
     class << self
-      # Delete all of the environments on the remote connection. The
-      # '_default' environment will never be deleted.
+      # Delete all of the environments on the client. The '_default' environment
+      # will never be deleted.
       #
-      # @param [Ridley::Connection] connection
+      # @param [Ridley::Client] client
       #
-      # @return [Array<Ridley::Environment>]
-      def delete_all(connection)
-        envs = all(connection).reject { |env| env.name.to_s == '_default' }
-        envs.collect { |obj| delete(connection, obj) }
+      # @return [Array<Ridley::EnvironmentResource>]
+      def delete_all(client)
+        envs = all(client).reject { |env| env.name.to_s == '_default' }
+        envs.collect { |obj| delete(client, obj) }
       end
     end
 
@@ -70,17 +70,4 @@ module Ridley
       self.override_attributes = self.override_attributes.deep_merge(attr_hash)
     end
   end
-
-  module DSL
-    # Coerces instance functions into class functions on Ridley::Environment. 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::Environment
-    def environment
-      ChainLink.new(self, Ridley::Environment)
-    end
-  end
 end

data/lib/ridley/resources/{node.rb → node_resource.rb}

@@ -1,9 +1,9 @@
 module Ridley 
   # @author Jamie Winsor <jamie@vialstudios.com>
-  class Node < Ridley::Resource
+  class NodeResource < Ridley::Resource
     class << self
-      # @overload bootstrap(connection, nodes, options = {})
-      #   @param [Ridley::Connection] connection
+      # @overload bootstrap(client, nodes, options = {})
+      #   @param [Ridley::Client] client
       #   @param [Array<String>, String] nodes
       #   @param [Hash] ssh
       #     * :user (String) a shell user that will login to each node and perform the bootstrap command on (required)
@@ -33,15 +33,15 @@ module Ridley
       #     bootstrap template to use (default: omnibus)
       #
       # @return [SSH::ResponseSet]
-      def bootstrap(connection, *args)
+      def bootstrap(client, *args)
         options = args.extract_options!
 
         default_options = {
-          server_url: connection.server_url,
-          validator_path: connection.validator_path,
-          validator_client: connection.validator_client,
-          encrypted_data_bag_secret_path: connection.encrypted_data_bag_secret_path,
-          ssh: connection.ssh
+          server_url: client.server_url,
+          validator_path: client.validator_path,
+          validator_client: client.validator_client,
+          encrypted_data_bag_secret_path: client.encrypted_data_bag_secret_path,
+          ssh: client.ssh
         }
 
         options = default_options.merge(options)
@@ -51,8 +51,8 @@ module Ridley
 
       # Merges the given data with the the data of the target node on the remote
       #
-      # @param [Ridley::Cnonection] connection
-      # @param [Ridley::Node, String] target
+      # @param [Ridley::Client] client
+      # @param [Ridley::NodeResource, String] target
       #   node or identifier of the node to merge
       # @option options [Array] :run_list
       #   run list items to merge
@@ -62,9 +62,9 @@ module Ridley
       # @raise [Errors::HTTPNotFound]
       #   if the target node is not found
       #
-      # @return [Ridley::Node]
-      def merge_data(connection, target, options = {})
-        find!(connection, target).merge_data(options)
+      # @return [Ridley::NodeResource]
+      def merge_data(client, target, options = {})
+        find!(client, target).merge_data(options)
       end
     end
 
@@ -119,9 +119,9 @@ module Ridley
     # @param [String] key
     # @param [Object] value
     #
-    # @return [HashWithIndifferentAccess]
+    # @return [Hashie::Mash]
     def set_chef_attribute(key, value)
-      attr_hash = HashWithIndifferentAccess.from_dotted_path(key, value)
+      attr_hash = Hashie::Mash.from_dotted_path(key, value)
       self.normal = self.normal.deep_merge(attr_hash)
     end
 
@@ -197,7 +197,7 @@ module Ridley
     #
     # @return [SSH::Response]
     def chef_client(options = {})
-      options = connection.ssh.merge(options)
+      options = client.ssh.merge(options)
 
       Ridley.log.debug "Running Chef Client on: #{self.public_hostname}"
       Ridley::SSH.start(self, options) do |ssh|
@@ -205,8 +205,8 @@ module Ridley
       end
     end
 
-    # Put the connection's encrypted data bag secret onto the instantiated node. If no
-    # encrypted data bag key path is set on the resource's connection then nil will be
+    # Put the client's encrypted data bag secret onto the instantiated node. If no
+    # encrypted data bag key path is set on the resource's client then nil will be
     # returned
     #
     # @param [Hash] options
@@ -214,14 +214,14 @@ module Ridley
     #
     # @return [SSH::Response, nil]
     def put_secret(options = {})
-      if connection.encrypted_data_bag_secret_path.nil? ||
-        !File.exists?(connection.encrypted_data_bag_secret_path)
+      if client.encrypted_data_bag_secret_path.nil? ||
+        !File.exists?(client.encrypted_data_bag_secret_path)
 
         return nil
       end
 
-      options = connection.ssh.merge(options)
-      secret  = File.read(connection.encrypted_data_bag_secret_path).chomp
+      options = client.ssh.merge(options)
+      secret  = File.read(client.encrypted_data_bag_secret_path).chomp
       command = "echo '#{secret}' > /etc/chef/encrypted_data_bag_secret; chmod 0600 /etc/chef/encrypted_data_bag_secret"
 
       Ridley.log.debug "Writing Encrypted Data Bag Secret to: #{self.public_hostname}"
@@ -238,7 +238,7 @@ module Ridley
     # @option options [Hash] :attributes
     #   attributes of normal precedence to merge
     #
-    # @return [Ridley::Node]
+    # @return [Ridley::NodeResource]
     def merge_data(options = {})
       unless options[:run_list].nil?
         self.run_list = (self.run_list + Array(options[:run_list])).uniq
@@ -252,17 +252,4 @@ module Ridley
       self
     end
   end
-  
-  module DSL
-    # Coerces instance functions into class functions on Ridley::Node. 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::Node
-    def node
-      ChainLink.new(self, Ridley::Node)
-    end
-  end
 end

data/lib/ridley/resources/{role.rb → role_resource.rb}

@@ -1,6 +1,6 @@
 module Ridley
   # @author Jamie Winsor <jamie@vialstudios.com>
-  class Role < Ridley::Resource
+  class RoleResource < Ridley::Resource
     set_chef_id "name"
     set_chef_type "role"
     set_chef_json_class "Chef::Role"
@@ -60,17 +60,4 @@ module Ridley
       self.default_attributes = self.default_attributes.deep_merge(attr_hash)
     end
   end
-
-  module DSL
-    # Coerces instance functions into class functions on Ridley::Role. 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::Role
-    def role
-      ChainLink.new(self, Ridley::Role)
-    end
-  end
 end

data/lib/ridley/resources/sandbox_resource.rb

@@ -0,0 +1,86 @@
+module Ridley
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  class SandboxResource
+    class << self
+      # Create a new Sandbox on the client's Chef Server. A Sandbox requires an
+      # array of file checksums which lets the Chef Server know what the signature
+      # of the contents to be uploaded will look like.
+      #
+      # @param [Ridley::Client] client
+      # @param [Array] checksums
+      #   a hash of file checksums
+      #
+      # @example using the Ridley client to create a sandbox
+      #   client.sandbox.create([
+      #     "385ea5490c86570c7de71070bce9384a",
+      #     "f6f73175e979bd90af6184ec277f760c",
+      #     "2e03dd7e5b2e6c8eab1cf41ac61396d5"
+      #   ])
+      #
+      # @return [Array<Ridley::SandboxResource>]
+      def create(client, checksums = [])
+        sumhash = { checksums: Hash.new }.tap do |chks|
+          Array(checksums).each { |chk| chks[:checksums][chk] = nil }
+        end
+
+        new(client, client.connection.post("sandboxes", MultiJson.encode(sumhash)).body)
+      end
+    end
+
+    include Chozo::VariaModel
+
+    attribute :sandbox_id,
+      type: String
+
+    attribute :uri,
+      type: String
+
+    attribute :checksums,
+      type: Hash
+
+    attribute :is_completed,
+      type: Boolean,
+      default: false
+
+    attr_reader :client
+
+    # @param [Ridley::Client] client
+    # @param [Hash] new_attrs
+    def initialize(client, new_attrs = {})
+      @client = client
+      mass_assign(new_attrs)
+    end
+
+    # Return information about the given checksum
+    #
+    # @example
+    #   sandbox.checksum("e5a0f6b48d0712382295ff30bec1f9cc") => {
+    #     needs_upload: true,
+    #     url: "https://s3.amazonaws.com/opscode-platform-production-data/organization"
+    #   }
+    #
+    # @param [#to_sym] chk_id
+    #   checksum to retrieve information about
+    #
+    # @return [Hash]
+    #   a hash containing the checksum information
+    def checksum(chk_id)
+      checksums[chk_id.to_sym]
+    end
+
+    # Concurrently upload all of this sandboxes files into the checksum containers of the sandbox
+    def upload(checksums)
+      SandboxUploader.upload(self, checksums)
+    end
+
+    # Notify the Chef Server that uploading to this sandbox has completed
+    def commit
+      response = client.connection.put("sandboxes/#{sandbox_id}", MultiJson.encode(is_completed: true)).body
+      set_attribute(:is_completed, response[:is_completed])
+    end
+
+    def to_s
+      "#{sandbox_id}: #{checksums}"
+    end
+  end
+end

data/lib/ridley/resources/search.rb

@@ -3,20 +3,20 @@ module Ridley
     class << self
       # Returns an array of possible search indexes to be search on
       #
-      # @param [Ridley::Connection] connection
+      # @param [Ridley::Client] client
       #
       # @example
       #
-      #   Search.indexes(connection) => [ :client, :environment, :node, :role ]
+      #   Search.indexes(client) => [ :client, :environment, :node, :role ]
       #
       # @return [Array<String, Symbol>]
-      def indexes(connection)
-        connection.get("search").body.collect { |name, _| name }
+      def indexes(client)
+        client.connection.get("search").body.collect { |name, _| name }
       end
     end
 
-    # @return [Ridley::Connection]
-    attr_reader :connection
+    # @return [Ridley::Client]
+    attr_reader :client
     attr_reader :index
     attr_reader :query
     
@@ -24,7 +24,7 @@ module Ridley
     attr_accessor :rows
     attr_accessor :start
 
-    # @param [Ridley::Connection] connection
+    # @param [Ridley::Client] client
     # @param [#to_sym] index
     # @param [#to_s] query
     #
@@ -34,20 +34,19 @@ module Ridley
     #   how many rows to return
     # @option options [Integer] :start
     #   the result number to start from
-    def initialize(connection, index, query, options = {})
-      @connection = connection
-      @index      = index.to_sym
-      @query      = query
-
-      @sort       = options[:sort]
-      @rows       = options[:rows]
-      @start      = options[:start]
+    def initialize(client, index, query, options = {})
+      @client = client
+      @index  = index.to_sym
+      @query  = query
+      @sort   = options[:sort]
+      @rows   = options[:rows]
+      @start  = options[:start]
     end
 
-    # Executes the built up query on the search's connection
+    # Executes the built up query on the search's client
     #
     # @example
-    #   Search.new(connection, :role)
+    #   Search.new(client, :role)
     #   search.run => 
     #     {
     #       total: 1,
@@ -68,17 +67,17 @@ module Ridley
     #
     # @return [Hash]
     def run
-      response = connection.get(query_uri, query_options).body
+      response = client.connection.get(query_uri, query_options).body
 
       case index
       when :node
-        response[:rows].collect { |row| Node.new(connection, row) }
+        response[:rows].collect { |row| Ridley::NodeResource.new(client, row) }
       when :role
-        response[:rows].collect { |row| Role.new(connection, row) }
+        response[:rows].collect { |row| Ridley::RoleResource.new(client, row) }
       when :client
-        response[:rows].collect { |row| Client.new(connection, row) }
+        response[:rows].collect { |row| Ridley::ClientResource.new(client, row) }
       when :environment
-        response[:rows].collect { |row| Environment.new(connection, row) }
+        response[:rows].collect { |row| Ridley::EnvironmentResource.new(client, row) }
       else
         response[:rows]
       end
@@ -92,41 +91,11 @@ module Ridley
 
       def query_options
         {}.tap do |options|
-          options[:q] = self.query unless self.query.nil?
-          options[:sort] = self.sort unless self.sort.nil?
-          options[:rows] = self.rows unless self.rows.nil?
+          options[:q]     = self.query unless self.query.nil?
+          options[:sort]  = self.sort unless self.sort.nil?
+          options[:rows]  = self.rows unless self.rows.nil?
           options[:start] = self.start unless self.start.nil?
         end
       end
     end
-
-  module DSL
-    # Creates an runs a new Ridley::Search
-    #
-    # @see Ridley::Search#run
-    #
-    # @param [String, Symbol] index
-    # @param [String, nil] query
-    #
-    # @option options [String] :sort
-    # @option options [Integer] :rows
-    # @option options [Integer] :start
-    #
-    # @return [Hash]
-    def search(index, query = nil, options = {})
-      Search.new(self, index, query, options).run
-    end
-
-    # Return the array of all possible search indexes for the including connection
-    #
-    # @example
-    #   conn = Ridley.connection(...)
-    #   conn.search_indexes => 
-    #     [:client, :environment, :node, :role, :"ridley-two", :"ridley-one"]
-    #
-    # @return [Array<Symbol, String>]
-    def search_indexes
-      Search.indexes(self)
-    end
-  end
 end

data/lib/ridley/sandbox_uploader.rb

@@ -0,0 +1,118 @@
+module Ridley
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  # @api private
+  class SandboxUploader
+    class << self
+      # Concurrently upload all of the files in the given sandbox and then clean up
+      # after ourselves
+      #
+      # @param [Ridley::SandboxResource] sandbox
+      # @param [Hash] checksums
+      #
+      # @option options [Integer] :pool_size (12)
+      #   the amount of concurrent uploads to perform
+      def upload(sandbox, checksums, options = {})
+        options = options.reverse_merge(
+          pool_size: 12
+        )
+        uploader = pool(size: options[:pool_size], args: [sandbox])
+        uploader.multi_upload(checksums)
+      ensure
+        uploader.terminate if uploader && uploader.alive?
+      end
+
+      # Return the checksum of the contents of the file at the given filepath
+      #
+      # @param [String] path
+      #   file to checksum
+      #
+      # @return [String]
+      #   the binary checksum of the contents of the file
+      def checksum(path)
+        File.open(path, 'rb') { |f| checksum_io(f, Digest::MD5.new) }
+      end
+
+      # Return a base64 encoded checksum of the contents of hte given file. This is the expected
+      # format of sandbox checksums given to the Chef Server.
+      #
+      # @param [String] path
+      #
+      # @return [String]
+      #   a base64 encoded checksum
+      def checksum64(path)
+        Base64.encode64([checksum(path)].pack("H*")).strip
+      end
+
+      # @param [String] io
+      # @param [Object] digest
+      #
+      # @return [String]
+      def checksum_io(io, digest)
+        while chunk = io.read(1024 * 8)
+          digest.update(chunk)
+        end
+        digest.hexdigest
+      end
+    end
+
+    extend Forwardable
+    include Celluloid
+
+    attr_reader :sandbox
+
+    def_delegator :sandbox, :client
+    def_delegator :sandbox, :checksum
+
+    def initialize(sandbox)
+      @sandbox = sandbox
+    end
+
+    # Concurrently upload multiple files into a sandbox
+    #
+    # @param [Hash] checksums
+    #   a hash of file checksums and file paths
+    #
+    # @example uploading multiple checksums
+    #
+    #   sandbox.multi_upload(
+    #     "e5a0f6b48d0712382295ff30bec1f9cc" => "/Users/reset/code/rbenv-cookbook/recipes/default.rb",
+    #     "de6532a7fbe717d52020dc9f3ae47dbe" => "/Users/reset/code/rbenv-cookbook/recipes/ohai_plugin.rb"
+    #   )
+    def multi_upload(checksums)
+      checksums.collect do |chk_id, path|
+        future.upload(chk_id, path)
+      end.map(&:value)
+    end
+
+    # Upload one file into the sandbox for the given checksum id
+    #
+    # @param [String] chk_id
+    #   checksum of the file being uploaded
+    # @param [String] path
+    #   path to the file to upload
+    #
+    # @return [Hash, nil]
+    def upload(chk_id, path)
+      checksum = self.checksum(chk_id)
+      
+      unless checksum[:needs_upload]
+        return nil
+      end
+
+      headers  = {
+        'Content-Type' => 'application/x-binary',
+        'content-md5' => self.class.checksum64(path)
+      }
+      contents = File.open(path, 'rb') { |f| f.read }
+
+      url         = URI(checksum[:url])
+      upload_path = url.path
+      url.path    = ""
+
+      Faraday.new(url) do |c|
+        c.request :chef_auth, client.client_name, client.client_key
+        c.adapter :net_http
+      end.put(upload_path, contents, headers)
+    end
+  end
+end