ridley 0.5.2 → 0.6.0

data/lib/ridley/ssh/response_set.rb

@@ -2,50 +2,97 @@ module Ridley
   class SSH
     # @author Jamie Winsor <jamie@vialstudios.com>
     class ResponseSet
-      # @return [Array<SSH::Response>]
-      attr_reader :oks
-      # @return [Array<SSH::Response>]
-      attr_reader :errors
+      class << self
+        # Merges the responses of the other ResponseSet with the target ResponseSet
+        # and returns the mutated target
+        #
+        # @param [SSH::ResponseSet] target
+        # @param [SSH::ResponseSet] other
+        #
+        # @return [SSH::ResponseSet]
+        def merge!(target, other)
+          if other.is_a?(self)
+            target.add_response(other.responses)
+          end
 
-      def initialize
-        @oks = Array.new
-        @errors = Array.new
+          target
+        end
       end
 
-      # Add an "OK" response to the ResponseSet
-      #
-      # @param [SSH::Response] response
-      def add_ok(response)
-        self.oks << response
+      extend Forwardable
+      include Enumerable
+
+      attr_reader :failures
+      attr_reader :successes
+
+      def_delegator :responses, :each
+
+      def initialize(responses = Array.new)
+        @failures  = Array.new
+        @successes = Array.new
+
+        add_response Array(responses)
       end
 
-      # Add an "Error" response to the ResponseSet
+      # @param [SSH::Response, Array<SSH::Response>] response
       #
-      # @param [SSH::Response] response
-      def add_error(response)
-        self.errors << response
+      # @return [Array<SSH::Response>]
+      def add_response(response)
+        if response.is_a?(Array)
+          until response.empty?
+            add_response(response.pop)
+          end
+          return responses
+        end
+
+        response.error? ? add_failure(response) : add_success(response)
+        responses
+      end
+      alias_method :<<, :add_response
+
+      def responses
+        successes + failures
       end
 
       # Return true if the response set contains any errors
       #
       # @return [Boolean]
       def has_errors?
-        self.errors.any?
+        self.failures.any?
       end
 
-      # Return one of the responses
+      # Merges the responses of another ResponseSet with self and returns
+      # a new instance of ResponseSet
+      #
+      # @param [Ridley::SSH::ResponseSet] other
       #
-      # @return [SSH::Response]
-      def first
-        (self.oks + self.errors).first
+      # @return [Ridley::SSH::ResponseSet]
+      def merge(other)
+        target = self.class.new(self.responses) # Why the fuck can't I use #dup here?
+        self.class.merge!(target, other)
       end
 
-      # Returns how many responses are in the set
+      # Merges the respones of another ResponseSet with self and returns
+      # mutated self
       #
-      # @return [Integer]
-      def length
-        self.oks.length + self.errors.length
+      # @param [Ridley::SSH::ResponseSet] other
+      #
+      # @return [self]
+      def merge!(other)
+        self.class.merge!(self, other)
       end
+
+      private
+
+        # @param [SSH::Response] response
+        def add_failure(response)
+          self.failures << response
+        end
+
+        # @param [SSH::Response] response
+        def add_success(response)
+          self.successes << response
+        end
     end
   end
 end

data/lib/ridley/ssh/worker.rb

@@ -5,11 +5,18 @@ module Ridley
     class Worker
       include Celluloid
       include Celluloid::Logger
+
+      attr_reader :sudo
+      attr_reader :user
+      attr_reader :options
       
       # @param [Hash] options
       def initialize(options = {})
-        @options = options
-        @user    = options.fetch(:user)
+        @options = options.dup
+        @sudo    = @options[:sudo]
+        @user    = @options[:user]
+
+        @options[:paranoid] = false
       end
 
       # @param [String] host
@@ -17,11 +24,15 @@ module Ridley
       #
       # @return [Array]
       def run(host, command)
-        response = Response.new("", "")
+        response = Response.new(host)
         debug "Running SSH command: '#{command}' on: '#{host}' as: '#{user}'"
 
-        Net::SSH.start(host, user, options) do |ssh|          
+        Net::SSH.start(host, user, options.slice(*Net::SSH::VALID_OPTIONS)) do |ssh|
           ssh.open_channel do |channel|
+            if self.sudo
+              channel.request_pty
+            end
+
             channel.exec(command) do |ch, success|
               unless success
                 raise "FAILURE: could not execute command"
@@ -29,10 +40,12 @@ module Ridley
 
               channel.on_data do |ch, data|
                 response.stdout += data
+                info "NODE[#{host}] #{data}" if data.present? and data != "\r\n"
               end
 
               channel.on_extended_data do |ch, type, data|
                 response.stderr += data
