beaker 1.21.0 → 2.0.0

data/lib/beaker/hypervisor/blimper.rb

@@ -1,108 +0,0 @@
-require 'blimpy'
-require 'yaml' unless defined?(YAML)
-require 'beaker/hypervisor/ec2_helper'
-
-module Beaker
-  class Blimper < Beaker::Hypervisor
-
-    def initialize(blimpy_hosts, options)
-      @options = options
-      @logger = options[:logger]
-      @hosts = blimpy_hosts
-      @blimpy = Blimpy
-    end
-
-    def provision
-      ami_spec= YAML.load_file(@options[:ec2_yaml])["AMI"]
-
-      fleet = @blimpy.fleet do |fleet|
-        @hosts.each do |host|
-          amitype = host['vmname'] || host['platform']
-          amisize = host['amisize'] || 'm1.small'
-          #use snapshot provided for this host
-          image_type = host['snapshot']
-          if not image_type
-            raise "No snapshot/image_type provided for blimpy provisioning"
-          end
-          ami = ami_spec[amitype]
-          fleet.add(:aws) do |ship|
-            ship.name = host.name
-            ship.ports = Beaker::EC2Helper.amiports(host['roles'])
-            ship.image_id = ami[:image][image_type.to_sym]
-            if not ship.image_id
-              raise "No image_id found for host #{ship.name} (#{amitype}:#{amisize}) using snapshot/image_type #{image_type}"
-            end
-            ship.flavor = amisize
-            ship.region = ami[:region]
-            ship.username = 'root'
-            ship.tags = {
-              :department => @options[:department],
-              :project => @options[:project],
-              :jenkins_build_url => @options[:jenkins_build_url],
-            }
-          end
-          @logger.debug "Added #{host.name} (#{amitype}:#{amisize}) using snapshot/image_type #{image_type} to blimpy fleet"
-        end
-      end
-
-      # Attempt to start the fleet, we wrap it with some error handling that
-      # deals with generic Fog errors and retrying in case these errors are
-      # transient.
-      fleet_retries = 0
-      begin
-        fleet.start
-      rescue Fog::Errors::Error, SystemCallError => ex
-        fleet_retries += 1
-        if fleet_retries <= 3
-          sleep_time = rand(10) + 10
-          @logger.notify("Calling fleet.destroy, sleeping #{sleep_time} seconds and retrying fleet.start due to exception #{ex.class.to_s} (#{ex.message}), retry attempt #{fleet_retries}.")
-          begin
-            timeout(30) do
-              fleet.destroy
-            end
-          rescue
-          end
-          sleep sleep_time
-          retry
-        else
-          @logger.error("Retried Fog #{fleet_retries} times, giving up and throwing the exception")
-          raise ex
-        end
-      end
-
-      # Configure our nodes to match the blimp fleet
-      # Also generate hosts entries for the fleet, since we're iterating
-      etc_hosts = "127.0.0.1\tlocalhost localhost.localdomain\n"
-      fleet.ships.each do |ship|
-        ship.wait_for_sshd
-        name = ship.name
-        host = @hosts.select { |host| host.name == name }[0]
-        host['ip'] = ship.dns
-        host.exec(Command.new("hostname #{name}"))
-        ip = get_ip(host)
-        domain = get_domain_name(host)
-        etc_hosts += "#{ip}\t#{name}\t#{name}.#{domain}\n"
-      end
-
-      # Send our hosts information to the nodes
-      @hosts.each do |host|
-        set_etc_hosts(host, etc_hosts)
-      end
-
-    end #revert_blimpy
-
-    def cleanup
-      fleet = @blimpy.fleet do |fleet|
-        @hosts.each do |host|
-          fleet.add(:aws) do |ship|
-            ship.name = host.name
-          end
-        end
-      end
-
-      @logger.notify "Destroying Blimpy boxes"
-      fleet.destroy
-    end
-
-  end
-end

