barking_iguana-compound 0.1.0

data/lib/barking_iguana/compound/ansible/playbook.rb

@@ -0,0 +1,96 @@
+module BarkingIguana
+  module Compound
+    module Ansible
+      class Playbook
+        attr_accessor :file, :inventory_path, :limit_pattern, :run_from, :user_name, :private_key_file, :io, :output_verbosity, :show_diff
+
+        def initialize file, run_from: nil
+          self.file = file
+          self.run_from = run_from
+          self.output_verbosity = 0
+          self.show_diff = false
+        end
+
+        def verbosity n
+          self.output_verbosity = n.to_i
+          self
+        end
+
+        def diff
+          self.show_diff = !self.show_diff
+          self
+        end
+
+        def stream_to io
+          self.io = io
+          self
+        end
+
+        def inventory name
+          self.inventory_path = name
+          self
+        end
+
+        def user name
+          self.user_name = name
+          self
+        end
+
+        def private_key key_file
+          self.private_key_file = key_file
+          self
+        end
+
+        def limit pattern
+          self.limit_pattern = pattern
+          self
+        end
+
+        def run
+          options = {}
+          options[:cwd] = run_from if run_from
+          options[:live_stream] = io if io
+          c = Mixlib::ShellOut.new(command, options)
+          c.run_command
+          c.error!
+          self
+        ensure
+          clean_up
+        end
+
+        private
+
+        def clean_up
+          return unless run_from
+          wrapper_playbook.close
+          wrapper_playbook.delete
+        end
+
+        def playbook_path
+          return file unless run_from
+          wrapper_playbook.write wrapper_playbook_content
+          wrapper_playbook.rewind
+          wrapper_playbook.path
+        end
+
+        def wrapper_playbook_content
+          "---\n- include: #{file}"
+        end
+
+        def wrapper_playbook
+          @wrapper_playbook ||= Tempfile.new(['wrapper-playbook-', '.yml'], run_from)
+        end
+
+        def command
+          c = "env ANSIBLE_RETRY_FILES_ENABLED=no ansible-playbook #{playbook_path} -i #{inventory_path}"
+          c << " -l #{limit_pattern}," unless limit_pattern.nil?
+          c << " -u #{user_name}" unless user_name.nil?
+          c << " -#{'v' * output_verbosity}" if output_verbosity > 0
+          c << " --diff" if show_diff
+          c << " --private-key=#{private_key_file}" unless private_key_file.nil?
+          c
+        end
+      end
+    end
+  end
+end

data/lib/barking_iguana/compound/host.rb

@@ -0,0 +1,21 @@
+module BarkingIguana
+  module Compound
+    class Host
+      attr_accessor :name, :uri, :state
+
+      def initialize(name:, uri:)
+        self.name = name
+        self.uri = uri
+        self.state = 'unknown'
+      end
+
+      def ssh_key
+        "#{ENV['HOME']}/.vagrant.d/insecure_private_key"
+      end
+
+      def ssh_username
+        'vagrant'
+      end
+    end
+  end
+end

data/lib/barking_iguana/compound/host_manager.rb

@@ -0,0 +1,63 @@
+module BarkingIguana
+  module Compound
+    class HostManager
+      attr_accessor :hosts
+      private :hosts=
+
+      attr_accessor :implementation
+      private :implementation=, :implementation
+
+      include BarkingIguana::Logging::Helper
+      include BarkingIguana::Benchmark
+
+      def initialize hosts = [], implementation_options = {}
+        self.hosts = hosts
+        if hosts.any? { |h| h.uri !~ /^10\.8\./ }
+          raise "Your hosts must be in the 10.8/16 CIDR to be managed by me"
+        end
+        self.implementation = Vagrant.new self, implementation_options
+        implementation.prepare
+      end
+
+      def destroy_all
+        destroy *hosts.map { |h| h.name }
+      end
+
+      def active
+        all.select { |h| h.state == 'running' }
+      end
+
+      def all
+        refresh_status
+        hosts
+      end
+
+      def refresh_status
+        benchmark "refreshing host status" do
+          implementation.refresh_status
+        end
+      end
+
+      {
+        launch: "up",
+        shutdown: "halt",
+        destroy: "destroy",
+      }.each do |interface, command|
+        define_method interface do |*host_names|
+          if host_names.empty?
+            logger.debug { "Not running anything because the hosts list is empty" }
+          else
+            host_names.sort!
+            benchmark "running #{interface} for #{host_names.join(', ')}" do
+              implementation.public_send command, *host_names
+            end
+          end
+        end
+      end
+
+      def find_by_name name
+        all.detect { |h| h.name == name }
+      end
+    end
+  end
+end

