test-kitchen 0.7.0 → 1.0.0.alpha.0

data/lib/kitchen/driver/ssh_base.rb

@@ -0,0 +1,192 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
+#
+# Copyright (C) 2012, Fletcher Nichol
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'net/ssh'
+require 'socket'
+
+module Kitchen
+
+  module Driver
+
+    # Base class for a driver that uses SSH to communication with an instance.
+    # A subclass must implement the following methods:
+    # * #create(state)
+    # * #destroy(state)
+    #
+    # @author Fletcher Nichol <fnichol@nichol.ca>
+    class SSHBase < Base
+
+      def create(state)
+        raise ClientError, "#{self.class}#create must be implemented"
+      end
+
+      def converge(state)
+        ssh_args = build_ssh_args(state)
+
+        install_omnibus(ssh_args) if config[:require_chef_omnibus]
+        prepare_chef_home(ssh_args)
+        upload_chef_data(ssh_args)
+        run_chef_solo(ssh_args)
+      end
+
+      def setup(state)
+        ssh_args = build_ssh_args(state)
+
+        if kb_setup_cmd
+          ssh(ssh_args, kb_setup_cmd)
+        end
+      end
+
+      def verify(state)
+        ssh_args = build_ssh_args(state)
+
+        if kb_run_cmd
+          ssh(ssh_args, kb_sync_cmd)
+          ssh(ssh_args, kb_run_cmd)
+        end
+      end
+
+      def destroy(state)
+        raise ClientError, "#{self.class}#destroy must be implemented"
+      end
+
+      def login_command(state)
+        args  = %W{ -o UserKnownHostsFile=/dev/null }
+        args += %W{ -o StrictHostKeyChecking=no }
+        args += %W{ -i #{config[:ssh_key]}} if config[:ssh_key]
+        args += %W{ #{config[:username]}@#{state[:hostname]}}
+
+        ["ssh", *args]
+      end
+
+      protected
+
+      def build_ssh_args(state)
+        opts = Hash.new
+        opts[:user_known_hosts_file] = "/dev/null"
+        opts[:paranoid] = false
+        opts[:password] = config[:password] if config[:password]
+        opts[:keys] = Array(config[:ssh_key]) if config[:ssh_key]
+
+        [state[:hostname], config[:username], opts]
+      end
+
+      def chef_home
+        "/tmp/kitchen-chef-solo".freeze
+      end
+
+      def install_omnibus(ssh_args)
+        flag = config[:require_chef_omnibus].downcase
+        version = if flag.is_a?(String) && flag != "latest"
+          "-s -- -v #{flag}"
+        else
+          ""
+        end
+
+        ssh(ssh_args, <<-INSTALL.gsub(/^ {10}/, ''))
+          should_update_chef() {
+            case "#{flag}" in
+              $(chef-solo --v | awk "{print \$2}")) return 1 ;;
+              latest|*) return 0 ;;
+            esac
+          }
+
+          if [ ! -d "/opt/chef" ] || should_update_chef ; then
+            echo "-----> Installing Chef Omnibus (#{flag})"
+            curl -sSL https://www.opscode.com/chef/install.sh \
+              | sudo bash #{version}
+          fi
+        INSTALL
+      end
+
+      def prepare_chef_home(ssh_args)
+        ssh(ssh_args, "sudo rm -rf #{chef_home} && mkdir -p #{chef_home}/cache")
+      end
+
+      def upload_chef_data(ssh_args)
+        Kitchen::ChefDataUploader.new(
+          instance, ssh_args, config[:kitchen_root], chef_home
+        ).upload
+      end
+
+      def run_chef_solo(ssh_args)
+        ssh(ssh_args, <<-RUN_SOLO)
+          sudo chef-solo -c #{chef_home}/solo.rb -j #{chef_home}/dna.json \
+            --log_level #{Util.from_logger_level(logger.level)}
+        RUN_SOLO
+      end
+
+      def ssh(ssh_args, cmd)
+        debug("[SSH] #{ssh_args[1]}@#{ssh_args[0]} (#{cmd})")
+        Net::SSH.start(*ssh_args) do |ssh|
+          exit_code = ssh_exec_with_exit!(ssh, cmd)
+
+          if exit_code != 0
+            shorter_cmd = cmd.squeeze(" ").strip
+            raise ActionFailed,
+              "SSH exited (#{exit_code}) for command: [#{shorter_cmd}]"
+          end
+        end
+      rescue Net::SSH::Exception => ex
+        raise ActionFailed, ex.message
+      end
+
+      def ssh_exec_with_exit!(ssh, cmd)
+        exit_code = nil
+        ssh.open_channel do |channel|
+
+          channel.request_pty
+
+          channel.exec(cmd) do |ch, success|
+
+            channel.on_data do |ch, data|
+              logger << data
+            end
+
+            channel.on_extended_data do |ch, type, data|
+              logger << data
+            end
+
+            channel.on_request("exit-status") do |ch, data|
+              exit_code = data.read_long
+            end
+          end
+        end
+        ssh.loop
+        exit_code
+      end
+
+      def wait_for_sshd(hostname)
+        logger << "." until test_ssh(hostname)
+      end
+
+      def test_ssh(hostname)
+        socket = TCPSocket.new(hostname, config[:port])
+        IO.select([socket], nil, nil, 5)
+      rescue SocketError, Errno::ECONNREFUSED,
+        Errno::EHOSTUNREACH, Errno::ENETUNREACH, IOError
+        sleep 2
+        false
+      rescue Errno::EPERM, Errno::ETIMEDOUT
+        false
+      ensure
+        socket && socket.close
+      end
+    end
+  end
+end