+                info "NODE[#{host}] #{data}" if data.present? and data != "\r\n"
               end
 
               channel.on_request("exit-status") do |ch, data|
@@ -50,22 +63,24 @@ module Ridley
 
         case response.exit_code
         when 0
-          debug "Successfully ran SSH command: '#{command}' on: '#{host}' as: '#{user}' and it succeeded"
+          debug "Successfully ran SSH command on: '#{host}' as: '#{user}'"
           [ :ok, response ]
         else
-          debug "Successfully ran SSH command: '#{command}' on: '#{host}' as: '#{user}' but it failed"
+          error "Successfully ran SSH command on: '#{host}' as: '#{user}', but it failed"
+          error response.stdout
           [ :error, response ]
         end
       rescue => e
-        debug "Failed to run SSH command: '#{command}' on: '#{host}' as: '#{user}'"
-        [ :error, e.message ]
+        error "Failed to run SSH command on: '#{host}' as: '#{user}'"
+        error "#{e.class}: #{e.message}"
+        response.exit_code = -1
+        response.stderr = e.message
+        [ :error, response ]
       end
 
       private
 
         attr_reader :runner
-        attr_reader :user
-        attr_reader :options
     end
   end
 end

data/lib/ridley/ssh.rb

@@ -29,46 +29,28 @@ module Ridley
     # @param [Hash] options
     #   @see Net::SSH
     def initialize(nodes, options = {})
-      @nodes   = nodes
+      @nodes   = Array(nodes)
       @options = options
-
-      self.options[:timeout] ||= 1.5
-    end
-
-    # @return [Array<SSH::Worker>]
-    def workers
-      @workers ||= Array(nodes).collect do |node|
-        Worker.new_link(current_actor, node.public_hostname, options)
-      end
     end
 
     # @param [String] command
     #
     # @return [Array]
     def run(command)
-      workers.collect { |worker| worker.async.run(command) }
+      workers = Array.new
+      futures = self.nodes.collect do |node|
+        workers << worker = Worker.new_link(self.options.freeze)
+        worker.future.run(node.public_hostname, command)
+      end
 
-      ResponseSet.new.tap do |responses|
-        until responses.length == workers.length
-          receive { |msg|
-            status, response = msg
-            
-            case status
-            when :ok
-              responses.add_ok(response)
-            when :error
-              responses.add_error(response)
-            else
-              error "SSH Failure: #{command}. terminating..."
-              terminate
-            end
-          }
+      ResponseSet.new.tap do |response_set|
+        futures.each do |future|
+          status, response = future.value
+          response_set.add_response(response)
         end
       end
-    end
-
-    def finalize
-      workers.collect(&:terminate)
+    ensure
+      workers.map(&:terminate)
     end
   end
 end

data/lib/ridley/version.rb

@@ -1,3 +1,3 @@
 module Ridley
-  VERSION = "0.5.2"
+  VERSION = "0.6.0"
 end

data/lib/ridley.rb

@@ -8,6 +8,7 @@ require 'active_model'
 require 'active_support/inflector'
 require 'forwardable'
 require 'thread'
+require 'pathname'
 
 if jruby?
   require 'json/pure'
@@ -41,7 +42,13 @@ module Ridley
   autoload :SSH, 'ridley/ssh'
 
   class << self
-    attr_accessor :logger
+    extend Forwardable
+
+    def_delegator "Ridley::Logging", :logger
+    alias_method :log, :logger
+
+    def_delegator "Ridley::Logging", :logger=
+    def_delegator "Ridley::Logging", :set_logger
 
     def connection(*args)
       Connection.new(*args)
@@ -51,19 +58,6 @@ module Ridley
       Connection.sync(*args, &block)
     end
 
-    # @return [Logger]
-    def logger
-      Ridley::Logging.logger
-    end
-    alias_method :log, :logger
-
-    # @param [Logger, nil] obj
-    #
-    # @return [Logger]
-    def set_logger(obj)
-      Ridley::Logging.set_logger(obj)
-    end
-
     # @return [Pathname]
     def root
       @root ||= Pathname.new(File.expand_path('../', File.dirname(__FILE__)))
@@ -71,6 +65,4 @@ module Ridley
   end
 end
 
-Celluloid.logger = Ridley.logger
-
 require 'ridley/middleware'

data/ridley.gemspec

@@ -7,6 +7,7 @@ Gem::Specification.new do |s|
   s.description   = %q{A reliable Chef API client with a clean syntax}
   s.summary       = s.description
   s.homepage      = "https://github.com/reset/ridley"
+  s.license       = "Apache 2.0"
 
   s.files         = `git ls-files`.split($\)
   s.executables   = Array.new

