ridley 0.7.0.beta → 0.7.0.rc1

data/lib/ridley/resources/cookbook_resource.rb

@@ -0,0 +1,121 @@
+module Ridley
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  class CookbookResource < Ridley::Resource
+    class << self
+      def create(*args)
+        raise NotImplementedError
+      end
+
+      def delete(*args)
+        raise NotImplementedError
+      end
+
+      def delete_all(*args)
+        raise NotImplementedError
+      end
+
+      # @param [Ridley::Client] client
+      # @param [String, #chef_id] object
+      # @param [String] version
+      #
+      # @return [nil, CookbookResource]
+      def find(client, object, version = nil)
+        find!(client, object, version)
+      rescue Errors::HTTPNotFound
+        nil
+      end
+
+      # @param [Ridley::Client] client
+      # @param [String, #chef_id] object
+      # @param [String] version
+      #
+      # @raise [Errors::HTTPNotFound]
+      #   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
+
+        new(client, client.connection.get(fetch_uri).body)
+      end
+
+      # Save a new Cookbook Version of the given name, version with the
+      # given manifest of files and checksums.
+      #
+      # @param [Ridley::Client] client
+      # @param [String] name
+      # @param [String] version
+      # @param [String] manifest
+      #   a JSON blob containing file names, file paths, and checksums for each
+      #   that describe the cookbook version being uploaded.
+      #
+      # @option options [Boolean] :freeze
+      # @option options [Boolean] :force
+      #
+      # @return [Hash]
+      def save(client, name, version, manifest, options = {})
+        freeze = options.fetch(:freeze, false)
+        force  = options.fetch(:force, false)
+
+        url = "cookbooks/#{name}/#{version}"
+        url << "?force=true" if force
+
+        client.connection.put(url, manifest)
+      end
+
+      def update(*args)
+        raise NotImplementedError
+      end
+    end
+
+    set_chef_id "name"
+    set_chef_type "cookbook"
+    set_chef_json_class "Chef::Cookbook"
+    set_resource_path "cookbooks"
+
+    attribute :name,
+      required: true
+
+    # Broken until resolved: https://github.com/reset/chozo/issues/17
+    # attribute :attributes,
+    #   type: Array
+
+    attribute :cookbook_name,
+      type: String
+
+    attribute :definitions,
+      type: Array
+
+    attribute :files,
+      type: Array
+
+    attribute :libraries,
+      type: Array
+
+    attribute :metadata,
+      type: Hashie::Mash
+
+    attribute :providers,
+      type: Array
+
+    attribute :recipes,
+      type: Array
+
+    attribute :resources,
+      type: Array
+
+    attribute :root_files,
+      type: Array
+
+    attribute :templates,
+      type: Array
+
+    attribute :version,
+      type: String
+  end
+end

data/lib/ridley/resources/{data_bag_item.rb → data_bag_item_resource.rb}

@@ -1,114 +1,108 @@
 module Ridley
   # @author Jamie Winsor <jamie@vialstudios.com>
-  class DataBagItem < Ridley::Resource
+  class DataBagItemResource < Ridley::Resource
     class << self
-      # @param [Ridley::Connection] connection
+      # @param [Ridley::Client] client
       #
       # @return [Array<Object>]
-      def all(connection, data_bag)
-        connection.get("#{data_bag.class.resource_path}/#{data_bag.name}").body.collect do |id, location|
-          new(connection, data_bag, id: id)
+      def all(client, data_bag)
+        client.connection.get("#{data_bag.class.resource_path}/#{data_bag.name}").body.collect do |id, location|
+          new(client, data_bag, id: id)
         end
       end
 
-      # @param [Ridley::Connection] connection
-      # @param [Ridley::DataBag] data_bag
+      # @param [Ridley::Client] client
+      # @param [Ridley::DataBagResource] data_bag
       # @param [String, #chef_id] object
       #
-      # @return [nil, Ridley::DataBagItem]
-      def find(connection, data_bag, object)
-        find!(connection, data_bag, object)
+      # @return [nil, Ridley::DataBagItemResource]
+      def find(client, data_bag, object)
+        find!(client, data_bag, object)
       rescue Errors::HTTPNotFound
         nil
       end
 
-      # @param [Ridley::Connection] connection
-      # @param [Ridley::DataBag] data_bag
+      # @param [Ridley::Client] client
+      # @param [Ridley::DataBagResource] data_bag
       # @param [String, #chef_id] object
       #
       # @raise [Errors::HTTPNotFound]
       #   if a resource with the given chef_id is not found
       #
-      # @return [Ridley::DataBagItem]
-      def find!(connection, data_bag, object)
+      # @return [Ridley::DataBagItemResource]
+      def find!(client, data_bag, object)
         chef_id = object.respond_to?(:chef_id) ? object.chef_id : object
-        new(connection, data_bag).from_hash(connection.get("#{data_bag.class.resource_path}/#{data_bag.name}/#{chef_id}").body)
+        new(client, data_bag).from_hash(client.connection.get("#{data_bag.class.resource_path}/#{data_bag.name}/#{chef_id}").body)
       end
 