data/lib/kitchen/driver.rb

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
+#
+# Copyright (C) 2012, Fletcher Nichol
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Kitchen
+
+  module Driver
+
+    # Returns an instance of a driver given a plugin type string.
+    #
+    # @param plugin [String] a driver plugin type, which will be constantized
+    # @return [Driver::Base] a driver instance
+    # @raise [ClientError] if a driver instance could not be created
+    def self.for_plugin(plugin, config)
+      require "kitchen/driver/#{plugin}"
+
+      str_const = Util.to_camel_case(plugin)
+      klass = self.const_get(str_const)
+      klass.new(config)
+    rescue UserError
+      raise
+    rescue LoadError
+      raise ClientError, "Could not require '#{plugin}' plugin from load path"
+    rescue
+      raise ClientError, "Failed to create a driver for '#{plugin}' plugin"
+    end
+  end
+end

data/lib/kitchen/errors.rb

@@ -0,0 +1,52 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
+#
+# Copyright (C) 2013, Fletcher Nichol
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Kitchen
+
+  module Error ; end
+
+  # Base exception class from which all Kitchen exceptions derive. This class
+  # nests an exception when this class is re-raised from a rescue block.
+  class StandardError < ::StandardError
+
+    include Error
+
+    attr_reader :original
+
+    def initialize(msg, original = $!)
+      super(msg)
+      @original = original
+    end
+  end
+
+  # Base exception class for all exceptions that are caused by user input
+  # errors.
+  class UserError < StandardError ; end
+
+  # Base exception class for all exceptions that are caused by incorrect use
+  # of an API.
+  class ClientError < StandardError ; end
+
+  # Base exception class for exceptions that are caused by external library
+  # failures which may be temporary.
+  class TransientFailure < StandardError ; end
+
+  # Exception class for any exceptions raised when performing an instance
+  # action.
+  class ActionFailed < TransientFailure ; end
+end

data/lib/kitchen/instance.rb

