beaker 3.20.0 → 3.21.0

data/lib/beaker/hypervisor/vagrant.rb

@@ -1,286 +0,0 @@
-require 'open3'
-
-module Beaker
-  class Vagrant < Beaker::Hypervisor
-
-    # Return a random mac address
-    #
-    # @return [String] a random mac address
-    def randmac
-      "080027" + (1..3).map{"%0.2X"%rand(256)}.join
-    end
-
-    def rand_chunk
-      (2 + rand(252)).to_s #don't want a 0, 1, or a 255
-    end
-
-    def randip
-      "10.255.#{rand_chunk}.#{rand_chunk}"
-    end
-
-    def private_network_generator(host)
-      private_network_string = "    v.vm.network :private_network, ip: \"#{host['ip'].to_s}\", :netmask => \"#{host['netmask'] ||= "255.255.0.0"}\""
-      case host['network_mac']
-      when 'false'
-        private_network_string << "\n"
-      when nil
-        private_network_string << ", :mac => \"#{randmac}\"\n"
-      else
-        private_network_string << ", :mac => \"#{host['network_mac']}\"\n"
-      end
-    end
-
-    def make_vfile hosts, options = {}
-      #HACK HACK HACK - add checks here to ensure that we have box + box_url
-      #generate the VagrantFile
-      v_file = "Vagrant.configure(\"2\") do |c|\n"
-      v_file << "  c.ssh.forward_agent = true\n" if options[:forward_ssh_agent] == true
-      v_file << "  c.ssh.insert_key = false\n"
-      hosts.each do |host|
-        host['ip'] ||= randip #use the existing ip, otherwise default to a random ip
-        v_file << "  c.vm.define '#{host.name}' do |v|\n"
-        v_file << "    v.vm.hostname = '#{host.name}'\n"
-        v_file << "    v.vm.box = '#{host['box']}'\n"
-        v_file << "    v.vm.box_url = '#{host['box_url']}'\n" unless host['box_url'].nil?
-        v_file << "    v.vm.box_version = '#{host['box_version']}'\n" unless host['box_version'].nil?
-        v_file << "    v.vm.box_check_update = '#{host['box_check_update'] ||= 'true'}'\n"
-        v_file << "    v.vm.synced_folder '.', '/vagrant', disabled: true\n" if host['synced_folder'] == 'disabled'
-        v_file << private_network_generator(host)
-
-        unless host['mount_folders'].nil?
-          host['mount_folders'].each do |name, folder|
-            v_file << "    v.vm.synced_folder '#{folder[:from]}', '#{folder[:to]}', create: true\n"
-          end
-        end
-
-        unless host['forwarded_ports'].nil?
-          host['forwarded_ports'].each do |_name, port|
-            fwd = "    v.vm.network :forwarded_port,"
-            fwd << " protocol: '#{port[:protocol]}'," unless port[:protocol].nil?
-            fwd << " guest_ip: '#{port[:to_ip]}'," unless port[:to_ip].nil?
-            fwd << " guest: #{port[:to]},"
-            fwd << " host_ip: '#{port[:from_ip]}'," unless port[:from_ip].nil?
-            fwd << " host: #{port[:from]}"
-            fwd << "\n"
-
-            v_file << fwd
-          end
-        end
-
-        if /windows/i.match(host['platform'])
-          #due to a regression bug in versions of vagrant 1.6.2, 1.6.3, 1.6.4, >= 1.7.3 ssh fails to forward
-          #automatically (note <=1.6.1, 1.6.5, 1.7.0 - 1.7.2 are uneffected)
-          #Explicitly setting SSH port forwarding due to this bug
-          v_file << "    v.vm.network :forwarded_port, guest: 22, host: 2222, id: 'ssh', auto_correct: true\n"
-          v_file << "    v.vm.network :forwarded_port, guest: 3389, host: 3389, id: 'rdp', auto_correct: true\n"
-          v_file << "    v.vm.network :forwarded_port, guest: 5985, host: 5985, id: 'winrm', auto_correct: true\n"
-          v_file << "    v.vm.guest = :windows\n"
-        end
-
-        if /osx/i.match(host['platform'])
-          v_file << "    v.vm.network 'private_network', ip: '10.0.1.10'\n"
-          v_file << "    v.vm.synced_folder '.', '/vagrant', :nfs => true\n"
-        end
-
-        if /freebsd/i.match(host['platform'])
-          v_file << "    v.ssh.shell = 'sh'\n"
-          v_file << "    v.vm.guest = :freebsd\n"
-
-          # FreeBSD NFS has a character restriction of 88 characters
-          # So you can enable it but if your module has a long name it probably won't work...
-          # So to keep things simple let's rsync by default!
-          #
-          # Further reading if interested:
-          # http://www.secnetix.de/olli/FreeBSD/mnamelen.hawk
-          # https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=167105
-          #
-          if host['vagrant_freebsd_nfs'].nil?
-            v_file << "    v.vm.synced_folder '.', '/vagrant', type: 'rsync'\n"
-          else
-            v_file << "    v.vm.synced_folder '.', '/vagrant', :nfs => true\n"
-          end
-        end
-
-        v_file << self.class.provider_vfile_section(host, options)
-
-        v_file << "  end\n"
-        @logger.debug "created Vagrantfile for VagrantHost #{host.name}"
-      end
-      v_file << "end\n"
-      File.open(@vagrant_file, 'w') do |f|
-        f.write(v_file)
-      end
-    end
-
-    def self.provider_vfile_section host, options
-      # Backwards compatibility; default to virtualbox
-      Beaker::VagrantVirtualbox.provider_vfile_section(host, options)
-    end
-
-    def set_ssh_config host, user
-        f = Tempfile.new("#{host.name}")
-        ssh_config = Dir.chdir(@vagrant_path) do
-          stdin, stdout, stderr, wait_thr = Open3.popen3(@vagrant_env, 'vagrant', 'ssh-config', host.name)
-          if not wait_thr.value.success?
-            raise "Failed to 'vagrant ssh-config' for #{host.name}"
-          end
-          stdout.read
-        end
-        #replace hostname with ip
-        ssh_config = ssh_config.gsub(/Host #{host.name}/, "Host #{host['ip']}") unless not host['ip']
-
-        #set the user
-        ssh_config = ssh_config.gsub(/User vagrant/, "User #{user}")
-        f.write(ssh_config)
-        f.rewind
-        host['ssh'] = {:config => f.path()}
-        host['user'] = user
-        @temp_files << f
-    end
-
-    def get_ip_from_vagrant_file(hostname)
-      ip = ''
-      if File.file?(@vagrant_file) #we should have a vagrant file available to us for reading
-        f = File.read(@vagrant_file)
-        m = /'#{hostname}'.*?ip:\s*('|")\s*([^'"]+)('|")/m.match(f)
-        if m
-          ip = m[2]
-          @logger.debug("Determined existing vagrant box #{hostname} ip to be: #{ip} ")
-        else
-          ip = nil
-          @logger.debug("Unable to determine ip for vagrant box #{hostname}")
-        end
-      else
-        raise("No vagrant file found (should be located at #{@vagrant_file})")
-      end
-      ip
-    end
-
-    def initialize(vagrant_hosts, options)
-      require 'tempfile'
-      @options = options
-      @logger = options[:logger]
-      @temp_files = []
-      @hosts = vagrant_hosts
-      @vagrant_path = File.expand_path(File.join(File.basename(__FILE__), '..', '.vagrant', 'beaker_vagrant_files', File.basename(options[:hosts_file])))
-      FileUtils.mkdir_p(@vagrant_path)
-      @vagrant_file = File.expand_path(File.join(@vagrant_path, "Vagrantfile"))
-      @vagrant_env = { "RUBYLIB" => "" }
-    end
-
-    def provision(provider = nil)
-      if !@options[:provision] and !File.file?(@vagrant_file)
-        raise "Beaker is configured with provision = false but no vagrant file was found at #{@vagrant_file}. You need to enable provision"
-      end
-      if @options[:provision]
-        #setting up new vagrant hosts
-        #make sure that any old boxes are dead dead dead
-        begin
-          vagrant_cmd("destroy --force") if File.file?(@vagrant_file)
-        rescue RuntimeError => e
-          # LATER: use <<~MESSAGE once we're on Ruby 2.3
-          @logger.debug(%Q{
-            Beaker failed to destroy the existing VM's. If you think this is
-            an error or you upgraded from an older version of beaker try
-            verifying the VM exists and deleting the existing Vagrantfile if
-            you believe it is safe to do so. WARNING: If a VM still exists
-            please run 'vagrant destroy'.
-
-            cd #{@vagrant_path}
-            vagrant status
-            vagrant destroy # only need to run this is a VM is not created
-            rm #{@vagrant_file} # only do this if all VM's are actually destroyed
-          }.each_line.map(&:strip).join("\n"))
-          raise e
-        end
-
-        make_vfile @hosts, @options
-
-        vagrant_cmd("up#{" --provider #{provider}" if provider}")
-      else #set host ip of already up boxes
-        @hosts.each do |host|
-          host[:ip] = get_ip_from_vagrant_file(host.name)
-        end
-      end
-
-      @logger.debug "configure vagrant boxes (set ssh-config, switch to root user, hack etc/hosts)"
-      @hosts.each do |host|
-        if host[:platform] =~ /windows/
-          @logger.debug "skip ssh hacks on windows box #{host[:name]}"
-          set_ssh_config host, host['user']
-          next
-        end
-
-        default_user = host['user']
-
-        set_ssh_config host, 'vagrant'
-
-        #copy vagrant's keys to roots home dir, to allow for login as root
-        copy_ssh_to_root host, @options
-        #ensure that root login is enabled for this host
-        enable_root_login host, @options
-        #shut down connection, will reconnect on next exec
-        host.close
-
-        set_ssh_config host, default_user
-      end
-
-      hack_etc_hosts @hosts, @options
-
-    end
-
-    def cleanup
-      @logger.debug "removing temporary ssh-config files per-vagrant box"
-      @temp_files.each do |f|
-        f.close()
-      end
-      @logger.notify "Destroying vagrant boxes"
-      vagrant_cmd("destroy --force")
-      FileUtils.rm_rf(@vagrant_path)
-    end
-
-    def vagrant_cmd(args)
-      Dir.chdir(@vagrant_path) do
-        exit_status = 1
-        Open3.popen3(@vagrant_env, "vagrant #{args}") {|stdin, stdout, stderr, wait_thr|
-          while line = stdout.gets
-            @logger.info(line)
-          end
-          if not wait_thr.value.success?
-            raise "Failed to exec 'vagrant #{args}'. Error was #{stderr.read}"
-          end
-          exit_status = wait_thr.value
-        }
-        if exit_status != 0
-          raise "Failed to execute vagrant_cmd ( #{args} ). Error was #{stderr.read}"
-        end
-      end
-    end
-
-    def self.cpus(host, options)
-      case
-      when host['vagrant_cpus']
-        host['vagrant_cpus']
-      when options['vagrant_cpus']
-        options['vagrant_cpus']
-      else
-        '1'
-      end
-    end
-
-    def self.memsize(host, options)
-      case
-      when host['vagrant_memsize']
-        host['vagrant_memsize']
-      when options['vagrant_memsize']
-        options['vagrant_memsize']
-      else
-        if host['platform'] =~ /windows/
-          '2048'
-        else
-          '1024'
-        end
-      end
-    end
-  end
-end

data/lib/beaker/hypervisor/vagrant_custom.rb

@@ -1,11 +0,0 @@
-require 'beaker/hypervisor/vagrant'
-
-class Beaker::VagrantCustom < Beaker::Vagrant
-  def provision(provider = nil)
-    super
-  end
-
-  def make_vfile hosts, options = {}
-    FileUtils.cp(@options[:vagrantfile_path], @vagrant_file)
-  end
-end

data/lib/beaker/hypervisor/vagrant_fusion.rb

@@ -1,17 +0,0 @@
-require 'beaker/hypervisor/vagrant'
-
-class Beaker::VagrantFusion < Beaker::Vagrant
-  def provision(provider = 'vmware_fusion')
-    # By default vmware_fusion creates a .vagrant directory relative to the
-    # Vagrantfile path. That means beaker tries to scp the VM to itself unless
-    # we move the VM files elsewhere.
-    ENV['VAGRANT_VMWARE_CLONE_DIRECTORY'] = '~/.vagrant/vmware_fusion'
-    super
-  end
-
-  def self.provider_vfile_section(host, options)
-    "    v.vm.provider :vmware_fusion do |v|\n" +
-    "      v.vmx['memsize'] = '#{memsize(host, options)}'\n" +
-    "    end\n"
-  end
-end

data/lib/beaker/hypervisor/vagrant_libvirt.rb

@@ -1,41 +0,0 @@
-require 'beaker/hypervisor/vagrant'
-
-class Beaker::VagrantLibvirt < Beaker::Vagrant
-  @memory = nil
-  @cpu    = nil
-
-  class << self
-    attr_reader :memory
-  end
-
-  # Return a random mac address with colons
-  #
-  # @return [String] a random mac address
-  def randmac
-    "08:00:27:" + (1..3).map{"%0.2X"%rand(256)}.join(':')
-  end
-
-  def provision(provider = 'libvirt')
-    super
-  end
-
-  def self.provider_vfile_section(host, options)
-    "    v.vm.provider :libvirt do |node|\n" +
-      "      node.cpus = #{cpus(host, options)}\n" +
-      "      node.memory = #{memsize(host, options)}\n" +
-      build_options_str(options) +
-      "    end\n"
-  end
-
-  def self.build_options_str(options)
-    other_options_str = ''
-    if options['libvirt']
-      other_options = []
-      options['libvirt'].each do |k, v|
-        other_options << "      node.#{k} = '#{v}'"
-      end
-      other_options_str = other_options.join("\n")
-    end
-    "#{other_options_str}\n"
-  end
-end

data/lib/beaker/hypervisor/vagrant_parallels.rb

@@ -1,18 +0,0 @@
-require 'beaker/hypervisor/vagrant'
-
-class Beaker::VagrantParallels < Beaker::Vagrant
-    def provision(provider = 'parallels')
-        super
-    end
-
-    def self.provider_vfile_section(host, options)
-        provider_section  = ""
-        provider_section << "    v.vm.provider :parallels do |prl|\n"
-        provider_section << "      prl.optimize_power_consumption = false\n"
-        provider_section << "      prl.memory = '#{memsize(host,options)}'\n"
-        provider_section << "      prl.update_guest_tools = false\n" if options[:prl_update_guest_tools] == 'disable'
-        provider_section << "    end\n"
-
-        provider_section
-    end
-end

data/lib/beaker/hypervisor/vagrant_virtualbox.rb

@@ -1,76 +0,0 @@
-require 'beaker/hypervisor/vagrant'
-
-class Beaker::VagrantVirtualbox < Beaker::Vagrant
-  def provision(provider = 'virtualbox')
-    super
-  end
-
-  # Generate a VM customization string
-  def self.vb_customize(command, args)
-    "      vb.customize ['#{command}', #{args.map{|a| "'#{a.to_s}'"}.join(", ")}]\n"
-  end
-
-  # Generate a VM customization string for the current VM
-  def self.vb_customize_vm(command, args)
-    "      vb.customize ['#{command}', :id, #{args.map{|a| "'#{a.to_s}'"}.join(", ")}]\n"
-  end
-
-  def self.provider_vfile_section(host, options)
-    # Allow memory and CPUs to be set at a per node level or overall, and take the most specific setting
-    provider_section  = ""
-    provider_section << "    v.vm.provider :virtualbox do |vb|\n"
-    provider_section << "      vb.customize ['modifyvm', :id, '--memory', '#{memsize(host,options)}', '--cpus', '#{cpus(host,options)}']\n"
-    provider_section << "      vb.vbguest.auto_update = false" if options[:vbguest_plugin] == 'disable'
-
-    # Guest volume support
-    # - Creates a new AHCI controller with the requisite number of ports,
-    #   the default controller is limited in its number of supported ports (2).
-    #   The AHCI emulation is generic enough for acceptance testing, and
-    #   presents the devices as SCSI devices in /sys/class/scsi_disk.
-    # - Creates the defined volumes in beaker's temporary folder and attaches
-    #   them to the controller in order starting at port 0.  This presents disks
-    #   as 2:0:0:0, 3:0:0:0 ... much like you'd see on commercial storage boxes
-    if host['volumes']
-      provider_section << self.vb_customize_vm('storagectl', [
-        '--name', 'SATA Controller',
-        '--add', 'sata',
-        '--controller', 'IntelAHCI',
-        '--portcount', host['volumes'].length
-      ])
-      host['volumes'].keys.each_with_index do |volume, index|
-        volume_path = "#{host.name}-#{volume}.vdi"
-        provider_section << self.vb_customize('createhd', [
-          '--filename', volume_path,
-          '--size', host['volumes'][volume]['size'],
-        ])
-        provider_section << self.vb_customize_vm('storageattach', [
-          '--storagectl', 'SATA Controller',
-          '--port', index,
-          '--device', 0,
-          '--type', 'hdd',
-          '--medium', volume_path,
-        ])
-      end
-    end
-
-    provider_section << "      vb.customize [\"modifyvm\", :id, \"--natdnshostresolver1\", \"#{host['natdns']}\"]\n" unless host['natdns'].nil?
-
-    provider_section << "      vb.customize [\"modifyvm\", :id, \"--natdnsproxy1\", \"#{host['natdns']}\"]\n" unless host['natdns'].nil?
-
-    provider_section << "      vb.gui = true\n" unless host['vb_gui'].nil?
-
-    provider_section << "      [\"modifyvm\", :id, \"--cpuidset\", \"1\",\"000206a7\",\"02100800\",\"1fbae3bf\",\"bfebfbff\"\]" if /osx/i.match(host['platform'])
-
-    if host['disk_path']
-      unless File.exist?(host['disk_path'])
-        host['disk_path'] = File.join(host['disk_path'], "#{host.name}.vmdk")
-        provider_section << "      vb.customize ['createhd', '--filename', '#{host['disk_path']}', '--size', #{host['disk_size'] ||= 5 * 1024}, '--format', 'vmdk']\n"
-      end
-      provider_section << "      vb.customize ['storageattach', :id, '--storagectl', 'SATA Controller', '--port', 1, '--device', 0, '--type', 'hdd', '--medium','#{host['disk_path']}']\n"
-    end
-
-    provider_section << "    end\n"
-
-    provider_section
-  end
-end