data/spec/beaker/hypervisor/blimper_spec.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-require 'blimpy'
-
-module Beaker
-  describe Blimper do
-    let( :blimper ) { Beaker::Blimper.new( @hosts, make_opts ) }
-    let( :amispec ) { { "centos-5-x86-64-west" => { :image => { :pe => "ami-sekrit1" }, :region => "us-west-2" }, 
-                        "centos-6-x86-64-west" => { :image => { :pe => "ami-sekrit2" }, :region => "us-west-2" }, 
-                        "centos-7-x86-64-west" => { :image => { :pe => "ami-sekrit3" }, :region => "us-west-2" } }}
-
-    before :each do
-      @hosts = make_hosts( { :snapshot => :pe })
-      @hosts[0][:platform] = "centos-5-x86-64-west" 
-      @hosts[1][:platform] = "centos-6-x86-64-west" 
-      @hosts[2][:platform] = "centos-7-x86-64-west" 
-      blimper.instance_variable_set( :@blimpy, MockBlimpy )
-    end
-
-    it "can provision a set of hosts" do 
-      YAML.stub( :load_file ).and_return( {"AMI" => amispec} )
-      blimper.stub( :get_ip ) do |host|
-        host['ip']
-      end
-      blimper.stub( :get_domain_name ).and_return( 'domain' )
-      blimper.stub( :sleep ).and_return( true )
-
-      @hosts.each do |host|
-        blimper.should_receive( :set_etc_hosts ).with( host, "127.0.0.1\tlocalhost localhost.localdomain\nvm1.my.ip\tvm1\tvm1.domain\nvm2.my.ip\tvm2\tvm2.domain\nvm3.my.ip\tvm3\tvm3.domain\n" )
-      end
-
-      blimper.provision
-    end
-
-    it "calls fleet.destroy on cleanup" do
-      MockFleet.any_instance.should_receive( :add ).with( :aws ).exactly( @hosts.length ).times
-      MockFleet.any_instance.should_receive( :destroy ).once
-
-      blimper.cleanup
-    end
-
-  end
-end

data/spec/beaker/options/data/LATEST

@@ -1 +0,0 @@
-3.0.0

data/spec/beaker/puppet_command_spec.rb

