ridley 0.10.0.rc1 → 0.10.0.rc2

data/lib/ridley/resources/environment_resource.rb

@@ -40,7 +40,7 @@ module Ridley
     # @example setting and saving an environment level default attribute
     #
     #   obj = environment.find("production")
-    #   obj.set_defualt_attribute("my_app.billing.enabled", false)
+    #   obj.set_default_attribute("my_app.billing.enabled", false)
     #   obj.save
     #
     # @param [String] key

data/lib/ridley/resources/node_resource.rb

@@ -1,4 +1,4 @@
-module Ridley 
+module Ridley
   # @author Jamie Winsor <reset@riotgames.com>
   class NodeResource < Ridley::Resource
     class << self
@@ -54,6 +54,65 @@ module Ridley
         Bootstrapper.new(args, options).run
       end
 
+      # Executes a Chef run using the best worker available for the given
+      # host.
+      #
+      # @param [Ridley::Client] client
+      # @param [String] host
+      #
+      # @return [HostConnector::Response]
+      def chef_run(client, host)
+        worker = configured_worker_for(client, host)
+        worker.chef_client
+      ensure
+        worker.terminate if worker && worker.alive?
+      end
+
+      # Puts a secret on the host using the best worker available for
+      # the given host.
+      #
+      # @param [Ridley::Client] client
+      # @param [String] host
+      # @param [String] encrypted_data_bag_secret_path
+      # 
+      # @return [HostConnector::Response]
+      def put_secret(client, host, encrypted_data_bag_secret_path)
+        worker = configured_worker_for(client, host)
+        worker.put_secret(encrypted_data_bag_secret_path)
+      ensure
+        worker.terminate if worker && worker.alive?
+      end
+
+      # Executes an arbitrary ruby script using the best worker available
+      # for the given host.
+      #
+      # @param [Ridley::Client] client
+      # @param [String] host
+      # @param [Array<String>] command_lines
+      #
+      # @return [HostConnector::Response]
+      def ruby_script(client, host, command_lines)
+        worker = configured_worker_for(client, host)
+        worker.ruby_script(command_lines)
+      ensure
+        worker.terminate if worker && worker.alive?
+      end
+
+      # Executes the given command on a node using the best worker
+      # available for the given host.
+      #
+      # @param [Ridley::Client] client
+      # @param [String] host
+      # @param [String] command
+      #
+      # @return [Array<Symbol, HostConnector::Response>]
+      def execute_command(client, host, command)
+        worker = configured_worker_for(client, host)
+        worker.run(command)
+      ensure
+        worker.terminate if worker && worker.alive?
+      end
+
       # Merges the given data with the the data of the target node on the remote
       #
       # @param [Ridley::Client] client
@@ -72,8 +131,25 @@ module Ridley
       def merge_data(client, target, options = {})
         find!(client, target).merge_data(options)
       end
+
+      private
+        # @param [Ridley::Client] client
+        # @param [String] host
+        #
+        # @return [SSH::Worker, WinRM::Worker]
+        def configured_worker_for(client, host)
+          connector_options = Hash.new
+          connector_options[:ssh] = client.ssh
+          connector_options[:winrm] = client.winrm
+
+          HostConnector.best_connector_for(host, connector_options) do |host_connector|
+            host_connector::Worker.new(host, connector_options)
+          end
+        end
     end
 
+    include Ridley::Logging
+
     set_chef_id "name"
     set_chef_type "node"
     set_chef_json_class "Chef::Node"
@@ -114,8 +190,8 @@ module Ridley
     # attribute and value.
     #
     # @note It is not possible to set any other attribute level on a node and have it persist after
-    #   a Chef Run. This is because all other attribute levels are truncated at the start of a Chef Run. 
-    # 
+    #   a Chef Run. This is because all other attribute levels are truncated at the start of a Chef Run.
+    #
     # @example setting and saving a node level normal attribute
     #
     #   obj = node.find("jwinsor-1")
@@ -165,7 +241,7 @@ module Ridley
     #
     # @return [nil, String]
     def cloud_provider
-      self.cloud? ? self.automatic[:cloud][:provider] : nil      
+      self.cloud? ? self.automatic[:cloud][:provider] : nil
     end
 
     # Returns true if the node is identified as a cloud node.
@@ -196,18 +272,25 @@ module Ridley
       self.cloud_provider == "rackspace"
     end
 
-    # Run Chef-Client on the instantiated node
+    # Run Chef-Client on the instantiated node.
     #
     # @param [Hash] options
