ridley 0.10.2 → 0.11.0.rc1

data/lib/ridley/resources/role_resource.rb

@@ -1,63 +1,7 @@
 module Ridley
   # @author Jamie Winsor <reset@riotgames.com>
   class RoleResource < Ridley::Resource
-    set_chef_id "name"
-    set_chef_type "role"
-    set_chef_json_class "Chef::Role"
     set_resource_path "roles"
-
-    attribute :name,
-      required: true
-
-    attribute :description,
-      default: String.new
-
-    attribute :default_attributes,
-      default: Hashie::Mash.new
-
-    attribute :override_attributes,
-      default: Hashie::Mash.new
-
-    attribute :run_list,
-      default: Array.new
-
-    attribute :env_run_lists,
-      default: Hash.new
-
-    # Set a role level override attribute given the dotted path representation of the Chef
-    # attribute and value
-    # 
-    # @example setting and saving a node level override attribute
-    #
-    #   obj = node.role("why_god_why")
-    #   obj.set_override_attribute("my_app.billing.enabled", false)
-    #   obj.save
-    #
-    # @param [String] key
-    # @param [Object] value
-    #
-    # @return [HashWithIndifferentAccess]
-    def set_override_attribute(key, value)
-      attr_hash = HashWithIndifferentAccess.from_dotted_path(key, value)
-      self.override_attributes = self.override_attributes.deep_merge(attr_hash)
-    end
-
-    # Set a role level default attribute given the dotted path representation of the Chef
-    # attribute and value
-    # 
-    # @example setting and saving a node level default attribute
-    #
-    #   obj = node.role("why_god_why")
-    #   obj.set_default_attribute("my_app.billing.enabled", false)
-    #   obj.save
-    #
-    # @param [String] key
-    # @param [Object] value
-    #
-    # @return [HashWithIndifferentAccess]
-    def set_default_attribute(key, value)
-      attr_hash = HashWithIndifferentAccess.from_dotted_path(key, value)
-      self.default_attributes = self.default_attributes.deep_merge(attr_hash)
-    end
+    represented_by Ridley::RoleObject
   end
 end

data/lib/ridley/resources/sandbox_resource.rb

@@ -1,86 +1,101 @@
 module Ridley
   # @author Jamie Winsor <reset@riotgames.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
+  class SandboxResource < Ridley::Resource
+    set_resource_path "sandboxes"
+    represented_by Ridley::SandboxObject
 
-        new(client, client.connection.post("sandboxes", MultiJson.encode(sumhash)).body)
-      end
+    finalizer do
+      uploader.terminate if uploader && uploader.alive?
     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
+    def initialize(connection_registry, client_name, client_key, options = {})
+      super(connection_registry)
+      options   = options.reverse_merge(pool_size: 4)
+      @uploader = SandboxUploader.pool(size: options[:pool_size], args: [ client_name, client_key, options ])
+    end
 
+    # 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 [Hash] new_attrs
-    def initialize(client, new_attrs = {})
-      @client = client
-      mass_assign(new_attrs)
+    # @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(checksums = [])
+      sumhash = { checksums: Hash.new }.tap do |chks|
+        Array(checksums).each { |chk| chks[:checksums][chk] = nil }
+      end
+      new(connection.post(self.class.resource_path, MultiJson.encode(sumhash)).body)
     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 [#chef_id] object
     #
-    # @param [#to_sym] chk_id
-    #   checksum to retrieve information about
+    # @raise [Ridley::Errors::SandboxCommitError]
+    # @raise [Ridley::Errors::ResourceNotFound]
+    # @raise [Ridley::Errors::PermissionDenied]
     #
     # @return [Hash]
-    #   a hash containing the checksum information
-    def checksum(chk_id)
-      checksums[chk_id.to_sym]
+    def commit(object)
+      chef_id = object.respond_to?(:chef_id) ? object.chef_id : object
+      connection.put("#{self.class.resource_path}/#{chef_id}", MultiJson.encode(is_completed: true)).body
+    rescue Ridley::Errors::HTTPBadRequest => ex
+      abort Ridley::Errors::SandboxCommitError.new(ex.message)
+    rescue Ridley::Errors::HTTPNotFound => ex
+      abort Ridley::Errors::ResourceNotFound.new(ex.message)
+    rescue Ridley::Errors::HTTPUnauthorized, Ridley::Errors::HTTPForbidden => ex
+      abort Ridley::Errors::PermissionDenied.new(ex.message)
     end
 
-    # Concurrently upload all of this sandboxes files into the checksum containers of the sandbox
-    def upload(checksums)
-      SandboxUploader.upload(self, checksums)
+    # Concurrently upload all of the files in the given sandbox
+    #
+    # @param [Ridley::SandboxObject] sandbox
+    # @param [Hash] checksums
+    #   a hash of file checksums and file paths
+    #
+    # @example
+    #   SandboxUploader.upload(sandbox,
+    #     "e5a0f6b48d0712382295ff30bec1f9cc" => "/Users/reset/code/rbenv-cookbook/recipes/default.rb",
+    #     "de6532a7fbe717d52020dc9f3ae47dbe" => "/Users/reset/code/rbenv-cookbook/recipes/ohai_plugin.rb"
+    #   )
+    #
+    # @return [Array<Hash>]
+    def upload(object, checksums)
+      checksums.collect do |chk_id, path|
+        uploader.future(:upload, object, chk_id, path)
+      end.map(&:value)
+    end
+
+    def update(*args)
+      raise RuntimeError, "action not supported"
     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])
