ridley 0.10.2 → 0.11.0.rc1

data/lib/ridley/chef_objects/role_object.rb

@@ -0,0 +1,62 @@
+module Ridley
+  # @author Jamie Winsor <reset@riotgames.com>
+  class RoleObject < Ridley::ChefObject
+    set_chef_id "name"
+    set_chef_type "role"
+    set_chef_json_class "Chef::Role"
+
+    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
+  end
+end

data/lib/ridley/chef_objects/sandbox_object.rb

@@ -0,0 +1,58 @@
+module Ridley
+  # @author Jamie Winsor <reset@riotgames.com>
+  class SandboxObject < ChefObject
+    set_chef_id "sandbox_id"
+
+    attribute :sandbox_id,
+      type: String
+
+    attribute :uri,
+      type: String
+
+    attribute :checksums,
+      type: Hash
+
+    attribute :is_completed,
+      type: Boolean,
+      default: false
+
+    # 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
+    #
+    # @param [Hash] checksums
+    #   a hash of file checksums and file paths
+    #
+    # @example
+    #   sandbox.upload(
+    #     "e5a0f6b48d0712382295ff30bec1f9cc" => "/Users/reset/code/rbenv-cookbook/recipes/default.rb",
+    #     "de6532a7fbe717d52020dc9f3ae47dbe" => "/Users/reset/code/rbenv-cookbook/recipes/ohai_plugin.rb"
+    #   )
+    def upload(checksums)
+      resource.upload(self, checksums)
+    end
+
+    # Notify the Chef Server that uploading to this sandbox has completed
+    #
+    # @raise [Ridley::Errors::SandboxCommitError]
+    def commit
+      response = resource.commit(self)
+      set_attribute(:is_completed, response[:is_completed])
+    end
+  end
+end

data/lib/ridley/client.rb

@@ -22,13 +22,40 @@ module Ridley
   #   r.save
   #
   #   connection.role.find("new-role") => <#Ridley::RoleResource: @name="new-role">
-  class Client < Celluloid::SupervisionGroup
+  class Client
+    class ConnectionSupervisor < ::Celluloid::SupervisionGroup
+      def initialize(registry, options)
+        super(registry)
+        pool(Ridley::Connection, size: options[:pool_size], args: [
+          options[:server_url],
+          options[:client_name],
+          options[:client_key],
+          options.slice(*Ridley::Connection::VALID_OPTIONS)
+        ], as: :connection_pool)
+      end
+    end
+
+    class ResourcesSupervisor < ::Celluloid::SupervisionGroup
+      def initialize(registry, connection_registry, options)
+        super(registry)
+        supervise_as :client_resource, Ridley::ClientResource, connection_registry
+        supervise_as :cookbook_resource, Ridley::CookbookResource, connection_registry,
+          options[:client_name], options[:client_key], options.slice(*Ridley::Connection::VALID_OPTIONS)
+        supervise_as :data_bag_resource, Ridley::DataBagResource, connection_registry,
+          options[:encrypted_data_bag_secret]
+        supervise_as :environment_resource, Ridley::EnvironmentResource, connection_registry
+        supervise_as :node_resource, Ridley::NodeResource, connection_registry, options
+        supervise_as :role_resource, Ridley::RoleResource, connection_registry
+        supervise_as :sandbox_resource, Ridley::SandboxResource, connection_registry,
+          options[:client_name], options[:client_key], options.slice(*Ridley::Connection::VALID_OPTIONS)
+        supervise_as :search_resource, Ridley::SearchResource, connection_registry
+      end
+    end
+
     class << self
       def open(options = {}, &block)
         cli = new(options)
         cli.evaluate(&block)
-      ensure
-        cli.terminate if cli && cli.alive?
       end
 
       # @raise [ArgumentError]
@@ -37,13 +64,13 @@ module Ridley
       def validate_options(options)
         missing = (REQUIRED_OPTIONS - options.keys)
 
-        unless missing.empty?
+        if missing.any?
           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?
+        if missing_values.any?
           values = missing_values.keys.collect { |opt| "'#{opt}'" }
           raise ArgumentError, "Missing value for required option(s): '#{values.join(', ')}'"
         end
@@ -57,8 +84,14 @@ module Ridley
     ].freeze
 
     extend Forwardable
+    include Celluloid
     include Ridley::Logging
 
