ridley 0.12.4 → 1.0.0.rc1

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

@@ -1,159 +0,0 @@
-module Ridley
-  module HostConnector
-    class WinRM
-      # @author Kyle Allan <kallan@riotgames.com>
-      # @api private
-      class Worker
-        include Celluloid
-        include Celluloid::Logger
-
-        # @return [String]
-        attr_reader :user
-        # @return [String]
-        attr_reader :password
-        # @return [String]
-        attr_reader :host
-        # @return [Hash]
-        attr_reader :options
-        # @return [String]
-        attr_reader :winrm_endpoint
-        # @return [CommandUploader]
-        attr_reader :command_uploader
-        # @return [Array]
-        attr_reader :command_uploaders
-
-        finalizer :finalize_callback
-
-        EMBEDDED_RUBY_PATH = 'C:\opscode\chef\embedded\bin\ruby'.freeze
-
-        # @param  host [String]
-        #   the host the worker is going to work on
-        # @option options [Hash] :winrm
-        #   * :user (String) a user that will login to each node and perform the bootstrap command on (required)
-        #   * :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 (5985)
-        def initialize(host, options = {})
-          options            = options.deep_symbolize_keys
-          @options           = options[:winrm] || Hash.new
-          @host              = host
-          @user              = @options[:user]
-          @password          = @options[:password]
-          @winrm_endpoint    = "http://#{host}:#{winrm_port}/wsman"
-          @command_uploaders = Array.new
-        end
-
-        def run(command)
-          response = Ridley::HostConnector::Response.new(host)
-          command_uploaders << command_uploader = CommandUploader.new(winrm)
-          command = get_command(command, command_uploader)
-
-          debug "Running WinRM Command: '#{command}' on: '#{host}' as: '#{user}'"
-
-          output = winrm.run_cmd(command) do |stdout, stderr|
-            if stdout
-              response.stdout += stdout
-              info "NODE[#{host}] #{stdout}"
-            end
-
-            if stderr
-              response.stderr += stderr unless stderr.nil?
-              info "NODE[#{host}] #{stdout}"
-            end
-          end
-
-          response.exit_code = output[:exitcode]
-
-          case response.exit_code
-          when 0
-            debug "Successfully ran WinRM command on: '#{host}' as: '#{user}'"
-            [ :ok, response ]
-          else
-            error "Successfully ran WinRM command on: '#{host}' as: '#{user}', but it failed"
-            error response.stdout
-            [ :error, response ]
-          end
-        rescue => e
-          error "Failed to run WinRM command on: '#{host}' as: '#{user}'"
-          error "#{e.class}: #{e.message}"
-          response.exit_code = -1
-          response.stderr = e.message
-          [ :error, response ]
-        end
-
-        # @return [WinRM::WinRMWebService]
-        def winrm
-          @winrm_client ||= begin
-            require 'active_support/core_ext/kernel/reporting'
-            # Silencing warnings because not all versions of GSSAPI support all of the GSSAPI methods
-            # the gssapi gem attempts to attach to and these warnings are dumped to STDERR.
-            silence_warnings do
-              require 'winrm'
-            end
-
-            client = ::WinRM::WinRMWebService.new(winrm_endpoint, :plaintext,
-              user: user, pass: password, disable_sspi: true, basic_auth_only: true)
-            client.set_timeout(6000)
-            client
-          end
-        end
-
-        # @return [Fixnum]
-        def winrm_port
-          options[:port] || Ridley::HostConnector::DEFAULT_WINRM_PORT
-        end
-
-        # Returns the command if it does not break the WinRM command length
-        # limit. Otherwise, we return an execution of the command as a batch file.
-        #
-        # @param  command [String]
-        #
-        # @return [String]
-        def get_command(command, command_uploader)
-          if command.length < CommandUploader::CHUNK_LIMIT
-            command
-          else
-            debug "Detected a command that was longer than #{CommandUploader::CHUNK_LIMIT} characters, \
-              uploading command as a file to the host."
-            command_uploader.upload(command)
-            command_uploader.command
-          end
-        end
-
-        # Executes a chef-client run on the nodes
-        #
-        # @return [#run]
-        def chef_client
-          run("chef-client")
-        end
-
-        # Writes the given encrypted data bag secret to the node
-        #
-        # @param [String] secret
-        #   your organization's encrypted data bag secret
-        #
-        # @return [#run]
-        def put_secret(secret)
-          command = "echo #{secret} > C:\\chef\\encrypted_data_bag_secret"
-          run(command)
-        end
-
-        # Executes a provided Ruby script in the embedded Ruby installation
-        #
-        # @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(';')}\""
-          run(command)
-        end
-
-        private
-
-          def finalize_callback
-            command_uploaders.map(&:cleanup)
-          end
-      end
-    end
-  end
-end