data/lib/barking_iguana/compound/server_spec.rb

@@ -0,0 +1,66 @@
+class ServerSpec
+  attr_accessor :stage
+
+  def initialize stage
+    self.stage = stage
+  end
+
+  include BarkingIguana::Logging::Helper
+  include BarkingIguana::Benchmark
+
+  def run
+    logger.debug { "Host tests: #{host_tests.inspect}" }
+    host_tests.each do |host_name, test_files|
+      command = "bundle exec ruby -S rspec -r #{control_repo_dir}/library/spec_helper.rb #{test_files.join(' ')}"
+      c = Mixlib::ShellOut.new command, live_stream: logger, cwd: control_repo_dir, env: env_for(host_name)
+      benchmark command do
+        c.run_command
+      end
+      c.error!
+    end
+  end
+
+  def control_repo_dir
+    stage.test.suite.control_directory
+  end
+
+  def host_for host_test
+    stage.test.host_manager.find_by_name host_test['name']
+  end
+
+  def env_for host_test
+    host = host_for host_test
+    raise "Could not find host #{host_test} in inventory #{hosts.inspect}" unless host
+    # TODO: Keep these in the host object
+    {
+      TARGET_HOST: host['uri'],
+      TARGET_SSH_USER: 'vagrant',
+      TARGET_SSH_KEY: "#{ENV['HOME']}/.vagrant.d/insecure_private_key"
+    }
+  end
+
+  def root_dir
+    stage.stage_file_root
+  end
+
+  def hosts
+    stage.test.host_manager.all
+  end
+
+  def host_tests
+    hosts.inject({}) do |a,e|
+      name = e.name
+      glob = "#{root_dir}/{#{name}/**/*_,}spec.rb"
+      logger.debug { "Host glob for #{name.inspect} = #{glob.inspect}" }
+      tests = Dir.glob glob
+      logger.debug { "Host tests for #{name.inspect} = #{tests.inspect}" }
+      if !tests.empty?
+        if e.state != 'running'
+          raise "There are tests for #{name} in #{stage.stage_directory}, but the host is #{e.state}"
+        end
+        a[e] = tests
+      end
+      a
+    end
+  end
+end

data/lib/barking_iguana/compound/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'serverspec'
+require 'rspec/wait'
+
+set :backend, :ssh
+set :host, ENV['TARGET_HOST']
+set :ssh_options, user: ENV['TARGET_SSH_USER'], keys: [ENV['TARGET_SSH_KEY']]

data/lib/barking_iguana/compound/test.rb