+    finalizer do
+      @connection_supervisor.terminate if @connection_supervisor && @connection_supervisor.alive?
+      @resources_supervisor.terminate if @resources_supervisor && @resources_supervisor.alive?
+    end
+
     def_delegator :connection, :build_url
     def_delegator :connection, :scheme
     def_delegator :connection, :host
@@ -66,6 +99,7 @@ module Ridley
     def_delegator :connection, :path_prefix
     def_delegator :connection, :url_prefix
 
+    def_delegator :connection, :organization
     def_delegator :connection, :client_key
     def_delegator :connection, :client_key=
     def_delegator :connection, :client_name
@@ -111,16 +145,16 @@ 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
+    # @option options [Integer] :pool_size (4)
+    #   size of the connection pool
     #
     # @raise [Errors::ClientKeyFileNotFound] if the option for :client_key does not contain
     #   a file path pointing to a readable client key
     def initialize(options = {})
-      log.info { "Ridley starting..." }
-      super()
-
       @options = options.reverse_merge(
         ssh: Hash.new,
-        winrm: Hash.new
+        winrm: Hash.new,
+        pool_size: 4
       ).deep_symbolize_keys
       self.class.validate_options(@options)
 
@@ -139,79 +173,80 @@ module Ridley
         @encrypted_data_bag_secret_path = File.expand_path(@options[:encrypted_data_bag_secret_path])
       end
 
+      @options[:encrypted_data_bag_secret] = encrypted_data_bag_secret
+
       unless @options[:client_key].present? && File.exist?(@options[:client_key])
         raise Errors::ClientKeyFileNotFound, "client key not found at: '#{@options[:client_key]}'"
       end
 
-      pool(Ridley::Connection, size: 4, args: [
-        @options[:server_url],
-        @options[:client_name],
-        @options[:client_key],
-        @options.slice(*Connection::VALID_OPTIONS)
-      ], as: :connection_pool)
+      @connection_registry   = Celluloid::Registry.new
+      @resources_registry    = Celluloid::Registry.new
+      @connection_supervisor = ConnectionSupervisor.new(@connection_registry, @options)
+      @resources_supervisor  = ResourcesSupervisor.new(@resources_registry, @connection_registry, @options)
     end
 
-    # @return [Ridley::ChainLink]
+    # @return [Ridley::ClientResource]
     def client
-      ChainLink.new(Actor.current, Ridley::ClientResource)
+      @resources_registry[:client_resource]
     end
 
-    # @return [Ridley::ChainLink]
+    # @return [Ridley::CookbookResource]
     def cookbook
-      ChainLink.new(Actor.current, Ridley::CookbookResource)
+      @resources_registry[:cookbook_resource]
     end
 
-    # @return [Ridley::ChainLink]
+    # @return [Ridley::DataBagResource]
     def data_bag
-      ChainLink.new(Actor.current, Ridley::DataBagResource)
+      @resources_registry[:data_bag_resource]
     end
 
-    # @return [Ridley::ChainLink]
+    # @return [Ridley::EnvironmentResource]
     def environment
-      ChainLink.new(Actor.current, Ridley::EnvironmentResource)
+      @resources_registry[:environment_resource]
     end
 
-    # @return [Ridley::ChainLink]
+    # @return [Ridley::NodeResource]
     def node
-      ChainLink.new(Actor.current, Ridley::NodeResource)
+      @resources_registry[:node_resource]
     end
 
-    # @return [Ridley::ChainLink]
+    # @return [Ridley::RoleResource]
     def role
-      ChainLink.new(Actor.current, Ridley::RoleResource)
+      @resources_registry[:role_resource]
     end
 
-    # @return [Ridley::ChainLink]
+    # @return [Ridley::SandboxResource]
     def sandbox
-      ChainLink.new(Actor.current, Ridley::SandboxResource)
+      @resources_registry[:sandbox_resource]
     end
 
-    # Creates an runs a new Ridley::Search
-    #
-    # @see Ridley::Search#run
+    # Perform a search the Chef Server
     #
-    # @param [String, Symbol] index
-    # @param [String, nil] query
+    # @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
     #
     # @return [Hash]
     def search(index, query = nil, options = {})
-      Ridley::Search.new(Actor.current, index, query, options).run
+      @resources_registry[:search_resource].run(index, query, options)
     end
 
     # Return the array of all possible search indexes for the including connection
     #
     # @example
     #   conn = Ridley.new(...)
-    #   conn.search_indexes => 
+    #   conn.search_indexes =>
     #     [:client, :environment, :node, :role, :"ridley-two", :"ridley-one"]
     #
     # @return [Array<Symbol, String>]
     def search_indexes