data/spec/support/actor_mocking.rb

@@ -0,0 +1,9 @@
+RSpec.configuration.before(:each) do
+  class Celluloid::ActorProxy
+    unless @rspec_compatible
+      @rspec_compatible = true
+      undef_method :should_receive
+      undef_method :stub
+    end
+  end
+end

data/spec/support/shared_examples/ridley_resource.rb

@@ -146,12 +146,12 @@ shared_examples_for "a Ridley Resource" do |resource_klass|
       end
 
       context "when there is an HTTPConflict" do
-        it "sends an update message to the implemeneting class" do
+        it "sends the update message to self" do
           updated = double('updated')
           updated.stub(:[]).and_return(Hash.new)
           updated.stub(:attributes).and_return(Hash.new)
           subject.class.should_receive(:create).and_raise(Ridley::Errors::HTTPConflict.new(updated))
-          subject.class.should_receive(:update).with(connection, subject).and_return(updated)
+          subject.should_receive(:update).and_return(updated)
 
           subject.save
         end
@@ -161,7 +161,7 @@ shared_examples_for "a Ridley Resource" do |resource_klass|
     context "when the object is invalid" do
       before(:each) { subject.stub(:valid?).and_return(false) }
 
-      it "raises an InvalidObject error" do
+      it "raises an InvalidResource error" do
         lambda {
           subject.save
         }.should raise_error(Ridley::Errors::InvalidResource)
@@ -169,6 +169,39 @@ shared_examples_for "a Ridley Resource" do |resource_klass|
     end
   end
 
+  describe "#update" do
+    context "when the object is valid" do   
+      let(:updated) do
+        updated = double('updated')
+        updated.stub(:[]).and_return(Hash.new)
+        updated.stub(:attributes).and_return(Hash.new)
+        updated
+      end
+
+      before(:each) { subject.stub(:valid?).and_return(true) }
+
+      it "sends an update message to the implementing class" do
+        subject.class.should_receive(:update).with(anything, subject).and_return(updated)
+        subject.update
+      end
+
+      it "returns true" do
+        subject.class.should_receive(:update).with(anything, subject).and_return(updated)
+        subject.update.should eql(true)
+      end
+    end
+
+    context "when the object is invalid" do
+      before(:each) { subject.stub(:valid?).and_return(false) }
+
+      it "raises an InvalidResource error" do
+        lambda {
+          subject.update
+        }.should raise_error(Ridley::Errors::InvalidResource)
+      end
+    end
+  end
+
   describe "#chef_id" do
     it "returns the value of the chef_id attribute" do
       subject.class.attribute(:name)

data/spec/unit/ridley/connection_spec.rb

@@ -17,6 +17,10 @@ describe Ridley::Connection do
     }
   end
 
+  it "exposes its options publicly" do
+    described_class::OPTIONS.should be_a Array
+  end
+
   describe "ClassMethods" do
     subject { Ridley::Connection }
 

data/spec/unit/ridley/resources/node_spec.rb

@@ -35,6 +35,17 @@ describe Ridley::Node do
         subject.bootstrap(connection, "33.33.33.10", "33.33.33.11", boot_options)
       end
     end
+
+    describe "::merge_data" do
+      it "finds the target node and sends it the merge_data message" do
+        data = double('data')
+        node = double('node')
+        node.should_receive(:merge_data).with(data)
+        subject.should_receive(:find!).and_return(node)
+
+        subject.merge_data(connection, node, data)
+      end
+    end
   end
 
   subject { Ridley::Node.new(connection) }
@@ -285,4 +296,50 @@ describe Ridley::Node do
   describe "#chef_client" do
     pending
   end
+
+  describe "#put_secret" do
+    pending
+  end
+
+  describe "#merge_data" do
+    before(:each) do
+      subject.name = "reset.riotgames.com"
+      subject.should_receive(:update)
+    end
+
+    it "appends items to the run_list" do
+      subject.merge_data(run_list: ["cook::one", "cook::two"])
+
+      subject.run_list.should =~ ["cook::one", "cook::two"]
+    end
+
+    it "ensures the run_list is unique if identical items are given" do
+      subject.run_list = [ "cook::one" ]
+      subject.merge_data(run_list: ["cook::one", "cook::two"])
+
+      subject.run_list.should =~ ["cook::one", "cook::two"]
+    end
+
+    it "deep merges attributes into the normal attributes" do
+      subject.normal = {
+        one: {
+          two: {
+            four: :deep
+          }
+        }
+      }
+      subject.merge_data(attributes: {
+        one: {
+          two: {
+            three: :deep
+          }
+        }
+      })
+
+      subject.normal[:one][:two].should have_key(:four)
+      subject.normal[:one][:two][:four].should eql(:deep)
+      subject.normal[:one][:two].should have_key(:three)
+      subject.normal[:one][:two][:three].should eql(:deep)
+    end
+  end
 end