-      # @param [Ridley::Connection] connection
-      # @param [Ridley::DataBag] data_bag
+      # @param [Ridley::Client] client
+      # @param [Ridley::DataBagResource] data_bag
       # @param [#to_hash] object
       #
-      # @return [Ridley::DataBagItem]
-      def create(connection, data_bag, object)
-        resource = new(connection, data_bag, object.to_hash)
+      # @return [Ridley::DataBagItemResource]
+      def create(client, data_bag, object)
+        resource = new(client, data_bag, object.to_hash)
         unless resource.valid?
           raise Errors::InvalidResource.new(resource.errors)
         end
 
-        new_attributes = connection.post("#{data_bag.class.resource_path}/#{data_bag.name}", resource.to_json).body
+        new_attributes = client.connection.post("#{data_bag.class.resource_path}/#{data_bag.name}", resource.to_json).body
         resource.from_hash(resource.attributes.deep_merge(new_attributes))
         resource
       end
 
-      # @param [Ridley::Connection] connection
-      # @param [Ridley::DataBag] data_bag
+      # @param [Ridley::Client] client
+      # @param [Ridley::DataBagResource] data_bag
       # @param [String, #chef_id] object
       #
-      # @return [Ridley::DataBagItem]
-      def delete(connection, data_bag, object)
+      # @return [Ridley::DataBagItemResource]
+      def delete(client, data_bag, object)
         chef_id = object.respond_to?(:chef_id) ? object.chef_id : object
-        new(connection, data_bag).from_hash(connection.delete("#{data_bag.class.resource_path}/#{data_bag.name}/#{chef_id}").body)
+        new(client, data_bag).from_hash(client.connection.delete("#{data_bag.class.resource_path}/#{data_bag.name}/#{chef_id}").body)
       end
 
-      # @param [Ridley::Connection] connection
-      # @param [Ridley::DataBag] data_bag
+      # @param [Ridley::Client] client
+      # @param [Ridley::DataBagResource] data_bag
       #
-      # @return [Array<Ridley::DataBagItem>]
-      def delete_all(connection, data_bag)
+      # @return [Array<Ridley::DataBagItemResource>]
+      def delete_all(client, data_bag)
         mutex = Mutex.new
         deleted = []
-        resources = all(connection, data_bag)
-
-        connection.thread_count.times.collect do
-          Thread.new(connection, data_bag, resources, deleted) do |connection, data_bag, resources, deleted|
-            while resource = mutex.synchronize { resources.pop }
-              result = delete(connection, data_bag, resource)
-              mutex.synchronize { deleted << result }
-            end
-          end
-        end.each(&:join)
-
-        deleted
+
+        all(client, data_bag).collect do |resource|
+          Celluloid::Future.new {
+            delete(client, data_bag, resource)
+          }
+        end.map(&:value)
       end
 
-      # @param [Ridley::Connection] connection
-      # @param [Ridley::DataBag] data_bag
+      # @param [Ridley::Client] client
+      # @param [Ridley::DataBagResource] data_bag
       # @param [#to_hash] object
       #