@@ -0,0 +1,327 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
+#
+# Copyright (C) 2012, Fletcher Nichol
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'benchmark'
+require 'fileutils'
+require 'thread'
+require 'vendor/hash_recursive_merge'
+
+module Kitchen
+
+  # An instance of a suite running on a platform. A created instance may be a
+  # local virtual machine, cloud instance, container, or even a bare metal
+  # server, which is determined by the platform's driver.
+  #
+  # @author Fletcher Nichol <fnichol@nichol.ca>
+  class Instance
+
+    include Logging
+
+    class << self
+      attr_accessor :mutexes
+    end
+
+    # @return [Suite] the test suite configuration
+    attr_reader :suite
+
+    # @return [Platform] the target platform configuration
+    attr_reader :platform
+
+    # @return [Driver::Base] driver object which will manage this instance's
+    #   lifecycle actions
+    attr_reader :driver
+
+    # @return [Logger] the logger for this instance
+    attr_reader :logger
+
+    # Creates a new instance, given a suite and a platform.
+    #
+    # @param [Hash] options configuration for a new suite
+    # @option options [Suite] :suite the suite
+    # @option options [Platform] :platform the platform
+    # @option options [Driver::Base] :driver the driver
+    # @option options [Logger] :logger the instance logger
+    def initialize(options = {})
+      options = { :logger => Kitchen.logger }.merge(options)
+      validate_options(options)
+      logger = options[:logger]
+
+      @suite = options[:suite]
+      @platform = options[:platform]
+      @driver = options[:driver]
+      @logger = logger.is_a?(Proc) ? logger.call(name) : logger
+
+      @driver.instance = self
+      setup_driver_mutex
+    end
+
+    # @return [String] name of this instance
+    def name
+      "#{suite.name}-#{platform.name}".gsub(/_/, '-').gsub(/\./, '')
+    end
+
+    def to_str
+      "<#{name}>"
+    end
+
+    # Returns a combined run_list starting with the platform's run_list
+    # followed by the suite's run_list.
+    #
+    # @return [Array] combined run_list from suite and platform
+    def run_list
+      Array(platform.run_list) + Array(suite.run_list)
+    end
+
+    # Returns a merged hash of Chef node attributes with values from the
+    # suite overriding values from the platform.
+    #
+    # @return [Hash] merged hash of Chef node attributes
+    def attributes
+      platform.attributes.rmerge(suite.attributes)
+    end
+
+    def dna
+      attributes.rmerge({ :run_list => run_list })
+    end
+
+    # Creates this instance.
+    #
+    # @see Driver::Base#create
+    # @return [self] this instance, used to chain actions
+    #
+    # @todo rescue Driver::ActionFailed and return some kind of null object
+    #   to gracfully stop action chaining
+    def create
+      transition_to(:create)
+    end
+
+    # Converges this running instance.
+    #
+    # @see Driver::Base#converge
+    # @return [self] this instance, used to chain actions
+    #
+    # @todo rescue Driver::ActionFailed and return some kind of null object
+    #   to gracfully stop action chaining
+    def converge
+      transition_to(:converge)
+    end
+
+    # Sets up this converged instance for suite tests.
+    #
+    # @see Driver::Base#setup
+    # @return [self] this instance, used to chain actions
+    #
+    # @todo rescue Driver::ActionFailed and return some kind of null object
+    #   to gracfully stop action chaining
+    def setup
+      transition_to(:setup)
+    end
+
+    # Verifies this set up instance by executing suite tests.
+    #
+    # @see Driver::Base#verify
+    # @return [self] this instance, used to chain actions
+    #
+    # @todo rescue Driver::ActionFailed and return some kind of null object
+    #   to gracfully stop action chaining
+    def verify
+      transition_to(:verify)
+    end
+
+    # Destroys this instance.
+    #
+    # @see Driver::Base#destroy
+    # @return [self] this instance, used to chain actions
+    #
+    # @todo rescue Driver::ActionFailed and return some kind of null object
+    #   to gracfully stop action chaining
+    def destroy
+      transition_to(:destroy)
+    end
+
+    # Tests this instance by creating, converging and verifying. If this
+    # instance is running, it will be pre-emptively destroyed to ensure a
+    # clean slate. The instance will be left post-verify in a running state.
+    #
+    # @param destroy_mode [Symbol] strategy used to cleanup after instance
+    #   has finished verifying (default: `:passing`)
+    # @return [self] this instance, used to chain actions
+    #
+    # @todo rescue Driver::ActionFailed and return some kind of null object
+    #   to gracfully stop action chaining
+    def test(destroy_mode = :passing)
+      elapsed = Benchmark.measure do
+        banner "Cleaning up any prior instances of #{to_str}"
+        destroy
+        banner "Testing #{to_str}"
+        verify
+        destroy if destroy_mode == :passing
+      end
+      info "Finished testing #{to_str} #{Util.duration(elapsed.real)}."
+      self
+    ensure
+      destroy if destroy_mode == :always
+    end
+
+    # Logs in to this instance by invoking a system command, provided by the
+    # instance's driver. This could be an SSH command, telnet, or serial
+    # console session.
+    #
+    # **Note** This method calls exec and will not return.
+    #
+    # @see Driver::Base#login_command
+    def login
+      command, *args = driver.login_command(state_file.read)
+
+      debug("Login command: #{command} #{args.join(' ')}")
+      Kernel.exec(command, *args)
+    end
+
+    def last_action
+      state_file.read[:last_action]
+    end
+
+    private
+
+    def validate_options(opts)
+      [:suite, :platform, :driver, :logger].each do |k|
+        raise ClientError, "Instance#new requires option :#{k}" if opts[k].nil?
+      end
+    end
+
+    def setup_driver_mutex
+      if driver.class.serial_actions
+        Kitchen.mutex.synchronize do
+          self.class.mutexes ||= Hash.new
+          self.class.mutexes[driver.class] = Mutex.new
+        end
+      end
+    end
+
+    def transition_to(desired)
+      result = nil
+      FSM.actions(last_action, desired).each do |transition|
+        result = send("#{transition}_action")
+      end
+      result
+    end
+
+    def create_action
+      perform_action(:create, "Creating")
+    end
+
+    def converge_action
+      perform_action(:converge, "Converging")
+    end
+
+    def setup_action
+      perform_action(:setup, "Setting up")
+    end
+
+    def verify_action
+      perform_action(:verify, "Verifying")
+    end
+
+    def destroy_action
+      perform_action(:destroy, "Destroying") { state_file.destroy }
+    end
+
+    def perform_action(verb, output_verb)
+      banner "#{output_verb} #{to_str}"
+      elapsed = action(verb) { |state| driver.public_send(verb, state) }
+      info("Finished #{output_verb.downcase} #{to_str}" +
+        " #{Util.duration(elapsed.real)}.")
+      yield if block_given?
+      self
+    end
+
+    def action(what, &block)
+      state = state_file.read
+      elapsed = Benchmark.measure do
+        synchronize_or_call(what, state, &block)
+      end
+      state[:last_action] = what.to_s
+      elapsed
+    rescue ActionFailed
+      raise
+    rescue Exception => e
+      raise ActionFailed, "Failed to complete ##{what} action: [#{e.message}]"
+    ensure
+      state_file.write(state)
+    end
+
+    def synchronize_or_call(what, state, &block)
+      if Array(driver.class.serial_actions).include?(what)
+        debug("#{to_str} is synchronizing on #{driver.class}##{what}")
+        self.class.mutexes[driver.class].synchronize do
+          debug("#{to_str} is messaging #{driver.class}##{what}")
+          block.call(state)
+        end
+      else
+        block.call(state)
+      end
+    end
+
+    def state_file
+      @state_file ||= StateFile.new(driver[:kitchen_root], name)
+    end
+
+    def banner(*args)
+      Kitchen.logger.logdev && Kitchen.logger.logdev.banner(*args)
+      super
+    end
+
+    # The simplest finite state machine pseudo-implementation needed to manage
+    # an Instance.
+    #
+    # @author Fletcher Nichol <fnichol@nichol.ca>
+    class FSM
+
+      # Returns an Array of all transitions to bring an Instance from its last
+      # reported transistioned state into the desired transitioned state.
+      #
+      # @param last [String,Symbol,nil] the last known transitioned state of
+      #   the Instance, defaulting to `nil` (for unknown or no history)
+      # @param desired [String,Symbol] the desired transitioned state for the
+      #   Instance
+      # @return [Array<Symbol>] an Array of transition actions to perform
+      def self.actions(last = nil, desired)
+        last_index = index(last)
+        desired_index = index(desired)
+
+        if last_index == desired_index || last_index > desired_index
+          Array(TRANSITIONS[desired_index])
+        else
+          TRANSITIONS.slice(last_index + 1, desired_index - last_index)
+        end
+      end
+
+      private
+
+      TRANSITIONS = [:destroy, :create, :converge, :setup, :verify]
+
+      def self.index(transition)
+        if transition.nil?
+          0
+        else
+          TRANSITIONS.find_index { |t| t == transition.to_sym }
+        end
+      end
+    end
+  end
+end

data/lib/kitchen/instance_actor.rb

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
+#
+# Copyright (C) 2013, Fletcher Nichol
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'delegate'
+
+module Kitchen
+
+  # A delegator for Instance which adds Celluloid actor support, boom.
+  #
+  # @author Fletcher Nichol <fnichol@nichol.ca>
+  class InstanceActor < SimpleDelegator
+
+    include Celluloid
+
+    # @!method actor_name()
+    #   Returns the name of the Celluloid actor.
+    #   @return [String] the actor name
+    alias_method :actor_name, :name
+
+    # Returns the name of the underlying instance.
+    #
+    # @return [String] the instance name
+    def name
+      __getobj__.name
+    end
+  end
+end