-    #   a hash of options to pass to {Ridley::SSH.start}
+    #   a hash of options to pass to the best {Ridley::HostConnector}
     #
-    # @return [SSH::Response]
+    # @return [HostConnector::Response]
     def chef_client(options = {})
-      options = client.ssh.merge(options)
+      connector_options = Hash.new
+      connector_options[:ssh] = client.ssh
+      connector_options[:winrm] = client.winrm
+      connector_options.merge(options)
+
+      log.debug "Running Chef Client on: #{self.public_hostname}"
 
-      Ridley.log.debug "Running Chef Client on: #{self.public_hostname}"
-      Ridley::SSH.start(self, options) do |ssh|
-        ssh.run("sudo chef-client").first
+      HostConnector.best_connector_for(self.public_hostname, connector_options) do |host_connector|
+        host_connector.start(self, connector_options) do |connector|
+          _, response = connector.chef_client
+          response
+        end
       end
     end
 
@@ -216,9 +299,9 @@ module Ridley
     # returned
     #
     # @param [Hash] options
-    #   a hash of options to pass to {Ridley::SSH.start}
+    #   a hash of options to pass to the best {Ridley::HostConnector}
     #
-    # @return [SSH::Response, nil]
+    # @return [HostConnector::Response, nil]
     def put_secret(options = {})
       if client.encrypted_data_bag_secret_path.nil? ||
         !File.exists?(client.encrypted_data_bag_secret_path)
@@ -226,13 +309,17 @@ module Ridley
         return nil
       end
 
-      options = client.ssh.merge(options)
-      secret  = File.read(client.encrypted_data_bag_secret_path).chomp
-      command = "echo '#{secret}' > /etc/chef/encrypted_data_bag_secret; chmod 0600 /etc/chef/encrypted_data_bag_secret"
+      connector_options = Hash.new
+      connector_options[:ssh] = client.ssh
+      connector_options[:winrm] = client.winrm
+
+      log.debug "Writing Encrypted Data Bag Secret to: #{self.public_hostname}"
 
-      Ridley.log.debug "Writing Encrypted Data Bag Secret to: #{self.public_hostname}"
-      Ridley::SSH.start(self, options) do |ssh|
-        ssh.run(command).first
+      HostConnector.best_connector_for(self.public_hostname, connector_options) do |host_connector|
+        host_connector.start(self, connector_options) do |connector|
+          _, response = connector.put_secret(client.encrypted_data_bag_secret_path)
+          response
+        end
       end
     end
 

data/lib/ridley/version.rb

@@ -1,3 +1,3 @@
 module Ridley
-  VERSION = "0.10.0.rc1"
+  VERSION = "0.10.0.rc2"
 end

data/spec/unit/ridley/bootstrap_bindings/windows_template_binding_spec.rb

@@ -104,12 +104,6 @@ describe Ridley::WindowsTemplateBinding do
     end
   end
 
-  describe "#windows_wget_vb" do
-    it "returns a string" do
-      subject.windows_wget_vb.should be_a(String)
-    end
-  end
-
   describe "#windows_wget_powershell" do
     it "returns a string" do
       subject.windows_wget_powershell.should be_a(String)

data/spec/unit/ridley/bootstrapper_spec.rb

@@ -64,9 +64,29 @@ describe Ridley::Bootstrapper do
   end
 
   describe "#contexts" do
-    it "returns an array of Bootstrapper::Contexts" do
-      subject.contexts.should be_a(Array)
-      subject.contexts.should each be_a(Ridley::Bootstrapper::Context)
+    before do
+      Ridley::Bootstrapper::Context.stub(:create).and_return(double)
+    end
+
+    it "creates a new context for each host" do
+      Ridley::Bootstrapper::Context.should_receive(:create).exactly(nodes.length).times
+      subject.contexts
+    end
+
+    it "contains a item for each host" do
+      subject.contexts.should have(nodes.length).items
+    end
+
+    context "when a host is unreachable" do
+      before do
+        Ridley::Bootstrapper::Context.stub(:create).and_raise(Ridley::Errors::HostConnectionError)
+      end
+
+      it "raises a HostConnectionError" do
+        expect {
+          subject.contexts
+        }.to raise_error(Ridley::Errors::HostConnectionError)
+      end
     end
   end
 

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

@@ -1,15 +1,57 @@
 require 'spec_helper'
 
 describe Ridley::HostConnector::SSH::Worker do