data/lib/ridley/log.rb

@@ -1,10 +0,0 @@
-require 'mixlib/log'
-
-module Ridley
-  # @author Jamie Winsor <reset@riotgames.com>
-  class Log
-    extend Mixlib::Log
-
-    init
-  end
-end

data/lib/ridley/mixin/bootstrap_binding.rb

@@ -1,77 +0,0 @@
-require 'erubis'
-
-module Ridley
-  module BootstrapBinding
-    module ClassMethods
-      def validate_options(options = {})
-        if options[:server_url].nil?
-          raise Errors::ArgumentError, "A server_url is required for bootstrapping"
-        end
-
-        if options[:validator_path].nil?
-          raise Errors::ArgumentError, "A path to a validator is required for bootstrapping"
-        end
-      end
-
-      # A hash of default options to be used in the Context initializer
-      #
-      # @return [Hash]
-      def default_options
-        @default_options ||= {
-          validator_client: "chef-validator",
-          attributes: Hash.new,
-          run_list: Array.new,
-          environment: "_default",
-          sudo: true,
-          hints: Hash.new
-        }
-      end
-    end
-
-    class << self
-      def included(base)
-        base.extend(ClassMethods)
-      end
-    end
-
-    attr_reader :template_file
-    attr_reader :bootstrap_proxy
-    attr_reader :chef_version
-    attr_reader :default_options
-    attr_reader :validator_path
-    attr_reader :encrypted_data_bag_secret
-    attr_reader :server_url
-    attr_reader :validator_client
-    attr_reader :node_name
-    attr_reader :attributes
-    attr_reader :run_list
-    attr_reader :environment
-
-    # @return [Pathname]
-    def templates_path
-      Ridley.root.join('bootstrappers')
-    end
-
-    # @return [String]
-    def first_boot
-      JSON.fast_generate(attributes.merge(run_list: run_list))
-    end
-
-    # The validation key to create a new client for the node
-    #
-    # @raise [Ridley::Errors::ValidatorNotFound]
-    #
-    # @return [String]
-    def validation_key
-      IO.read(File.expand_path(validator_path)).chomp
-    rescue Errno::ENOENT
-      raise Errors::ValidatorNotFound, "Error bootstrapping: Validator not found at '#{validator_path}'"
-    end
-
-    # @return [Erubis::Eruby]
-    def template
-      Erubis::Eruby.new(IO.read(template_file).chomp)
-    end
-
-  end
-end

data/spec/unit/ridley/bootstrapper/context_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-describe Ridley::Bootstrapper::Context do
-  let(:host) { "reset.riotgames.com" }
-
-  let(:options) do
-    {
-      server_url: "https://api.opscode.com/organizations/vialstudios",
-      validator_client: "chef-validator",
-      validator_path: fixtures_path.join("reset.pem").to_s,
-      encrypted_data_bag_secret: File.read(fixtures_path.join("reset.pem"))
-    }
-  end
-
-  describe "ClassMethods" do
-    subject { Ridley::Bootstrapper::Context }
-
-    describe "::create" do
-      context "when the best connection is SSH" do
-        it "sets template_binding to a Ridley::UnixTemplateBinding" do
-          Ridley::HostConnector.stub(:best_connector_for).and_return(Ridley::HostConnector::SSH)
-          context = subject.create(host, options)
-          context.template_binding.should be_a(Ridley::UnixTemplateBinding)
-        end
-      end
-
-      context "when the best connection is WinRM" do
-        it "sets template_binding to a Ridley::WindowsTemplateBinding" do
-          Ridley::HostConnector.stub(:best_connector_for).and_return(Ridley::HostConnector::WinRM)
-          context = subject.create(host, options)
-          context.template_binding.should be_a(Ridley::WindowsTemplateBinding)
-        end
-      end
-
-      context "when there is no good connection option" do
-        it "raises an error" do
-          Ridley::HostConnector.stub(:best_connector_for).and_return(nil)
-          expect {
-            context = subject.create(host, options)
-          }.to raise_error(Ridley::Errors::HostConnectionError)
-        end
-      end
-    end
-  end
-end

