beaker 0.0.0

data/lib/beaker/hypervisor/blimper.rb

@@ -0,0 +1,123 @@
+module Beaker 
+  class Blimper < Beaker::Hypervisor
+
+    def amiports(host)
+      roles = host['roles']
+      ports = [22]
+
+      if roles.include? 'database'
+        ports << 8080
+        ports << 8081
+      end
+
+      if roles.include? 'master'
+        ports << 8140
+      end
+
+      if roles.include? 'dashboard'
+        ports << 443
+      end
+
+      ports
+    end
+
+  def initialize(blimpy_hosts, options, config)
+    @options = options
+    @config = config['CONFIG'].dup
+    @logger = options[:logger]
+    @blimpy_hosts = blimpy_hosts
+    require 'rubygems' unless defined?(Gem)
+    require 'yaml' unless defined?(YAML)
+    begin
+      require 'blimpy'
+    rescue LoadError
+      raise "Unable to load Blimpy, please ensure its installed"
+    end
+    ami_spec= YAML.load_file('config/image_templates/ec2.yaml')["AMI"]
+
+    fleet = Blimpy.fleet do |fleet|
+      @blimpy_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 = amiports(host)
+          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'
+        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 => 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 Fog::Errors::Error (#{
+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 = @blimpy_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
+    @blimpy_hosts.each do |host|
+      set_etc_hosts(host, etc_hosts)
+    end
+
+    end #revert_blimpy
+
+    def cleanup
+      fleet = Blimpy.fleet do |fleet|
+        @blimpy_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/lib/beaker/hypervisor/fusion.rb

@@ -0,0 +1,56 @@
+module Beaker 
+  class Fusion < Beaker::Hypervisor
+
+  def initialize(fusion_hosts, options, config)
+      require 'rubygems' unless defined?(Gem)
+      begin
+        require 'fission'
+      rescue LoadError
+        raise "Unable to load fission, please ensure it is installed!"
+      end
+      @logger = options[:logger]
+      @options = options
+      @config = config['CONFIG'].dup
+      @fusion_hosts = fusion_hosts
+
+
+      available = Fission::VM.all.data.collect{|vm| vm.name}.sort.join(", ")
+      @logger.notify "Available VM names: #{available}"
+
+      @fusion_hosts.each do |host|
+        vm_name = host["vmname"] || host.name
+        vm = Fission::VM.new vm_name
+        raise "Could not find VM '#{vm_name}' for #{host.name}!" unless vm.exists?
+
+        available_snapshots = vm.snapshots.data.sort.join(", ")
+        @logger.notify "Available snapshots for #{host.name}: #{available_snapshots}"
+        snap_name = host["snapshot"] 
+        raise "No snapshot specified for #{host.name}" unless snap_name
+        raise "Could not find snapshot '#{snap_name}' for host #{host.name}!" unless vm.snapshots.data.include? snap_name
+
+        @logger.notify "Reverting #{host.name} to snapshot '#{snap_name}'"
+        start = Time.now
+        vm.revert_to_snapshot snap_name
+        while vm.running?.data
+          sleep 1
+        end
+        time = Time.now - start
+        @logger.notify "Spent %.2f seconds reverting" % time
+
+        @logger.notify "Resuming #{host.name}"
+        start = Time.now
+        vm.start :headless => true
+        until vm.running?.data
+          sleep 1
+        end
+        time = Time.now - start
+        @logger.notify "Spent %.2f seconds resuming VM" % time
+      end
+    end #revert_fusion
+
+    def cleanup
+      @logger.notify "No cleanup for fusion boxes"
+    end
+
+end
+end

data/lib/beaker/hypervisor/solaris.rb

@@ -0,0 +1,65 @@
+module Beaker 
+  class Solaris < Beaker::Hypervisor
+
+    def initialize(solaris_hosts, options, config)
+      @options = options
+      @config = config['CONFIG'].dup
+      @logger = options[:logger]
+      @solaris_hosts = solaris_hosts
+      fog_file = nil
+      if File.exists?( File.join(ENV['HOME'], '.fog') )
+        fog_file = YAML.load_file( File.join(ENV['HOME'], '.fog') )
+      end
+      raise "Cant load ~/.fog config" unless fog_file
+
+      hypername = fog_file[:default][:solaris_hypervisor_server]
+      vmpath    = fog_file[:default][:solaris_hypervisor_vmpath]
+      snappaths = fog_file[:default][:solaris_hypervisor_snappaths]
+
+      hyperconf = {
+        'HOSTS'  => {
+          hypername => { 'platform' => 'solaris-11-sparc' }
+        },
+        'CONFIG' => {
+          'user' => fog_file[:default][:solaris_hypervisor_username] || ENV['USER'],
+          'ssh'  => {
+            :keys => fog_file[:default][:solaris_hypervisor_keyfile] || "#{ENV['HOME']}/.ssh/id_rsa"
+          }
+        }
+      }
+
+      hyperconfig = Beaker::TestConfig.new( hyperconf, @options )
+
+      @logger.notify "Connecting to hypervisor at #{hypername}"
+      hypervisor = Beaker::Host.create( hypername, @options, hyperconfig )
+
+      @solaris_hosts.each do |host|
+        vm_name = host['vmname'] || host.name
+        #use the snapshot provided for this host
+        snapshot = host['snapshot']
+
+
+        @logger.notify "Reverting #{vm_name} to snapshot #{snapshot}"
+        start = Time.now
+        hypervisor.exec(Command.new("sudo /sbin/zfs rollback -Rf #{vmpath}/#{vm_name}@#{snapshot}"))
+        snappaths.each do |spath|
+          @logger.notify "Reverting #{vm_name}/#{spath} to snapshot #{snapshot}"
+          hypervisor.exec(Command.new("sudo /sbin/zfs rollback -Rf #{vmpath}/#{vm_name}/#{spath}@#{snapshot}"))
+        end
+        time = Time.now - start
+        @logger.notify "Spent %.2f seconds reverting" % time
+
+        @logger.notify "Booting #{vm_name}"
+        start = Time.now
+        hypervisor.exec(Command.new("sudo /sbin/zoneadm -z #{vm_name} boot"))
+        @logger.notify "Spent %.2f seconds booting #{vm_name}" % (Time.now - start)
+      end
+      hypervisor.close
+    end
+
+    def cleanup
+      @logger.notify "No cleanup for solaris boxes"
+    end
+
+  end
+end

data/lib/beaker/hypervisor/vagrant.rb

@@ -0,0 +1,118 @@
+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
+      (1 + rand(253)).to_s #don't want a 0 or a 255
+    end
+    
+    def randip
+      "192.168.#{rand_chunk}.#{rand_chunk}"
+    end
+
+    def make_vfile hosts
+      #HACK HACK HACK - add checks here to ensure that we have box + box_url
+      #generate the VagrantFile
+      vagrant_file = "Vagrant.configure(\"2\") do |c|\n"
+      hosts.each do |host|
+        host['ip'] ||= randip #use the existing ip, otherwise default to a random ip
+        vagrant_file << "  c.vm.define '#{host.name}' do |v|\n"
+        vagrant_file << "    v.vm.hostname = '#{host.name}'\n"
+        vagrant_file << "    v.vm.box = '#{host['box']}'\n"
+        vagrant_file << "    v.vm.box_url = '#{host['box_url']}'\n" unless host['box_url'].nil?
+        vagrant_file << "    v.vm.base_mac = '#{randmac}'\n"
+        vagrant_file << "    v.vm.network :private_network, ip: \"#{host['ip'].to_s}\"\n"
+        vagrant_file << "  end\n"
+        @logger.debug "created Vagrantfile for VagrantHost #{host.name}"
+      end
+      vagrant_file << "  c.vm.provider :virtualbox do |vb|\n"
+      vagrant_file << "    vb.customize [\"modifyvm\", :id, \"--memory\", \"1024\"]\n"
+      vagrant_file << "  end\n"
+      vagrant_file << "end\n"
+      f = File.open("Vagrantfile", 'w') 
+      f.write(vagrant_file)
+      f.close()
+    end
+
+    def hack_etc_hosts hosts
+      etc_hosts = "127.0.0.1\tlocalhost localhost.localdomain\n"
+      hosts.each do |host|
+        etc_hosts += "#{host['ip'].to_s}\t#{host.name}\n"
+      end
+      hosts.each do |host|
+        set_etc_hosts(host, etc_hosts)
+      end
+    end
+
+    def copy_ssh_to_root host
+      #make is possible to log in as root by copying the ssh dir to root's account
+      @logger.debug "Give root a copy of vagrant's keys"
+      if host['platform'] =~ /windows/
+        host.exec(Command.new('sudo su -c "cp -r .ssh /home/Administrator/."'))
+      else
+        host.exec(Command.new('sudo su -c "cp -r .ssh /root/."'))
+      end
+    end
+
+    def set_ssh_config host, user
+        f = Tempfile.new("#{host.name}")
+        ssh_config = `vagrant ssh-config #{host.name}`
+        #replace hostname with ip
+        ssh_config = ssh_config.gsub(/#{host.name}/, 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 initialize(vagrant_hosts, options, config)
+      require 'tempfile'
+      @options = options
+      @config = config['CONFIG'].dup
+      @logger = options[:logger]
+      @temp_files = []
+      @vagrant_hosts = vagrant_hosts
+
+      make_vfile @vagrant_hosts
+
+      #stop anything currently running, that way vagrant up will re-do networking on existing boxes
+      system("vagrant halt") 
+      system("vagrant up")
+
+      @logger.debug "configure vagrant boxes (set ssh-config, switch to root user, hack etc/hosts)"
+      @vagrant_hosts.each do |host|
+        default_user = host['user']
+
+        set_ssh_config host, 'vagrant'
+        
+        copy_ssh_to_root host
+        #shut down connection, will reconnect on next exec
+        host.close 
+
+        set_ssh_config host, default_user
+
+      end
+
+      hack_etc_hosts @vagrant_hosts
+    end
+
+    def cleanup
+      @logger.debug "removing temporory ssh-config files per-vagrant box"
+      @temp_files.each do |f|
+        f.close()
+      end
+      @logger.notify "Destroying vagrant boxes"
+      system("vagrant destroy --force")
+    end
+
+  end
+end

data/lib/beaker/hypervisor/vcloud.rb

@@ -0,0 +1,175 @@
+module Beaker 
+  class Vcloud < Beaker::Hypervisor
+
+    def initialize(vcloud_hosts, options, config)
+      @options = options
+      @config = config['CONFIG'].dup
+      @logger = options[:logger]
+      @vcloud_hosts = vcloud_hosts
+      require 'yaml' unless defined?(YAML)
+
+      raise 'You must specify a datastore for vCloud instances!' unless @config['datastore']
+      raise 'You must specify a resource pool for vCloud instances!' unless @config['resourcepool']
+      raise 'You must specify a folder for vCloud instances!' unless @config['folder']
+
+      vsphere_credentials = VsphereHelper.load_config
+
+      @logger.notify "Connecting to vSphere at #{vsphere_credentials[:server]}" +
+        " with credentials for #{vsphere_credentials[:user]}"
+
+      vsphere_helper = VsphereHelper.new( vsphere_credentials )
+      vsphere_vms = {}
+
+      attempts = 10
+
+      start = Time.now
+      @vcloud_hosts.each_with_index do |h, i|
+        # Generate a randomized hostname
+        o = [('a'..'z'),('0'..'9')].map{|r| r.to_a}.flatten
+        h['vmhostname'] = o[rand(25)] + (0...14).map{o[rand(o.length)]}.join
+
+        if h['template'] =~ /\//
+          templatefolders = h['template'].split('/')
+          h['template'] = templatefolders.pop
+        end
+
+        @logger.notify "Deploying #{h['vmhostname']} (#{h.name}) to #{@config['folder']} from template '#{h['template']}'"
+
+        vm = {}
+
+        if templatefolders
+          vm[h['template']] = vsphere_helper.find_folder(templatefolders.join('/')).find(h['template'])
+        else
+          vm = vsphere_helper.find_vms(h['template'])
+        end
+
+        if vm.length == 0
+          raise "Unable to find template '#{h['template']}'!"
+        end
+
+        # Add VM annotation
+        configSpec = RbVmomi::VIM.VirtualMachineConfigSpec(
+          :annotation =>
+            'Base template:  ' + h['template'] + "\n" +
+            'Creation time:  ' + Time.now.strftime("%Y-%m-%d %H:%M") + "\n\n" +
+            'CI build link:  ' + ( ENV['BUILD_URL'] || 'Deployed independently of CI' )
+        )
+
+        # Are we using a customization spec?
+        customizationSpec = vsphere_helper.find_customization( h['template'] )
+
+        if customizationSpec
+          # Print a logger message if using a customization spec
+          @logger.notify "Found customization spec for '#{h['template']}', will apply after boot"
+
+          # Using a customization spec takes longer, set a longer timeout
+          attempts = attempts * 2
+        end
+
+        # Put the VM in the specified folder and resource pool
+        relocateSpec = RbVmomi::VIM.VirtualMachineRelocateSpec(
+          :datastore    => vsphere_helper.find_datastore(@config['datastore']),
+          :pool         => vsphere_helper.find_pool(@config['resourcepool']),
+          :diskMoveType => :moveChildMostDiskBacking
+        )
+
+        # Create a clone spec
+        spec = RbVmomi::VIM.VirtualMachineCloneSpec(
+          :config        => configSpec,
+          :location      => relocateSpec,
+          :customization => customizationSpec,
+          :powerOn       => true,
+          :template      => false
+        )
+
+        # Deploy from specified template
+        if (@vcloud_hosts.length == 1) or (i == @vcloud_hosts.length - 1)
+          vm[h['template']].CloneVM_Task( :folder => vsphere_helper.find_folder(@config['folder']), :name => h['vmhostname'], :spec => spec ).wait_for_completion
+        else
+          vm[h['template']].CloneVM_Task( :folder => vsphere_helper.find_folder(@config['folder']), :name => h['vmhostname'], :spec => spec )
+        end
+      end
+      @logger.notify 'Spent %.2f seconds deploying VMs' % (Time.now - start)
+
+      start = Time.now
+      @vcloud_hosts.each_with_index do |h, i|
+        @logger.notify "Booting #{h['vmhostname']} (#{h.name}) and waiting for it to register with vSphere"
+        try = 1
+        last_wait = 0
+        wait = 1
+        until
+          vsphere_helper.find_vms(h['vmhostname'])[h['vmhostname']].summary.guest.toolsRunningStatus == 'guestToolsRunning' and
+          vsphere_helper.find_vms(h['vmhostname'])[h['vmhostname']].summary.guest.ipAddress != nil
+          if try <= attempts
+            sleep wait
+            (last_wait, wait) = wait, last_wait + wait
+            try += 1
+          else
+            raise "vSphere registration failed after #{wait} seconds"
+          end
+        end
+      end
+      @logger.notify "Spent %.2f seconds booting and waiting for vSphere registration" % (Time.now - start)
+
+      start = Time.now
+      @vcloud_hosts.each_with_index do |h, i|
+        @logger.notify "Waiting for #{h['vmhostname']} DNS resolution"
+        try = 1
+        last_wait = 0
+        wait = 3
+
+        begin
+          Socket.getaddrinfo(h['vmhostname'], nil)
+        rescue
+          if try <= attempts
+            sleep wait
+            (last_wait, wait) = wait, last_wait + wait
+            try += 1
+
+            retry
+          else
+            raise "DNS resolution failed after #{wait} seconds"
+          end
+        end
+      end
+      @logger.notify "Spent %.2f seconds waiting for DNS resolution" % (Time.now - start)
+
+      vsphere_helper.close 
+    end
+
+    def cleanup
+      @logger.notify "Destroying vCloud boxes"
+      vsphere_credentials = VsphereHelper.load_config
+
+      @logger.notify "Connecting to vSphere at #{vsphere_credentials[:server]}" +
+        " with credentials for #{vsphere_credentials[:user]}"
+
+      vsphere_helper = VsphereHelper.new( vsphere_credentials )
+
+      vm_names = @vcloud_hosts.map {|h| h['vmhostname'] }.compact
+      if @vcloud_hosts.length != vm_names.length
+        @logger.warn "Some hosts did not have vmhostname set correctly! This likely means VM provisioning was not successful"
+      end
+      vms = vsphere_helper.find_vms vm_names
+      vm_names.each do |name|
+        unless vm = vms[name]
+          raise "Couldn't find VM #{name} in vSphere!"
+        end
+
+        if vm.runtime.powerState == 'poweredOn'
+          @logger.notify "Shutting down #{vm.name}"
+          start = Time.now
+          vm.PowerOffVM_Task.wait_for_completion
+          @logger.notify "Spent %.2f seconds halting #{vm.name}" % (Time.now - start)
+        end
+
+        start = Time.now
+        vm.Destroy_Task
+        @logger.notify "Spent %.2f seconds destroying #{vm.name}" % (Time.now - start)
+      end
+
+      vsphere_helper.close
+    end
+
+  end
+end