-  describe "ClassMethods" do
-    let(:host) { 'reset.riotgames.com' }
+  subject { ssh_worker }
+  let(:ssh_worker) { described_class.new(host, options) }
+
+  let(:host) { 'reset.riotgames.com' }
+  let(:options) { {} }
+  
+  describe "#sudo" do
+    subject { ssh_worker.sudo }
+
+    it { should be_false }
+
+    context "with sudo" do
+      let(:options) { { ssh: { sudo: true } } }
+      
+      it { should be_true }
+    end
+  end
+
+  describe "#chef_client" do
+    subject(:chef_client) { ssh_worker.chef_client }
+
+    it { should be_a(Array) }
+
+    context "with sudo" do
+      let(:options) { { ssh: { sudo: true } } }
+
+      it "sends a run command with sudo" do
+        ssh_worker.should_receive(:run).with("sudo chef-client")
+        chef_client
+      end
+    end
+  end
+
+  describe "#put_secret" do
+    subject(:put_secret) { ssh_worker.put_secret(encrypted_data_bag_secret_path) }
+    let(:encrypted_data_bag_secret_path) { fixtures_path.join("encrypted_data_bag_secret").to_s }
+    let(:secret) { File.read(encrypted_data_bag_secret_path).chomp }
     
-    subject { described_class }
+    it "receives a run command with echo" do
+      ssh_worker.should_receive(:run).with("echo '#{secret}' > /etc/chef/encrypted_data_bag_secret; chmod 0600 /etc/chef/encrypted_data_bag_secret")
+      put_secret
+    end
+  end
+
+  describe "#ruby_script" do
+    subject(:ruby_script) { ssh_worker.ruby_script(command_lines) }
+    let(:command_lines) { ["puts 'hello'", "puts 'there'"] }
 
-    describe "::new" do
-      it { subject.new(host, ssh: {sudo: true}).sudo.should be_true }
-      it { subject.new(host, ssh: {sudo: false}).sudo.should be_false }
-      it { subject.new(host).sudo.should be_false }
+    it "receives a ruby call with the command" do
+      ssh_worker.should_receive(:run).with("#{described_class::EMBEDDED_RUBY_PATH} -e \"puts 'hello';puts 'there'\"")
+      ruby_script
     end
   end
 end

data/spec/unit/ridley/host_connector/ssh_spec.rb

@@ -18,7 +18,8 @@ describe Ridley::HostConnector::SSH do
       let(:options) do
         {
           user: "vagrant",
-          password: "vagrant"
+          password: "vagrant",
+          timeout: 1
         }
       end
 
@@ -38,10 +39,10 @@ describe Ridley::HostConnector::SSH do
     end
   end
 
-  subject { Ridley::HostConnector::SSH.new([node_one, node_two], user: "vagrant", password: "vagrant") }
+  subject { Ridley::HostConnector::SSH.new([node_one, node_two], ssh: {user: "vagrant", password: "vagrant", timeout: 1}) }
 
   describe "#run" do
-    it "returns an SSH::ResponseSet" do
+    it "returns an HostConnector::ResponseSet" do
       subject.run("ls").should be_a(Ridley::HostConnector::ResponseSet)
     end
   end

data/spec/unit/ridley/host_connector/winrm/command_uploader_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Ridley::HostConnector::WinRM::CommandUploader do
+  let(:winrm_stub) {
+    double('WinRM',
+      run_cmd: run_cmd_data,
+      powershell: nil
+    )
+  }
+
+  subject { command_uploader }
+
+  let(:command_uploader) { described_class.new(winrm_stub) }
+  let(:command_string) { "a" * 2048 }
+  let(:run_cmd_data) { { data: [{ stdout: "abc123" }] } }
+  let(:command_file_name) { "my_command.bat" }
+
+  its(:winrm) { should eq(winrm_stub) }
+
+  before do
+    command_uploader.stub(:get_file_path).and_return("")
+  end
+
+  describe "#upload" do
+    let(:upload) { command_uploader.upload(command_string) }
+
+    it "calls winrm to upload and convert the command" do
+      winrm_stub.should_receive(:run_cmd).and_return(
+        run_cmd_data,
+        nil,
+        run_cmd_data
+      )
+      winrm_stub.should_receive(:powershell)
+
+      upload
+    end
+  end
+
+  describe "#command" do
+    subject { command }
+    let(:command) { command_uploader.command }
+
+    before do
+      command_uploader.stub command_file_name: command_file_name
+    end
+
+    it { should eq("cmd.exe /C #{command_file_name}") }
+  end
+
+  describe "#cleanup" do
+    subject { cleanup }
+
+    let(:cleanup) { command_uploader.cleanup }
+    let(:base64_file_name) { "my_base64_file" }
+
+    before do
+      command_uploader.stub command_file_name: command_file_name
+      command_uploader.stub base64_file_name: base64_file_name
+    end
+
+    it "cleans up the windows temp dir" do
+      winrm_stub.should_receive(:run_cmd).with("del #{base64_file_name} /F /Q")
+      winrm_stub.should_receive(:run_cmd).with("del #{command_file_name} /F /Q")
+      cleanup
+    end
+  end
+end

