ridley 0.10.2 → 0.11.0.rc1

data/lib/ridley/host_connector/ssh.rb

@@ -7,7 +7,7 @@ module Ridley
       autoload :Worker, 'ridley/host_connector/ssh/worker'
 
       class << self
-        # @param [Ridley::NodeResource, Array<Ridley::NodeResource>] nodes
+        # @param [Ridley::NodeObject, Array<Ridley::NodeObject>] nodes
         # @param [Hash] options
         def start(nodes, options = {}, &block)
           runner = new(nodes, options)
@@ -16,7 +16,7 @@ module Ridley
 
           result
         ensure
-          runner.terminate if runner && runner.alive?          
+          runner.terminate if runner && runner.alive?
         end
       end
 
@@ -26,7 +26,7 @@ module Ridley
       attr_reader :nodes
       attr_reader :options
 
-      # @param [Ridley::NodeResource, Array<Ridley::NodeResource>] nodes
+      # @param [Ridley::NodeObject, Array<Ridley::NodeObject>] nodes
       # @param [Hash] options
       #   @see Net::SSH
       def initialize(nodes, options = {})

data/lib/ridley/host_connector/ssh/worker.rb

@@ -14,7 +14,7 @@ module Ridley
         attr_reader :options
 
         EMBEDDED_RUBY_PATH = '/opt/chef/embedded/bin/ruby'.freeze
-        
+
         # @param [Hash] options
         def initialize(host, options = {})
           options = options.deep_symbolize_keys
@@ -104,16 +104,14 @@ module Ridley
           run(command)
         end
 
-        # Executes a copy of the encrypted_data_bag_secret to the nodes
+        # Writes the given encrypted data bag secret to the node
+        #
+        # @param [String] secret
+        #   your organization's encrypted data bag secret
         #
-        # @param [String] encrypted_data_bag_secret_path
-        #   the path to the encrypted_data_bag_secret
-        # 
         # @return [#run]
-        def put_secret(encrypted_data_bag_secret_path)
-          secret  = File.read(encrypted_data_bag_secret_path).chomp
+        def put_secret(secret)
           command = "echo '#{secret}' > /etc/chef/encrypted_data_bag_secret; chmod 0600 /etc/chef/encrypted_data_bag_secret"
-
           run(command)
         end
 
@@ -121,7 +119,7 @@ module Ridley
         #
         # @param [Array<String>] command_lines
         #   An Array of lines of the command to be executed
-        # 
+        #
         # @return [#run]
         def ruby_script(command_lines)
           command = "#{EMBEDDED_RUBY_PATH} -e \"#{command_lines.join(';')}\""

data/lib/ridley/host_connector/winrm/worker.rb

@@ -118,14 +118,13 @@ module Ridley
           run("chef-client")
         end
 
-        # Executes a copy of the encrypted_data_bag_secret to the nodes
+        # Writes the given encrypted data bag secret to the node
         #
-        # @param [String] encrypted_data_bag_secret_path
-        #   the path to the encrypted_data_bag_secret
+        # @param [String] secret
+        #   your organization's encrypted data bag secret
         #
         # @return [#run]
-        def put_secret(encrypted_data_bag_secret_path)
-          secret  = File.read(encrypted_data_bag_secret_path).chomp
+        def put_secret(secret)
           command = "echo #{secret} > C:\\chef\\encrypted_data_bag_secret"
           run(command)
         end

data/lib/ridley/mixin/bootstrap_binding.rb

@@ -39,7 +39,7 @@ module Ridley
     attr_reader :chef_version
     attr_reader :default_options
     attr_reader :validator_path
-    attr_reader :encrypted_data_bag_secret_path
+    attr_reader :encrypted_data_bag_secret
     attr_reader :server_url
     attr_reader :validator_client
     attr_reader :node_name
@@ -57,17 +57,6 @@ module Ridley
       MultiJson.encode attributes.merge(run_list: run_list)
     end
 
-    # @raise [Ridley::Errors::EncryptedDataBagSecretNotFound]
-    #
-    # @return [String, nil]
-    def encrypted_data_bag_secret
-      return unless encrypted_data_bag_secret_path
-
-      IO.read(encrypted_data_bag_secret_path).chomp
-    rescue Errno::ENOENT
-      raise Errors::EncryptedDataBagSecretNotFound, "Error bootstrapping: Encrypted data bag secret provided but not found at '#{encrypted_data_bag_secret_path}'"
-    end
-
     # The validation key to create a new client for the node
     #
     # @raise [Ridley::Errors::ValidatorNotFound]