-      Ridley::Search.indexes(Actor.current)
+      @resources_registry[:search_resource].indexes
     end
 
     # The encrypted data bag secret for this connection.
@@ -241,16 +276,12 @@ module Ridley
     end
     alias_method :sync, :evaluate
 
-    def finalize
-      connection.terminate if connection && connection.alive?
-    end
-
-    def connection
-      @registry[:connection_pool]
-    end
-
     private
 
+      def connection
+        @connection_registry[:connection_pool]
+      end
+
       def method_missing(method, *args, &block)
         if block_given?
           @self_before_instance_eval ||= eval("self", block.binding)

data/lib/ridley/connection.rb

@@ -96,7 +96,7 @@ module Ridley
     # we expect. Caught exceptions are re-raised with Celluloid#abort so we don't crash the connection.
     def run_request(*args)
       super
-    rescue Errors::HTTPError => ex
+    rescue Errors::HTTPError, Faraday::Error => ex
       abort(ex)
     end
 

data/lib/ridley/errors.rb

@@ -34,6 +34,11 @@ module Ridley
     end
 
     class CookbookSyntaxError < RidleyError; end
+    class EncryptedDataBagSecretNotSet < RidleyError
+      def message
+        "no encrypted data bag secret was set for this Ridley connection"
+      end
+    end
 
     class BootstrapError < RidleyError; end
     class ClientKeyFileNotFound < BootstrapError; end
@@ -54,6 +59,8 @@ module Ridley
     end
 
     class FrozenCookbook < RidleyError; end
+    class SandboxCommitError < RidleyError; end
+    class PermissionDenied < RidleyError; end
 
     class HTTPError < RidleyError
       class << self
@@ -74,7 +81,7 @@ module Ridley
 
         def error_map
           @@error_map ||= Hash.new
-        end        
+        end
       end
 
       attr_reader :env

data/lib/ridley/host_connector.rb

@@ -13,13 +13,35 @@ module Ridley
     DEFAULT_WINRM_PORT = 5985.freeze
 
     class << self
+      # Create a new connection worker for the given host. An SSH or WinRM connection will be returned
+      # depending on which ports are open on the target host.
+      #
+      # @param [String] host
+      #   host to create a connector for
+      #
+      # @option options [Hash] ssh
+      #   * :user (String) a shell user that will login to each node and perform the bootstrap command on
+      #   * :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
+      # @option options [Hash] :winrm
+      #   * :user (String) a user that will login to each node and perform the bootstrap command on
+      #   * :password (String) the password for the user that will perform the bootstrap
+      #   * :port (Fixnum) the winrm port to connect on the node the bootstrap will be performed on
+      #
+      # @return [SSH::Worker, WinRM::Worker]
+      def new(host, options = {})
+        HostConnector.best_connector_for(host, options) do |host_connector|
+          host_connector::Worker.new(host, options)
+        end
+      end
+
       # Finds and returns the best HostConnector for a given host
       #
       # @param  host [String]
       #   the host to attempt to connect to
       # @option options [Hash] :ssh
       #   * :port (Fixnum) the ssh port to connect on the node the bootstrap will be performed on (22)
-      #   * :timeout (Float) [5.0] timeout value for testing SSH connection
       # @option options [Hash] :winrm
       #   * :port (Fixnum) the winrm port to connect on the node the bootstrap will be performed on (5985)
       # @param block [Proc]
@@ -28,7 +50,7 @@ module Ridley
       # @return [Ridley::HostConnector] a class under Ridley::HostConnector
       def best_connector_for(host, options = {}, &block)
         ssh_port, winrm_port = parse_port_options(options)
-        if connector_port_open?(host, ssh_port, options[:ssh][:timeout])
+        if connector_port_open?(host, ssh_port)
           host_connector = Ridley::HostConnector::SSH
         elsif connector_port_open?(host, winrm_port)
           host_connector = Ridley::HostConnector::WinRM
@@ -50,12 +72,10 @@ module Ridley
       #   the host to attempt to connect to
       # @param  port [Fixnum]
       #   the port to attempt to connect on
-      # @param  timeout [Float]
-      #   the number of seconds to wait (default: 3)
       #
       # @return [Boolean]
-      def connector_port_open?(host, port, timeout=3)
-        Timeout::timeout(timeout) do
+      def connector_port_open?(host, port)
+        Timeout::timeout(3) do
           socket = TCPSocket.new(host, port)
           socket.close
         end