@@ -0,0 +1,84 @@
+module BarkingIguana
+  module Compound
+    class Test
+      attr_accessor :suite
+      private :suite=
+
+      attr_accessor :directory
+      private :directory=
+
+      include BarkingIguana::Logging::Helper
+      include BarkingIguana::Benchmark
+
+      def initialize suite, directory
+        self.suite = suite
+        self.directory = directory
+      end
+
+      def name
+        directory.sub(suite.directory + '/', '').tr('/', ':')
+      end
+
+      def stages
+        return [ TestStage.new(self, directory) ] if simple_test?
+        Dir[directory + '/*'].select { |d| File.directory? d }.map { |s| TestStage.new self, File.basename(s) }
+      end
+
+      def simple_test?
+        File.exists? "#{directory}/playbook.yml"
+      end
+
+      def run
+        benchmark "test #{name}" do
+          begin
+            stages.each &:run
+          ensure
+            teardown
+          end
+        end
+      end
+
+      def teardown
+        benchmark "#{name}: destroying all hosts" do
+          host_manager.destroy_all
+        end
+        return unless custom_teardown?
+        command_line = "bash -ex #{custom_teardown_file}"
+        c = Mixlib::ShellOut.new command_line, cwd: directory, live_stream: logger
+        benchmark "#{name}: running custom teardown" do
+          c.run_command
+        end
+        c.error!
+      end
+
+      def custom_teardown?
+        File.exists? custom_teardown_file
+      end
+
+      def custom_teardown_file
+        File.expand_path "teardown.sh", directory
+      end
+
+      def host_manager
+        @host_manger ||= HostManager.new(hosts, driver_options)
+      end
+
+      def driver_options
+        options = {}
+        logger.debug { "Does #{vagrant_file_template_path} exist? -> #{File.exists? vagrant_file_template_path}" }
+        options[:vagrant_file_template_path] = vagrant_file_template_path if File.exists? vagrant_file_template_path
+        options[:root] = directory
+        options
+      end
+
+      def vagrant_file_template_path
+        File.join directory, 'Vagrantfile.erb'
+      end
+
+      def hosts
+        # FIXME: Implement uniqueness operators on Host
+        stages.map(&:hosts).flatten.uniq { |h| h.uri }
+      end
+    end
+  end
+end

data/lib/barking_iguana/compound/test_stage.rb

@@ -0,0 +1,102 @@
+module BarkingIguana
+  module Compound
+    class TestStage
+      attr_accessor :test, :stage_directory
+
+      def initialize test, stage_directory
+        self.test = test
+        self.stage_directory = stage_directory
+      end
+
+      def actions
+        %i(setup converge verify).freeze
+      end
+
+      include BarkingIguana::Logging::Helper
+      include BarkingIguana::Benchmark
+
+      def run
+        benchmark display_name do
+          actions.each do |action|
+            benchmark "#{display_name} action #{action}" do
+              public_send action
+            end
+          end
+        end
+      end
+
+      def name
+        return if test.simple_test?
+        stage_directory
+      end
+
+      def display_name
+        return test.name if test.simple_test?
+        test.name + ' stage ' + stage_directory
+      end
+
+      def inventory_path
+        File.join stage_file_root, 'inventory'
+      end
+
+      def stage_file_root
+        return test.directory if test.simple_test?
+        File.expand_path stage_directory, test.directory
+      end
+
+      def playbook_path
+        "#{stage_file_root}/playbook.yml"
+      end
+
+      def inventory
+        Ansible.inventory inventory_path
+      end
+
+      def hosts
+        inventory.hosts
+      end
+
+      def control_directory
+        test.suite.control_directory
+      end
+
+      def playbook
+        Ansible.playbook(playbook_path, run_from: control_directory).inventory(inventory.path).private_key("#{ENV['HOME']}/.vagrant.d/insecure_private_key").user('vagrant').stream_to(logger).verbosity(2).diff
+      end
+
+      def suite
+        test.suite
+      end
+
+      def setup
+        desired_hosts = inventory.hosts.map { |h| h.name  }.sort
+        logger.debug { "Desired hosts for #{display_name}: #{desired_hosts.join(', ')}" }
+        active_hosts = host_manager.active.map { |h| h.name }.sort
+        logger.debug { "Active hosts for #{display_name}: #{active_hosts.join(', ')}" }
+        hosts_to_launch = desired_hosts - active_hosts
+        logger.debug { "Launch hosts for #{display_name}: #{hosts_to_launch.join(', ')}" }
+        host_manager.launch *hosts_to_launch
+        hosts_to_stop = active_hosts - desired_hosts
+        logger.debug { "Stop hosts for #{display_name}: #{hosts_to_stop.join(', ')}" }
+        host_manager.shutdown *hosts_to_stop
+      end
+
+      def host_manager
+        test.host_manager
+      end
+
+      def converge
+        return unless File.exists? playbook_path
+        playbook.run
+      end
+
+      def verify
+        server_spec.run
+      end
+
+      def server_spec
+        @server_spec ||= ServerSpec.new(self)
+      end
+    end
+  end
+end