+    def all(*args)
+      raise RuntimeError, "action not supported"
     end
 
-    def to_s
-      "#{sandbox_id}: #{checksums}"
+    def find(*args)
+      raise RuntimeError, "action not supported"
     end
+
+    def delete(*args)
+      raise RuntimeError, "action not supported"
+    end
+
+    def delete_all(*args)
+      raise RuntimeError, "action not supported"
+    end
+
+    private
+
+      attr_reader :uploader
   end
 end

data/lib/ridley/resources/search_resource.rb

@@ -0,0 +1,99 @@
+module Ridley
+  # @author Jamie Winsor <reset@riotgames.com>
+  class SearchResource < Ridley::Resource
+    class << self
+      # @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
+      #
+      # @return [Hash]
+      def build_query(query_string, options = {})
+        {}.tap do |query_opts|
+          query_opts[:q]     = query_string unless query_string.nil?
+          query_opts[:sort]  = options[:sort] unless options[:sort].nil?
+          query_opts[:rows]  = options[:rows] unless options[:rows].nil?
+          query_opts[:start] = options[:start] unless options[:start].nil?
+        end
+      end
+
+      # @param [#to_s] index
+      #
+      # @return [String]
+      def query_uri(index)
+        "#{resource_path}/#{index}"
+      end
+    end
+
+    set_resource_path "search"
+
+    # Returns an array of possible search indexes to be search on
+    #
+    # @param [Ridley::Client] client
+    #
+    # @example
+    #
+    #   Search.indexes(client) => [ :client, :environment, :node, :role ]
+    #
+    # @return [Array<String, Symbol>]
+    def indexes
+      connection.get(self.class.resource_path).body.collect { |name, _| name }
+    end
+
+    # Executes the built up query on the search's client
+    #
+    # @param [#to_sym, #to_s] index
+    # @param [#to_s] 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
+    #   Search.new(client, :role)
+    #   search.run =>
+    #     {
+    #       total: 1,
+    #       start: 0,
+    #       rows: [
+    #         {
+    #           name: "ridley-test-role",
+    #           default_attributes: {},
+    #           json_class: "Chef::Role",
+    #           env_run_lists: {},
+    #           run_list: [],
+    #           description: "a test role for Ridley!",
+    #           chef_type: "role",
+    #           override_attributes: {}
+    #         }
+    #       ]
+    #     }
+    #
+    # @return [Array<ChefObject>, Hash]
+    def run(index, query_string, options = {})
+      query_uri = self.class.query_uri(index)
+      query     = self.class.build_query(query_string, options)
+      response  = connection.get(query_uri, query).body
+
+      case index.to_sym
+      when :node
+        response[:rows].collect { |row| Ridley::NodeObject.new(row) }
+      when :role
+        response[:rows].collect { |row| Ridley::RoleObject.new(row) }
+      when :client
+        response[:rows].collect { |row| Ridley::ClientObject.new(row) }
+      when :environment
+        response[:rows].collect { |row| Ridley::EnvironmentObject.new(row) }
+      else
+        response[:rows]
+      end
+    end
+  end
+end

data/lib/ridley/sandbox_uploader.rb

@@ -3,24 +3,6 @@ module Ridley
   # @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
@@ -55,45 +37,29 @@ module Ridley
       end
     end
 
-    extend Forwardable
     include Celluloid
 
-    attr_reader :sandbox
-
-    def_delegator :sandbox, :client
-    def_delegator :sandbox, :checksum
-
-    def initialize(sandbox)
-      @sandbox = sandbox
-    end
+    attr_reader :client_name
+    attr_reader :client_key
+    attr_reader :options
 
-    # 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)
+    def initialize(client_name, client_key, options = {})
+      @client_name = client_name
+      @client_key  = client_key
+      @options     = options
     end
 
     # Upload one file into the sandbox for the given checksum id
     #
+    # @param [Ridley::SandboxObject] sandbox
     # @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)
+    def upload(sandbox, chk_id, path)
+      checksum = sandbox.checksum(chk_id)
 
       unless checksum[:needs_upload]
         return nil
@@ -109,17 +75,11 @@ module Ridley
       upload_path = url.path
       url.path    = ""
 
-      # versions prior to OSS Chef 11 will strip the port to upload the file to in the checksum
-      # url returned. This will ensure we are uploading to the proper location.
-      if client.connection.foss?
-        url.port = URI(client.connection.server_url).port
-      end
-
       begin
-        Faraday.new(url, client.options.slice(*Connection::VALID_OPTIONS)) do |c|
+        Faraday.new(url, self.options) do |c|
           c.response :chef_response
           c.response :follow_redirects
-          c.request :chef_auth, client.client_name, client.client_key
+          c.request :chef_auth, self.client_name, self.client_key
           c.adapter :net_http
         end.put(upload_path, contents, headers)
       rescue Ridley::Errors::HTTPError => ex

data/lib/ridley/version.rb

@@ -1,3 +1,3 @@
 module Ridley
-  VERSION = "0.10.2"
+  VERSION = "0.11.0.rc1"
 end

data/spec/acceptance/bootstrapping_spec.rb

@@ -23,7 +23,7 @@ describe "Bootstrapping a node", type: "acceptance" do
 
   it "returns an array of response objects" do
     pending
-    
+
     connection.node.bootstrap("33.33.33.10").should_not have_errors
   end
 end