beaker 0.0.0 → 1.0.0

data/lib/beaker/hypervisor/fusion.rb

@@ -1,7 +1,7 @@
 module Beaker 
   class Fusion < Beaker::Hypervisor
 
-  def initialize(fusion_hosts, options, config)
+    def initialize(fusion_hosts, options)
       require 'rubygems' unless defined?(Gem)
       begin
         require 'fission'
@@ -10,16 +10,17 @@ module Beaker
       end
       @logger = options[:logger]
       @options = options
-      @config = config['CONFIG'].dup
       @fusion_hosts = fusion_hosts
+      @fission = Fission::VM
+    end
 
-
-      available = Fission::VM.all.data.collect{|vm| vm.name}.sort.join(", ")
+    def provision
+      available = @fission.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
+        vm = @fission.new vm_name
         raise "Could not find VM '#{vm_name}' for #{host.name}!" unless vm.exists?
 
         available_snapshots = vm.snapshots.data.sort.join(", ")
@@ -46,11 +47,11 @@ module Beaker
         time = Time.now - start
         @logger.notify "Spent %.2f seconds resuming VM" % time
       end
-    end #revert_fusion
+      end #revert_fusion
 
-    def cleanup
-      @logger.notify "No cleanup for fusion boxes"
-    end
+      def cleanup
+        @logger.notify "No cleanup for fusion boxes"
+      end
 
-end
+  end
 end

data/lib/beaker/hypervisor/solaris.rb

@@ -1,44 +1,38 @@
-module Beaker 
+module Beaker
   class Solaris < Beaker::Hypervisor
 
-    def initialize(solaris_hosts, options, config)
+    def initialize(solaris_hosts, options)
       @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') )
+      @fog_file = nil
+      if File.exists?( @options[:dot_fog] )
+        @fog_file = YAML.load_file( @options[:dot_fog] )
       end
-      raise "Cant load ~/.fog config" unless fog_file
+      raise "Cant load #{@options[:dot_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]
+    end
+
+    def provision
+      hypername = @fog_file[:default][:solaris_hypervisor_server] 
+      vmpath    = @fog_file[:default][:solaris_hypervisor_vmpath]
+      snappaths = @fog_file[:default][:solaris_hypervisor_snappaths]
 