data/spec/unit/ridley/ssh/response_set_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+describe Ridley::SSH::ResponseSet do
+  describe "ClassMethods" do
+    subject { described_class }
+
+    describe "::merge!" do
+      let(:target) { Ridley::SSH::ResponseSet.new }
+      let(:other) { Ridley::SSH::ResponseSet.new }
+
+      before(:each) do
+        other.add_response(Ridley::SSH::Response.new('host.local'))
+      end
+
+      it "returns the mutated target" do
+        result = subject.merge!(target, other)
+
+        result.should eql(target)
+        result.should have(1).item
+      end
+    end
+  end
+
+  subject { described_class.new }
+
+  describe "#add_response" do
+    it "accepts an array of responses" do
+      responses = [
+        Ridley::SSH::Response.new("one.riotgames.com"),
+        Ridley::SSH::Response.new("two.riotgames.com")
+      ]
+      subject.add_response(responses)
+
+      subject.responses.should have(2).items
+    end
+
+    it "accepts a single response" do
+      response = Ridley::SSH::Response.new("one.riotgames.com")
+      subject.add_response(response)
+
+      subject.responses.should have(1).item
+    end
+  end
+
+  describe "#responses" do
+    it "returns an array of Ridley::SSH::Response objects including both failures and successes" do
+      responses = [
+        double('success', error?: false),
+        double('failure', error?: true)
+      ]
+      subject.add_response(responses)
+
+      subject.responses.should have(2).items
+    end
+  end
+
+  describe "#successes" do
+    it "returns an array of Ridley::SSH::Response objects only including the successes" do
+      responses = [
+        double('success', error?: false),
+        double('failure', error?: true)
+      ]
+      subject.add_response(responses)
+
+      subject.successes.should have(1).item
+    end
+  end
+
+  describe "#failures" do
+    it "returns an array of Ridley::SSH::Response objects only including the failures" do
+      responses = [
+        double('success', error?: false),
+        double('failure', error?: true)
+      ]
+      subject.add_response(responses)
+
+      subject.failures.should have(1).item
+    end
+  end
+
+  describe "#merge" do
+    let(:target) { Ridley::SSH::ResponseSet.new }
+    let(:other) { Ridley::SSH::ResponseSet.new }
+
+    before(:each) do
+      other.add_response(Ridley::SSH::Response.new('host.local'))
+    end
+
+    it "returns a new Ridley::SSH::ResponseSet object" do
+      result = target.merge(other)
+
+      result.should have(1).item
+      target.should have(0).items
+    end
+  end
+
+  describe "#merge!" do
+    let(:target) { Ridley::SSH::ResponseSet.new }
+    let(:other) { Ridley::SSH::ResponseSet.new }
+
+    before(:each) do
+      other.add_response(Ridley::SSH::Response.new('host.local'))
+    end
+
+    it "returns the mutated target" do
+      result = target.merge!(other)
+
+      result.should have(1).item
+      target.should have(1).item
+    end
+  end
+end

data/spec/unit/ridley/ssh/worker_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Ridley::SSH::Worker do
+  describe "ClassMethods" do
+    subject { described_class }
+
+    describe "::new" do
+      it { subject.new(sudo: true).sudo.should be_true }
+      it { subject.new(sudo: false).sudo.should be_false }
+      it { subject.new().sudo.should be_false }
+    end
+  end
+end

data/spec/unit/ridley/ssh_spec.rb

@@ -15,17 +15,34 @@ describe Ridley::SSH do
     subject { Ridley::SSH }
     
     describe "::start" do
-      pending
+      let(:options) do
+        {
+          user: "vagrant",
+          password: "vagrant"
+        }
+      end
+
+      it "evaluates within the context of a new SSH and returns the last item in the block" do
+        result = subject.start([node_one, node_two], options) do |ssh|
+          ssh.run("ls")
+        end
+
+        result.should be_a(Ridley::SSH::ResponseSet)
+      end
+
+      it "raises a LocalJumpError if a block is not provided" do        
+        expect {
+          subject.start([node_one, node_two], options)
+        }.to raise_error(LocalJumpError)
+      end
     end
   end
 
   subject { Ridley::SSH.new([node_one, node_two], user: "vagrant", password: "vagrant") }
 
-  describe "#workers" do
-    pending
-  end
-
   describe "#run" do
-    pending
+    it "returns an SSH::ResponseSet" do
+      subject.run("ls").should be_a(Ridley::SSH::ResponseSet)
+    end
   end
 end