data/lib/ridley/resource.rb

@@ -2,21 +2,9 @@ module Ridley
   # @author Jamie Winsor <reset@riotgames.com>
   class Resource
     class << self
-      # @return [String, nil]
-      def chef_id
-        @chef_id
-      end
-
-      # @param [String, Symbol] identifier
-      #
-      # @return [String]
-      def set_chef_id(identifier)
-        @chef_id = identifier.to_sym
-      end
-
       # @return [String]
       def resource_path
-        @resource_path ||= self.chef_type.pluralize
+        @resource_path ||= representation.chef_type.pluralize
       end
 
       # @param [String] path
@@ -26,191 +14,83 @@ module Ridley
         @resource_path = path
       end
 
-      # @return [String]
-      def chef_type
-        @chef_type ||= self.class.name.underscore
-      end
-
-      # @param [String, Symbol] type
-      #
-      # @return [String]
-      def set_chef_type(type)
-        @chef_type = type.to_s
-        attribute(:chef_type, default: type)
-      end
-
-      # @return [String, nil]
-      def chef_json_class
-        @chef_json_class
-      end
-
-      # @param [String, Symbol] klass
-      #
-      # @return [String]
-      def set_chef_json_class(klass)
-        @chef_json_class = klass
-        attribute(:json_class, default: klass)
-      end
-
-      # @param [Ridley::Client] client
-      #
-      # @return [Array<Object>]
-      def all(client)
-        client.connection.get(self.resource_path).body.collect do |identity, location|
-          new(client, self.chef_id => identity)
-        end
-      end
-      
-      # @param [Ridley::Client] client
-      # @param [String, #chef_id] object
-      #
-      # @return [nil, Object]
-      def find(client, object)
-        find!(client, object)
-      rescue Errors::ResourceNotFound
-        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 [Object]
-      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
-      # @param [#to_hash] object
-      #
-      # @return [Object]
-      def create(client, object)
-        resource = new(client, object.to_hash)
-        new_attributes = client.connection.post(self.resource_path, resource.to_json).body
-        resource.mass_assign(resource._attributes_.deep_merge(new_attributes))
-        resource
-      end
-
-      # @param [Ridley::Client] client
-      # @param [String, #chef_id] object
-      #
-      # @return [Object]
-      def delete(client, object)
-        chef_id = object.respond_to?(:chef_id) ? object.chef_id : object
-        new(client, client.connection.delete("#{self.resource_path}/#{chef_id}").body)
-      end
-
-      # @param [Ridley::Client] client
-      #
-      # @return [Array<Object>]
-      def delete_all(client)
-        mutex = Mutex.new
-        deleted = []
-
-        all(client).collect do |resource|
-          Celluloid::Future.new {
-            delete(client, resource)
-          }
-        end.map(&:value)
+      def representation
+        return @representation if @representation
+        raise RuntimeError.new("no representation set")
       end
 
-      # @param [Ridley::Client] client
-      # @param [#to_hash] object
-      #
-      # @return [Object]
-      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)
+      def represented_by(klass)
+        @representation = klass
       end
     end
 
+    include Celluloid
     include Chozo::VariaModel
     include Comparable
 
-    # @param [Ridley::Client] client
-    # @param [Hash] new_attrs
-    def initialize(client, new_attrs = {})
-      @client = client
-      mass_assign(new_attrs)
+    # @param [Celluloid::Registry] connection_registry
+    def initialize(connection_registry)
+      @connection_registry = connection_registry
     end
 
-    # Creates a resource on the target remote or updates one if the resource
-    # already exists.
-    #
-    # @raise [Errors::InvalidResource]
-    #   if the resource does not pass validations
-    #
-    # @return [Boolean]
-    def save
-      raise Errors::InvalidResource.new(self.errors) unless valid?
-
-      mass_assign(self.class.create(client, self)._attributes_)
-      true
-    rescue Errors::HTTPConflict
-      self.update
-      true
+    def new(*args)
+      self.class.representation.new(Actor.current, *args)
     end
 
-    # Updates the instantiated resource on the target remote with any changes made
-    # to self
-    #
-    # @raise [Errors::InvalidResource]
-    #   if the resource does not pass validations
-    #
-    # @return [Boolean]
-    def update
-      raise Errors::InvalidResource.new(self.errors) unless valid?
-
-      mass_assign(self.class.update(client, self)._attributes_)
-      true
+    def connection
+      @connection_registry[:connection_pool]
     end
 
-    # Reload the attributes of the instantiated resource
+    # @param [Ridley::Client] client
     #