-      hyperconf = {
-        'HOSTS'  => {
+      hyperopts = @options.dup
+      hyperopts['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 )
+      hypervisor = Beaker::Host.create( hypername, hyperopts )
+      hypervisor[:user] = @fog_file[:default][:solaris_hypervisor_username] || hypervisor[:user]
+      hypervisor[:ssh][:keys] = [@fog_file[:default][:solaris_hypervisor_keyfile]] || hypervisor[:ssh][:keys]
 
       @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}"))

data/lib/beaker/hypervisor/vagrant.rb

@@ -1,3 +1,5 @@
+require 'open3'
+
 module Beaker 
   class Vagrant < Beaker::Hypervisor
 
@@ -9,11 +11,11 @@ module Beaker
     end
 
     def rand_chunk
-      (1 + rand(253)).to_s #don't want a 0 or a 255
+      (2 + rand(252)).to_s #don't want a 0, 1, or a 255
     end
     
     def randip
-      "192.168.#{rand_chunk}.#{rand_chunk}"
+      "10.255.#{rand_chunk}.#{rand_chunk}"
     end
 
     def make_vfile hosts
@@ -27,7 +29,7 @@ module Beaker
         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 << "    v.vm.network :private_network, ip: \"#{host['ip'].to_s}\", :netmask => \"255.255.0.0\"\n"
         vagrant_file << "  end\n"
         @logger.debug "created Vagrantfile for VagrantHost #{host.name}"
       end
@@ -35,9 +37,10 @@ module Beaker
       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()
+      FileUtils.mkdir_p(@vagrant_path)
+      File.open(File.expand_path(File.join(@vagrant_path, "Vagrantfile")), 'w') do |f|
+        f.write(vagrant_file)
+      end
     end
 
     def hack_etc_hosts hosts
@@ -62,7 +65,10 @@ module Beaker
 
     def set_ssh_config host, user
         f = Tempfile.new("#{host.name}")
-        ssh_config = `vagrant ssh-config #{host.name}`
+        ssh_config = Dir.chdir(@vagrant_path) do
+          stdin, stdout = Open3.popen3('vagrant', 'ssh-config', host.name)
+          stdout.read
+        end
         #replace hostname with ip
         ssh_config = ssh_config.gsub(/#{host.name}/, host['ip']) 
         #set the user 
@@ -74,19 +80,22 @@ module Beaker
         @temp_files << f
     end
 
-    def initialize(vagrant_hosts, options, config)
+    def initialize(vagrant_hosts, options)
       require 'tempfile'
       @options = options
-      @config = config['CONFIG'].dup
       @logger = options[:logger]
       @temp_files = []
       @vagrant_hosts = vagrant_hosts
+      @vagrant_path = File.expand_path(File.join(File.basename(__FILE__), '..', 'vagrant_files', options[:hosts_file]))
+
+    end
 
+    def provision
       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")
+      vagrant_cmd("halt")
+      vagrant_cmd("up")
 
       @logger.debug "configure vagrant boxes (set ssh-config, switch to root user, hack etc/hosts)"
       @vagrant_hosts.each do |host|
@@ -111,7 +120,13 @@ module Beaker
         f.close()
       end
       @logger.notify "Destroying vagrant boxes"
-      system("vagrant destroy --force")
+      vagrant_cmd("destroy --force")
+    end
+
+    def vagrant_cmd(args)
+      Dir.chdir(@vagrant_path) do
+        system("vagrant #{args}")
+      end
     end
 
   end

data/lib/beaker/hypervisor/vcloud.rb

@@ -1,174 +1,190 @@
+require 'yaml' unless defined?(YAML)
+
 module Beaker 
   class Vcloud < Beaker::Hypervisor
+    CHARMAP = [('a'..'z'),('0'..'9')].map{|r| r.to_a}.flatten
 
-    def initialize(vcloud_hosts, options, config)
+    def initialize(vcloud_hosts, options)
       @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
+      raise 'You must specify a datastore for vCloud instances!' unless @options['datastore']
+      raise 'You must specify a resource pool for vCloud instances!' unless @options['resourcepool']
+      raise 'You must specify a folder for vCloud instances!' unless @options['folder']
+      @vsphere_credentials = VsphereHelper.load_config(@options[:dot_fog])
+    end
 
-        if h['template'] =~ /\//
-          templatefolders = h['template'].split('/')
-          h['template'] = templatefolders.pop
-        end
+    def connect_to_vsphere
+      @logger.notify "Connecting to vSphere at #{@vsphere_credentials[:server]}" +
+        " with credentials for #{@vsphere_credentials[:user]}"
 
-        @logger.notify "Deploying #{h['vmhostname']} (#{h.name}) to #{@config['folder']} from template '#{h['template']}'"
+      @vsphere_helper = VsphereHelper.new( @vsphere_credentials )
+    end
 
-        vm = {}
+    def wait_for_dns_resolution host, try, attempts
+      @logger.notify "Waiting for #{host['vmhostname']} DNS resolution"
+      begin
+        Socket.getaddrinfo(host['vmhostname'], nil)
+      rescue
+        if try <= attempts
+          sleep 5
+          try += 1
 
-        if templatefolders
-          vm[h['template']] = vsphere_helper.find_folder(templatefolders.join('/')).find(h['template'])
+          retry
         else
-          vm = vsphere_helper.find_vms(h['template'])
+          raise "DNS resolution failed after #{@options[:timeout].to_i} seconds"
         end
+      end
+    end
 
-        if vm.length == 0
-          raise "Unable to find template '#{h['template']}'!"
+    def booting_host host, try, attempts
+      @logger.notify "Booting #{host['vmhostname']} (#{host.name}) and waiting for it to register with vSphere"
+      until
+        @vsphere_helper.find_vms(host['vmhostname'])[host['vmhostname']].summary.guest.toolsRunningStatus == 'guestToolsRunning' and
+        @vsphere_helper.find_vms(host['vmhostname'])[host['vmhostname']].summary.guest.ipAddress != nil
+        if try <= attempts
+          sleep 5
+          try += 1
+        else
+          raise "vSphere registration failed after #{@options[:timeout].to_i} seconds"
         end
+      end
+    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
+    def generate_host_name
+      CHARMAP[rand(25)] + (0...14).map{CHARMAP[rand(CHARMAP.length)]}.join
+    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
+    def create_clone_spec host
+      # Add VM annotation
+      configSpec = RbVmomi::VIM.VirtualMachineConfigSpec(
+        :annotation =>
+          'Base template:  ' + host['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( host['template'] )
+
+      if customizationSpec
+        # Print a logger message if using a customization spec
+        @logger.notify "Found customization spec for '#{host['template']}', will apply after boot"
       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"
+      # Put the VM in the specified folder and resource pool
+      relocateSpec = RbVmomi::VIM.VirtualMachineRelocateSpec(
+        :datastore    => @vsphere_helper.find_datastore(@options['datastore']),
+        :pool         => @vsphere_helper.find_pool(@options['resourcepool']),
+        :diskMoveType => :moveChildMostDiskBacking
+      )
+
+      # Create a clone spec
+      spec = RbVmomi::VIM.VirtualMachineCloneSpec(
+        :config        => configSpec,
+        :location      => relocateSpec,
+        :customization => customizationSpec,
+        :powerOn       => true,
+        :template      => false
+      )
+      spec
+    end
+
+    def provision
+      connect_to_vsphere
+      begin
+        vsphere_vms = {}
+  
         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
+        attempts = @options[:timeout].to_i / 5
+  
+        start = Time.now
+        tasks = []
+        @vcloud_hosts.each_with_index do |h, i|
+          # Generate a randomized hostname
+          h['vmhostname'] = generate_host_name
+  
+          if h['template'] =~ /\//
+            templatefolders = h['template'].split('/')
+            h['template'] = templatefolders.pop
+          end
+  
+          @logger.notify "Deploying #{h['vmhostname']} (#{h.name}) to #{@options['folder']} from template '#{h['template']}'"
+  
+          vm = {}
+  
+          if templatefolders
+            vm[h['template']] = @vsphere_helper.find_folder(templatefolders.join('/')).find(h['template'])
           else
-            raise "vSphere registration failed after #{wait} seconds"
+            vm = @vsphere_helper.find_vms(h['template'])
           end
+  
+          if vm.length == 0
+            raise "Unable to find template '#{h['template']}'!"
+          end
+  
+          spec = create_clone_spec(h)
+  
+          # Deploy from specified template
+          tasks << vm[h['template']].CloneVM_Task( :folder => @vsphere_helper.find_folder(@options['folder']), :name => h['vmhostname'], :spec => spec )
         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"
+        try = (Time.now - start) / 5
+        @vsphere_helper.wait_for_tasks(tasks, try, attempts)
+        @logger.notify 'Spent %.2f seconds deploying VMs' % (Time.now - start)
+  
+        try = (Time.now - start) / 5
+        duration = run_and_report_duration do 
+          @vcloud_hosts.each_with_index do |h, i|
+            booting_host(h, try, attempts)
           end
         end
+        @logger.notify "Spent %.2f seconds booting and waiting for vSphere registration" % duration
+  
+        try = (Time.now - start) / 5
+        duration = run_and_report_duration do
+          @vcloud_hosts.each_with_index do |h, i|
+            wait_for_dns_resolution(h, try, attempts)
+          end
+        end
+        @logger.notify "Spent %.2f seconds waiting for DNS resolution" % duration
+      rescue => e
+        @vsphere_helper.close 
+        report_and_raise(@logger, e, "Vcloud.provision")
       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!"
+      connect_to_vsphere
+      begin
+        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
-
-        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)
+        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}"
+            duration = run_and_report_duration do
+              vm.PowerOffVM_Task.wait_for_completion
+            end
+            @logger.notify "Spent %.2f seconds halting #{vm.name}" % duration
+          end
+  
+          duration = run_and_report_duration do 
+            vm.Destroy_Task
+          end
+          @logger.notify "Spent %.2f seconds destroying #{vm.name}" % duration
         end
-
-        start = Time.now
-        vm.Destroy_Task
-        @logger.notify "Spent %.2f seconds destroying #{vm.name}" % (Time.now - start)
+      rescue => e
+        @vsphere_helper.close
+        report_and_raise(@logger, e, "Vcloud.cleanup")
       end
-
-      vsphere_helper.close
     end
 
   end