data/spec/unit/ridley/host_connector/winrm/worker_spec.rb

@@ -1,41 +1,87 @@
 require 'spec_helper'
 
 describe Ridley::HostConnector::WinRM::Worker do
+  subject { winrm_worker }
+  let(:winrm_worker) { described_class.new(host, options) }
   let(:host) { 'reset.riotgames.com' }  
-  
-  let(:options) do
-    {
-      winrm: {
-        port: 1234
-      }
-    }
-  end
+  let(:options) { {} }
 
-  subject { Ridley::HostConnector::WinRM::Worker.new(host, options) }
+  before do
+    Ridley::HostConnector::WinRM::CommandUploader.stub(:new).and_return(double('command_uploader'))
+  end
 
   describe "#winrm_port" do
-    it "can be overridden if options contains :winrm_port" do
-      subject.winrm_port.should eq(1234)
-    end
+    subject(:winrm_port) { winrm_worker.winrm_port }
+
+    it { should eq(Ridley::HostConnector::DEFAULT_WINRM_PORT) }
 
-    it "defaults to Ridley::HostConnector::DEFAULT_WINRM_PORT when not overridden" do
-      options.delete(:winrm)
-      subject.winrm_port.should eq(Ridley::HostConnector::DEFAULT_WINRM_PORT)
+    context "when overridden" do
+      let(:options) { { winrm: { port: 1234 } } }
+
+      it { should eq(1234) }
     end
   end
 
   describe "#winrm" do
-    it "returns a WinRM::WinRMWebService" do
-      subject.winrm.should be_a(WinRM::WinRMWebService)
-    end
+    subject { winrm_worker.winrm }
+
+    it { should be_a(WinRM::WinRMWebService) }
   end
 
   describe "#get_command" do
+    subject(:get_command) { winrm_worker.get_command(command, command_uploader_stub) }
+
     let(:command) { "echo %TEMP%" }
-    context "when a command is less than 2047 characters" do
-      it "returns the command" do
-        subject.get_command(command).should eq(command)
+    let(:command_uploader_stub) { double('CommandUploader') }
+
+    it { should eq(command) }
+    
+    context "when a command is more than 2047 characters" do
+      let(:command) { "a" * 2048 }
+
+      it "uploads and returns a command" do
+        Ridley::HostConnector::WinRM::CommandUploader.stub new: command_uploader_stub
+
+        command_uploader_stub.should_receive :upload
+        command_uploader_stub.stub command: "my command"
+        command_uploader_stub.stub(:cleanup)
+
+        get_command.should eq("my command")
       end
     end
   end
+
+  describe "#chef_client" do
+    subject(:chef_client) { winrm_worker.chef_client }
+
+    it "receives a command to run chef-client" do
+      winrm_worker.should_receive(:run).with("chef-client")
+
+      chef_client
+    end
+  end
+
+  describe "#put_secret" do
+    subject(:put_secret) { winrm_worker.put_secret(encrypted_data_bag_secret_path) }
+
+    let(:encrypted_data_bag_secret_path) { fixtures_path.join("encrypted_data_bag_secret").to_s }
+    let(:secret) { File.read(encrypted_data_bag_secret_path).chomp }
+
+    it "receives a command to copy the secret" do
+      winrm_worker.should_receive(:run).with("echo #{secret} > C:\\chef\\encrypted_data_bag_secret")
+
+      put_secret
+    end
+  end
+
+  describe "#ruby_script" do
+    subject(:ruby_script) { winrm_worker.ruby_script(command_lines) }
+    let(:command_lines) { ["puts 'hello'", "puts 'there'"] }
+
+    it "receives a ruby call with the command" do
+      winrm_worker.should_receive(:run).with("#{described_class::EMBEDDED_RUBY_PATH} -e \"puts 'hello';puts 'there'\"")
+
+      ruby_script
+    end
+  end
 end