-    # @return [Object]
-    def reload
-      mass_assign(self.class.find(client, self)._attributes_)
-      self
+    # @return [Array<Object>]
+    def all
+      connection.get(self.class.resource_path).body.collect do |identity, location|
+        new(self.class.representation.chef_id => identity)
+      end
     end
 
-    # @return [String]
-    def chef_id
-      get_attribute(self.class.chef_id)
+    # @param [String, #chef_id] object
+    #
+    # @return [nil, Object]
+    def find(object)
+      chef_id = object.respond_to?(:chef_id) ? object.chef_id : object
+      new(connection.get("#{self.class.resource_path}/#{chef_id}").body)
+    rescue Errors::HTTPNotFound => ex
+      nil
     end
 
-    def to_s
-      "#<#{self.class} chef_id:#{self.chef_id}, attributes:#{self._attributes_}>"
+    # @param [#to_hash] object
+    #
+    # @return [Object]
+    def create(object)
+      resource = new(object.to_hash)
+      new_attributes = connection.post(self.class.resource_path, resource.to_json).body
+      resource.mass_assign(resource._attributes_.deep_merge(new_attributes))
+      resource
     end
 
-    # @param [Object] other
+    # @param [String, #chef_id] object
     #
-    # @return [Boolean]
-    def <=>(other)
-      self.chef_id <=> other.chef_id
+    # @return [Object]
+    def delete(object)
+      chef_id = object.respond_to?(:chef_id) ? object.chef_id : object
+      new(connection.delete("#{self.class.resource_path}/#{chef_id}").body)
     end
 
-    def ==(other)
-      self.chef_id == other.chef_id
+    # @return [Array<Object>]
+    def delete_all
+      all.collect do |resource|
+        future(:delete, resource)
+      end.map(&:value)
     end
 
-    # @param [Object] other
+    # @param [#to_hash] object
     #
-    # @return [Boolean]
-    def eql?(other)
-      self.class == other.class && self == other
-    end
-
-    def hash
-      self.chef_id.hash
+    # @return [Object]
+    def update(object)
+      resource = new(object.to_hash)
+      new(connection.put("#{self.class.resource_path}/#{resource.chef_id}", resource.to_json).body)
     end
-
-    private
-
-      attr_reader :client
   end
 end

data/lib/ridley/resources/client_resource.rb

@@ -4,80 +4,30 @@ module Ridley
   # @example listing all clients
   #   conn = Ridley.new(...)
   #   conn.client.all #=> [
-  #     #<Ridley::ClientResource chef_id:'reset'>,
-  #     #<Ridley::ClientResource chef_id:'reset-validator'>
+  #     #<Ridley::ClientObject chef_id:'reset'>,
+  #     #<Ridley::ClientObject chef_id:'reset-validator'>
   #   ]
   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::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::ClientResource]
-      def regenerate_key(client, chef_client)
-        obj = find!(client, chef_client)
-        obj.regenerate_key
-        obj
-      end
-    end
-
-    set_chef_id "name"
-    set_chef_type "client"
-    set_chef_json_class "Chef::ApiClient"
     set_resource_path "clients"
+    represented_by Ridley::ClientObject
 
-    attribute :name,
-      type: String,
-      required: true
-
-    attribute :admin,
-      type: Boolean,
-      required: true,
-      default: false
-
-    attribute :validator,
-      type: Boolean,
-      required: true,
-      default: false
-
-    attribute :certificate,
-      type: String
-
-    attribute :public_key,
-      type: String
-
-    attribute :private_key,
-      type: [ String, Boolean ]
-
-    attribute :orgname,
-      type: String
-
-    # Regenerates the private key of the instantiated client object. The new
-    # private key will be set to the value of the 'private_key' accessor
-    # of the instantiated client object.
+    # 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.
     #
-    # @return [Boolean]
-    #   true for success and false for failure
-    def regenerate_key
-      self.private_key = true
-      self.save
-    end
-
-    # 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 client.connection.hosted?
-        to_hash.except(:json_class).to_json
-      else
-        super
+    # @param [String, #chef_id] chef_client
+    #
+    # @raise [Errors::ResourceNotFound]
+    #   if a client with the given chef_id is not found
+    #
+    # @return [Ridley::ClientObject]
+    def regenerate_key(chef_client)
+      unless chef_client = find(chef_client)
+        abort Errors::ResourceNotFound.new("client '#{chef_client}' not found")
       end
+
+      chef_client.private_key = true
+      update(chef_client)
     end
   end
 end