data/spec/unit/ridley/bootstrapper_spec.rb

@@ -1,96 +0,0 @@
-require 'spec_helper'
-
-describe Ridley::Bootstrapper do
-  let(:nodes) do
-    [
-      "33.33.33.10"
-    ]
-  end
-
-  let(:options) do
-    {
-      ssh_user: "vagrant",
-      ssh_password: "vagrant",
-      server_url: "https://api.opscode.com/organizations/vialstudios",
-      validator_client: "vialstudios-validator",
-      validator_path: fixtures_path.join("reset.pem").to_s,
-      encrypted_data_bag_secret: File.read(fixtures_path.join("reset.pem"))
-    }
-  end
-
-  before(:each) { Ridley::HostConnector.stub(:best_connector_for).and_return(Ridley::HostConnector::SSH) }
-
-  describe "ClassMethods" do
-    subject { Ridley::Bootstrapper }
-
-    describe "::new" do
-      context "given a single string for nodes" do
-        before(:each) do
-          @obj = subject.new("33.33.33.10", options)
-        end
-
-        it "has one node" do
-          @obj.hosts.should have(1).item
-        end
-
-        it "has one context" do
-          @obj.contexts.should have(1).item
-        end
-      end
-
-      context "given an an array of strings nodes" do
-        before(:each) do
-          @obj = subject.new(["33.33.33.10", "33.33.33.11"], options)
-        end
-
-        it "has a host for each item given" do
-          @obj.hosts.should have(2).items
-        end
-
-        it "has a context for each item given" do
-          @obj.contexts.should have(2).items
-        end
-      end
-    end
-  end
-
-  subject { Ridley::Bootstrapper.new(nodes, options) }
-
-  describe "#hosts" do
-    it "returns an array of strings" do
-      subject.hosts.should be_a(Array)
-      subject.hosts.should each be_a(String)
-    end
-  end
-
-  describe "#contexts" do
-    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
-
-  describe "#run" do
-    pending
-  end
-end

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

@@ -1,112 +0,0 @@
-require 'spec_helper'
-
-describe Ridley::HostConnector::ResponseSet do
-  describe "ClassMethods" do
-    subject { described_class }
-
-    describe "::merge!" do
-      let(:target) { Ridley::HostConnector::ResponseSet.new }
-      let(:other) { Ridley::HostConnector::ResponseSet.new }
-
-      before(:each) do
-        other.add_response(Ridley::HostConnector::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::HostConnector::Response.new("one.riotgames.com"),
-        Ridley::HostConnector::Response.new("two.riotgames.com")
-      ]
-      subject.add_response(responses)
-
-      subject.responses.should have(2).items
-    end
-
-    it "accepts a single response" do
-      response = Ridley::HostConnector::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::HostConnector::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::HostConnector::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::HostConnector::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::HostConnector::ResponseSet.new }
-    let(:other) { Ridley::HostConnector::ResponseSet.new }
-
-    before(:each) do
-      other.add_response(Ridley::HostConnector::Response.new('host.local'))
-    end
-
-    it "returns a new Ridley::HostConnector::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::HostConnector::ResponseSet.new }
-    let(:other) { Ridley::HostConnector::ResponseSet.new }
-
-    before(:each) do
-      other.add_response(Ridley::HostConnector::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