@@ -1,161 +0,0 @@
-require 'spec_helper'
-
-module Beaker
-  #most testing already covered in Command, just need to cover env variable handling
-  describe PuppetCommand do
-    let(:command) { @command || '/bin/ls' }
-    let(:args)    { @args    || Array.new }
-    let(:options) { @options || {} }
-    subject(:cmd) { PuppetCommand.new( command, args, options ) }
-    let(:host)    { make_host( 'name', { :platform => @platform } ) }
-
-    let( :nix_path ) { %q[PATH="/usr/bin:/opt/puppet-git-repos/hiera/bin:${PATH}"] }
-    let( :nix_lib  ) { %q[RUBYLIB="/opt/puppet-git-repos/hiera/lib:/opt/puppet-git-repos/hiera-puppet/lib:${RUBYLIB}"] }
-
-    it 'creates a Windows env for a Windows host' do
-      @platform = 'windows'
-      @command = 'agent'
-      @args    = [ 'to', 'the', 'baz' ]
-      @options = { :foo => 'bar' }
-
-      expect( host ).to be_a_kind_of Windows::Host
-      expect( cmd.options ).to be == options
-      expect( cmd.args    ).to be == [@args]
-      expect( cmd.command ).to be == "puppet " + @command
-
-      expect( cmd.args_string    ).to be == 'to the baz'
-      expect( cmd.options_string ).to be == '--foo=bar'
-
-      win_path  = %q[/opt/puppet-git-repos/hiera/bin:${PATH}]
-      win_lib   = %q[`cygpath -w /opt/puppet-git-repos/hiera/lib`;`cygpath -w /opt/puppet-git-repos/hiera-puppet/lib`;${RUBYLIB}]
-      cmd_exe   = %q[cmd.exe /c]
-
-      command_line = cmd.environment_string_for( host, cmd.environment )
-      expect( command_line ).to include( win_path )
-      expect( command_line ).to include( win_lib )
-      expect( command_line ).to include( cmd_exe )
-    end
-
-    it 'creates a Unix env for a Unix host' do
-      @platform = 'unix'
-      @command = 'agent'
-      @args    = [ 'to', 'the', 'baz' ]
-      @options = { :foo => 'bar' }
-
-      expect( host ).to be_a_kind_of Unix::Host
-      expect( cmd.options ).to be == @options
-      expect( cmd.args    ).to be == [@args]
-      expect( cmd.command ).to be == "puppet " + @command
-
-      expect( cmd.args_string    ).to be == 'to the baz'
-      expect( cmd.options_string ).to be == '--foo=bar'
-
-      command_line = cmd.environment_string_for( host, cmd.environment )
-      expect( command_line ).to include( nix_path )
-      expect( command_line ).to include( nix_lib )
-    end
-
-    it 'creates an AIX env for an AIX host' do
-      @platform = 'aix'
-      @command = 'agent'
-      @args    = [ 'to', 'the', 'baz' ]
-      @options = { :foo => 'bar' }
-
-      expect( host ).to be_a_kind_of Aix::Host
-      expect( cmd.options ).to be == @options
-      expect( cmd.args    ).to be == [@args]
-      expect( cmd.command ).to be == "puppet " + @command
-
-      expect( cmd.args_string    ).to be == 'to the baz'
-      expect( cmd.options_string ).to be == '--foo=bar'
-
-      command_line = cmd.environment_string_for( host, cmd.environment )
-      expect( command_line ).to include( nix_path )
-      expect( command_line ).to include( nix_lib )
-    end
-
-    it 'correctly adds additional ENV to default ENV' do
-      @platform = 'unix'
-      @command = 'agent'
-      @args    = [ 'to', 'the', 'baz' ]
-      @options = { :foo => 'bar', 'ENV' => {'PATH' => '/STRING_ENV/bin'} }
-
-      expect( host ).to be_a_kind_of Unix::Host
-      expect( cmd.options ).to be == @options
-      expect( cmd.args    ).to be == [@args]
-      expect( cmd.command ).to be == "puppet " + @command
-
-      expect( cmd.args_string    ).to be == 'to the baz'
-      expect( cmd.options_string ).to be == '--foo=bar'
-      custom = %q[PATH="/STRING_ENV/bin"]
-
-      command_line = cmd.environment_string_for( host, cmd.environment )
-      expect( command_line ).to include( nix_path )
-      expect( command_line ).to include( nix_lib )
-      expect( command_line ).to include( custom )
-    end
-
-    it 'correctly adds additional :ENV to default ENV' do
-      @platform = 'unix'
-      @command = 'agent'
-      @args    = [ 'to', 'the', 'baz' ]
-      @options = { :foo => 'bar', :ENV => {'PATH' => '/SYMBOL_ENV/bin'} }
-
-      expect( host ).to be_a_kind_of Unix::Host
-      expect( cmd.options ).to be == @options
-      expect( cmd.args    ).to be == [@args]
-      expect( cmd.command ).to be == "puppet " + @command
-
-      expect( cmd.args_string    ).to be == 'to the baz'
-      expect( cmd.options_string ).to be == '--foo=bar'
-
-      custom = %q[PATH="/SYMBOL_ENV/bin"]
-      command_line = cmd.environment_string_for( host, cmd.environment )
-      expect( command_line ).to include( nix_path )
-      expect( command_line ).to include( nix_lib )
-      expect( command_line ).to include( custom )
-    end
-
-    it 'correctly adds additional :environment to default ENV' do
-      @platform = 'unix'
-      @command = 'agent'
-      @args    = [ 'to', 'the', 'baz' ]
-      @options = { :foo => 'bar', :environment => {'PATH' => '/SYMBOL_ENVIRONMENT/bin'} }
-
-      expect( host ).to be_a_kind_of Unix::Host
-      expect( cmd.options ).to be == @options
-      expect( cmd.args    ).to be == [@args]
-      expect( cmd.command ).to be == "puppet " + @command
-
-      expect( cmd.args_string    ).to be == 'to the baz'
-      expect( cmd.options_string ).to be == '--foo=bar'
-
-      custom = %q[PATH="/SYMBOL_ENVIRONMENT/bin"]
-      command_line = cmd.environment_string_for( host, cmd.environment )
-      expect( command_line ).to include( nix_path )
-      expect( command_line ).to include( nix_lib )
-      expect( command_line ).to include( custom )
-    end
-
-    it 'correctly adds additional environment to default ENV' do
-      @platform = 'unix'
-      @command = 'agent'
-      @args    = [ 'to', 'the', 'baz' ]
-      @options = { :foo => 'bar', 'environment' => {'PATH' => '/STRING_ENVIRONMENT/bin'} }
-
-      expect( host ).to be_a_kind_of Unix::Host
-      expect( cmd.options ).to be == @options
-      expect( cmd.args    ).to be == [@args]
-      expect( cmd.command ).to be == "puppet " + @command
-
-      expect( cmd.args_string    ).to be == 'to the baz'
-      expect( cmd.options_string ).to be == '--foo=bar'
-
-      custom = %q[PATH="/STRING_ENVIRONMENT/bin"]
-      command_line = cmd.environment_string_for( host, cmd.environment )
-      expect( command_line ).to include( nix_path )
-      expect( command_line ).to include( nix_lib )
-      expect( command_line ).to include( custom )
-    end
-  end
-end

data/spec/mock_blimpy.rb

@@ -1,48 +0,0 @@
-class MockShip 
-  attr_accessor :name, :ports, :image_id, :flavor, :region, :username, :dns, :tags
-
-  def initialize
-    @dns = "my.ip.address"
-  end
-
-  def wait_for_sshd
-    @dns = "#{@name}.my.ip"
-    return true
-  end
-
-end
-
-class MockFleet
-  attr_accessor :ships
-  @@attempts = 0
-
-  def initialize
-    @ships = []
-  end
-
-  def add type
-    @ships << MockShip.new
-    yield(@ships[-1])
-    @ships[-1]
-  end
-
-  def start
-    if @@attempts < 1
-      @@attempts += 1
-      raise Fog::Errors::Error
-    end
-  end
-
-  def destroy
-  end
-
-end
-
-class MockBlimpy 
-  @@fleet = nil
-  def self.fleet 
-    yield(@@fleet = MockFleet.new)
-    @@fleet
-  end
-
-end