-      # @return [Ridley::DataBagItem]
-      def update(connection, data_bag, object)
-        resource = new(connection, data_bag, object.to_hash)
-        new(connection, data_bag).from_hash(
-          connection.put("#{data_bag.class.resource_path}/#{data_bag.name}/#{resource.chef_id}", resource.to_json).body
+      # @return [Ridley::DataBagItemResource]
+      def update(client, data_bag, object)
+        resource = new(client, data_bag, object.to_hash)
+        new(client, data_bag).from_hash(
+          client.connection.put("#{data_bag.class.resource_path}/#{data_bag.name}/#{resource.chef_id}", resource.to_json).body
         )
       end
     end
 
     set_assignment_mode :carefree
 
-    # @return [Ridley::DataBag]
+    # @return [Ridley::DataBagResource]
     attr_reader :data_bag
 
     attribute :id,
       type: String,
       required: true
 
-    # @param [Ridley::Connection] connection
-    # @param [Ridley::DataBag] data_bag
+    # @param [Ridley::Client] client
+    # @param [Ridley::DataBagResource] data_bag
     # @param [#to_hash] new_attrs
-    def initialize(connection, data_bag, new_attrs = {})
-      super(connection, new_attrs)
+    def initialize(client, data_bag, new_attrs = {})
+      super(client, new_attrs)
       @data_bag = data_bag
     end
 
@@ -130,7 +124,7 @@ module Ridley
     def save
       raise Errors::InvalidResource.new(self.errors) unless valid?
 
-      mass_assign(self.class.create(connection, data_bag, self).attributes)
+      mass_assign(self.class.create(client, data_bag, self).attributes)
       true
     rescue Errors::HTTPConflict
       self.update
@@ -150,7 +144,7 @@ module Ridley
 
       cipher = OpenSSL::Cipher::Cipher.new('aes-256-cbc')
       cipher.decrypt
-      cipher.pkcs5_keyivgen(connection.encrypted_data_bag_secret)
+      cipher.pkcs5_keyivgen(client.encrypted_data_bag_secret)
       decrypted_value = cipher.update(decoded_value) + cipher.final
 
       YAML.load(decrypted_value)
@@ -160,7 +154,7 @@ module Ridley
     #
     # @return [Object]
     def reload
-      mass_assign(self.class.find(connection, data_bag, self).attributes)
+      mass_assign(self.class.find(client, data_bag, self).attributes)
       self
     end
 
@@ -174,7 +168,7 @@ module Ridley
     def update
       raise Errors::InvalidResource.new(self.errors) unless valid?
 
-      mass_assign(sself.class.update(connection, data_bag, self).attributes)
+      mass_assign(sself.class.update(client, data_bag, self).attributes)
       true
     end
 
@@ -191,10 +185,5 @@ module Ridley
     def to_s
       self.attributes
     end
-
-    private
-
-      # @return [Ridley::Connection]
-      attr_reader :connection
   end
 end

data/lib/ridley/resources/data_bag_resource.rb

@@ -0,0 +1,74 @@
+require 'ridley/resources/data_bag_item_resource'
+require 'ridley/resources/encrypted_data_bag_item_resource'
+
+module Ridley
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  # @api private
+  class DBIChainLink
+    attr_reader :data_bag
+    attr_reader :client
+    attr_reader :klass
+
+    # @param [Ridley::DataBagResource] data_bag
+    # @param [Ridley::Client] client
+    #
+    # @option options [Boolean] :encrypted (false)
+    def initialize(data_bag, client, options = {})
+      options[:encrypted] ||= false
+
+      @data_bag = data_bag
+      @client = client
+      @klass = options[:encrypted] ? Ridley::EncryptedDataBagItemResource : Ridley::DataBagItemResource
+    end
+
+    def new(*args)
+      klass.send(:new, client, data_bag, *args)
+    end
+
+    def method_missing(fun, *args, &block)
+      klass.send(fun, client, data_bag, *args, &block)
+    end
+  end
+
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  class DataBagResource < Ridley::Resource
+    class << self
+      # @param [Ridley::Client] client
+      # @param [String, #chef_id] object
+      #
+      # @return [nil, Ridley::DataBagResource]
+      def find(client, object)
+        find!(client, object)
+      rescue Errors::HTTPNotFound
+        nil
+      end
+
+      # @param [Ridley::Client] client
+      # @param [String, #chef_id] object
+      #
+      # @raise [Errors::HTTPNotFound]
+      #   if a resource with the given chef_id is not found
+      #
+      # @return [Ridley::DataBagResource]
+      def find!(client, object)
+        chef_id = object.respond_to?(:chef_id) ? object.chef_id : object
+        client.connection.get("#{self.resource_path}/#{chef_id}")
+        new(client, name: chef_id)
+      end
+    end
+
+    set_chef_id "name"
+    set_resource_path "data"
+
+    attribute :name,
+      required: true
+
+    def item
+      DBIChainLink.new(self, client)
+    end
+
+    def encrypted_item
+      DBIChainLink.new(self, client, encrypted: true)
+    end
+  end
+end

data/lib/ridley/resources/encrypted_data_bag_item_resource.rb

@@ -0,0 +1,55 @@
+module Ridley
+  # @author Jamie Winsor <jamie@vialstudios.com>
+  class EncryptedDataBagItemResource
+    class << self
+      # Finds a data bag item and decrypts it.
+      #
+      # @param [Ridley::Client] client
+      # @param [Ridley::DataBagResource] data_bag
+      # @param [String, #chef_id] object
+      #
+      # @return [nil, Ridley::DataBagItemResource]
+      def find(client, data_bag, object)
+        find!(client, data_bag, object)
+      rescue Errors::HTTPNotFound
+        nil
+      end
+
+      # Finds a data bag item and decrypts it. Throws an exception if the item doesn't exist.
+      #
+      # @param [Ridley::Client] client
+      # @param [Ridley::DataBagResource] data_bag
+      # @param [String, #chef_id] object
+      #
+      # @raise [Errors::HTTPNotFound]
+      #   if a resource with the given chef_id is not found
+      #
+      # @return [nil, Ridley::DataBagItemResource]
+      def find!(client, data_bag, object)
+        data_bag_item = DataBagItem.find!(client, data_bag, object)
+        data_bag_item.decrypt
+        new(client, data_bag, data_bag_item.attributes)
+      end
+    end
+
+    attr_reader :data_bag
+    attr_reader :attributes
+
+    # @param [Ridley::Client] client
+    # @param [Ridley::DataBagResource] data_bag
+    # @param [#to_hash] attributes
+    def initialize(client, data_bag, attributes = {})
+      @client     = client
+      @data_bag   = data_bag
+      @attributes = attributes
+    end
+
+    def to_s
+      self.attributes
+    end
+
+    private
+
+      attr_reader :client
+  end
+end