new file mode 100644
@@ -0,0 +1,165 @@
+import sys, os, time, logging, commands, socket
+from autotest_lib.client.bin import test
+from autotest_lib.client.common_lib import error
+import kvm_utils, kvm_preprocessing, common, kvm_vm, kvm_test_utils
+
+
+class kvm_migration(test.test):
+ """
+ KVM migration test.
+
+ @copyright: Red Hat 2008-2009
+ @see: http://www.linux-kvm.org/page/KVM-Autotest/Client_Install
+ (Online doc - Getting started with KVM testing)
+
+ Migration execution progress:
+
+ source host dest host
+ ------------------------------------------------------------------
+ log into guest
+ ------------------------------------------------------------------
+ start socket server
+
+ ---- wait 30 secs -------------- wait login_timeout+30 secs-------
+
+ accept connection connect to socket server,send mig_port
+ ------------------------------------------------------------------
+ start migration
+
+ ---- wait 30 secs -------------- wait mig_timeout+30 secs---------
+
+ try to log into migrated guest
+ ------------------------------------------------------------------
+
+ """
+ version = 1
+ def initialize(self):
+ pass
+
+
+ def run_once(self, params):
+ """
+ Setup remote machine and then execute migration.
+ """
+ # Check whether remote machine is ready
+ dsthost = params.get("dsthost")
+ srchost = params.get("srchost")
+ image_path = os.path.join(self.bindir, "images")
+
+ rootdir = params.get("rootdir")
+ iso = os.path.join(rootdir, 'iso')
+ images = os.path.join(rootdir, 'images')
+ qemu = os.path.join(rootdir, 'qemu')
+ qemu_img = os.path.join(rootdir, 'qemu-img')
+
+ def link_if_not_exist(ldir, target, link_name):
+ t = target
+ l = os.path.join(ldir, link_name)
+ if not os.path.exists(l):
+ os.symlink(t,l)
+ link_if_not_exist(self.bindir, '../../', 'autotest')
+ link_if_not_exist(self.bindir, iso, 'isos')
+ link_if_not_exist(self.bindir, images, 'images')
+ link_if_not_exist(self.bindir, qemu, 'qemu')
+ link_if_not_exist(self.bindir, qemu_img, 'qemu-img')
+
+ # Report the parameters we've received and write them as keyvals
+ logging.debug("Test parameters:")
+ keys = params.keys()
+ keys.sort()
+ for key in keys:
+ logging.debug(" %s = %s", key, params[key])
+ self.write_test_keyval({key: params[key]})
+
+ # Open the environment file
+ env_filename = os.path.join(self.bindir, params.get("env", "env"))
+ env = kvm_utils.load_env(env_filename, {})
+ logging.debug("Contents of environment: %s" % str(env))
+
+ # Preprocess
+ kvm_preprocessing.preprocess(self, params, env)
+ kvm_utils.dump_env(env, env_filename)
+
+ try:
+ try:
+ # Get the living VM
+ vm = kvm_test_utils.get_living_vm(env, params.get("main_vm"))
+ migration_test_command = params.get("migration_test_command")
+ login_timeout = int(params.get("login_timeout"))
+ mig_timeout = int(params.get("mig_timeout"))
+ source_addr = (srchost, 50006)
+ all = [srchost, dsthost]
+
+ # Check whether migration is supported
+ s, o = vm.send_monitor_cmd("help info")
+ if not "info migrate" in o:
+ raise error.TestError("Migration is not supported")
+
+ if params.get("role") == "source":
+
+ session = kvm_test_utils.wait_for_login(vm,
+ timeout=login_timeout)
+ ref_output = session.get_command_output(migration_test_command)
+
+
+ # Listen on a port to get the migration port received from
+ # dest machine
+ s = socket.socket()
+ s.bind(source_addr)
+ s.listen(1)
+
+ # Wait 30 seconds for source and dest to reach this point
+ self.job.barrier(srchost,'socket_started',30).rendezvous(*all)
+
+ conn, addr = s.accept()
+ mig_port = int(conn.recv(6))
+ s.close()
+
+ logging.info("Start migrating now...")
+ kvm_test_utils.migrate(vm, dsthost, mig_port, env)
+
+ # Wait up to 30 seconds for dest to reach this point
+ self.job.barrier(srchost,'mig_finished',30).rendezvous(*all)
+
+ session.close()
+
+ elif params.get("role") == "dest":
+
+ # Wait up to login_timeout+30 seconds for the source to
+ # reach this point
+ self.job.barrier(dsthost, 'socket_started',
+ login_timeout+30).rendezvous(*all)
+
+ s = socket.socket()
+ s.connect(source_addr)
+ s.send("%d" % vm.migration_port)
+ s.close()
+
+ # Wait up to mig_timeout+30 seconds for the source to
+ # reach this point: migration finished
+ self.job.barrier(dsthost, 'mig_finished',
+ mig_timeout+30).rendezvous(*all)
+
+ try:
+ session = kvm_test_utils.wait_for_login(vm)
+ except:
+ raise error.TestFail("Could not log into migrated guest")
+
+ if session.get_command_status(migration_test_command) != 0:
+ raise error.TestFail("migration_test_command failed!")
+
+ else:
+ raise error.TestError('Invalid role specified')
+
+ except Exception, e:
+ logging.error("Test failed: %s", e)
+ logging.debug("Postprocessing on error...")
+ kvm_preprocessing.postprocess_on_error(self, params, env)
+ kvm_utils.dump_env(env, env_filename)
+ raise
+
+ finally:
+ # Postprocess
+ kvm_preprocessing.postprocess(self, params, env)
+ logging.debug("Contents of environment: %s", str(env))
+ kvm_utils.dump_env(env, env_filename)
@@ -106,7 +106,7 @@ def reboot(vm, session, method="shell", sleep_before_reset=10, nic_index=0,
return session
-def migrate(vm, env=None):
+def migrate(vm, rem_host, rem_port, env=None, mig_timeout=90):
"""
Migrate a VM locally and re-register it in the environment.
@@ -133,13 +133,14 @@ def migrate(vm, env=None):
if not "info migrate" in o:
raise error.TestError("Migration is not supported")
- # Clone the source VM and ask the clone to wait for incoming migration
- dest_vm = vm.clone()
- dest_vm.create(for_migration=True)
+ if rem_host == "localhost":
+ # Clone the source VM and ask the clone to wait for incoming migration
+ dest_vm = vm.clone()
+ dest_vm.create(for_migration=True)
try:
# Define the migration command
- cmd = "migrate -d tcp:localhost:%d" % dest_vm.migration_port
+ cmd = "migrate -d tcp:%s:%d" % (rem_host, rem_port)
logging.debug("Migrating with command: %s" % cmd)
# Migrate
@@ -150,7 +151,7 @@ def migrate(vm, env=None):
raise error.TestFail("Migration command failed")
# Wait for migration to finish
- if not kvm_utils.wait_for(mig_finished, 90, 2, 2,
+ if not kvm_utils.wait_for(mig_finished, mig_timeout, 2, 2,
"Waiting for migration to finish..."):
raise error.TestFail("Timeout elapsed while waiting for migration "
"to finish")
@@ -166,15 +167,17 @@ def migrate(vm, env=None):
# Kill the source VM
vm.destroy(gracefully=False)
- # Replace the source VM with the new cloned VM
- if env is not None:
- kvm_utils.env_register_vm(env, vm.name, dest_vm)
+ if rem_host == "localhost":
+ # Replace the source VM with the new cloned VM
+ if env is not None:
+ kvm_utils.env_register_vm(env, vm.name, dest_vm)
- # Return the new cloned VM
- return dest_vm
+ # Return the new cloned VM
+ return dest_vm
except:
- dest_vm.destroy()
+ if rem_host == "localhost":
+ dest_vm.destroy()
raise
@@ -81,6 +81,8 @@ variants:
migration_bg_command = "cd /tmp; nohup tcpdump -q -t ip host localhost"
migration_bg_check_command = pgrep tcpdump
migration_bg_kill_command = pkill tcpdump
+ mig_timeout = 90
+ login_timeout = 240
kill_vm_on_error = yes
iterations = 2
used_mem = 1024
new file mode 120000
@@ -0,0 +1 @@
+kvm
\ No newline at end of file
new file mode 100644
@@ -0,0 +1,137 @@
+AUTHOR = "Yolkfull Chow <yzhou@redhat.com>"
+TIME = "SHORT"
+NAME = "Migration across Multi-machine"
+TEST_CATEGORY = "Functional"
+TEST_CLASS = 'Virtualization'
+TEST_TYPE = "Server"
+DOC = """
+Migrate KVM guest between two hosts.
+
+Arguments to run_test:
+
+@dict - a dictionary containing all parameters that migration need.
+"""
+
+import sys, os, commands, glob, shutil
+from autotest_lib.server import utils
+
+AUTOTEST_DIR = '/root/devel/upstream/server-migration'
+
+CLIENT_TEST_DIR = os.path.join(AUTOTEST_DIR, 'client/tests/')
+KVM_DIR = os.path.join(CLIENT_TEST_DIR, 'kvm')
+
+sample_files = glob.glob(os.path.join(KVM_DIR, '*.cfg.sample'))
+for sample_file in sample_files:
+ sample_file_name = os.path.basename(sample_file)
+ cfg_file_name = ".".join(sample_file_name.split(".")[:-1])
+ cfg_file_path = os.path.join(KVM_DIR, cfg_file_name)
+ sample_file_path = os.path.join(KVM_DIR, sample_file)
+ shutil.copyfile(sample_file_path, cfg_file_path)
+
+sys.path.append(KVM_DIR)
+import common, kvm_config
+
+rootdir = '/tmp/kvm_autotest_root'
+
+def run(pair):
+ print "KVM migration running on srchost [%s] and desthost [%s]\n" % (
+ pair[0], pair[1])
+
+ # Edit this to limit the migration that you want
+ test_variants = """
+only full
+only qcow2
+only ide
+only default
+only up
+only Fedora.11.32
+no install setup
+no hugepages
+only migrate
+only rtl8139
+"""
+
+ source = hosts.create_host(pair[0])
+ dest = hosts.create_host(pair[1])
+
+ source_at = autotest.Autotest(source)
+ source_at.install(source)
+ dest_at = autotest.Autotest(dest)
+ dest_at.install(dest)
+
+ # FIXME: should parse config file on client machines?
+ filename = os.path.join(KVM_DIR, "kvm_tests.cfg.sample")
+ sample_f = open(filename, 'r')
+ new_contents = sample_f.readlines()[:-1]
+ sample_f.close()
+
+ new_contents = "".join(new_contents)
+ new_contents += test_variants
+
+ filename = os.path.join(KVM_DIR, 'kvm_tests.cfg')
+ f = open(filename, 'w')
+ f.write(new_contents)
+ f.close()
+
+ if not os.path.exists(filename):
+ print "[ERROR] Test config file doesn't found"
+ sys.exit(1)
+
+ # Get test set (dictionary list) from the configuration file
+ cfg = kvm_config.config(filename)
+
+ filename = os.path.join(KVM_DIR, "kvm_address_pools.cfg")
+ if os.path.exists(filename):
+ cfg.parse_file(filename)
+ hostname = os.uname()[1].split(".")[0]
+ if cfg.filter("^" + hostname):
+ cfg.parse_string("only ^%s" % hostname)
+ else:
+ cfg.parse_string("only ^default_host")
+
+ list = cfg.get_list()
+
+ # Control file template for client machine
+ control_string = "job.run_test('kvm_migration', params=%s)"
+
+ for vm_dict in list:
+
+ vm_dict['srchost'] = source.ip
+ vm_dict['dsthost'] = dest.ip
+ vm_dict['display'] = 'vnc'
+ vm_dict['rootdir'] = rootdir
+
+ source_dict = vm_dict.copy()
+ dest_dict = vm_dict.copy()
+
+ source_dict['role'] = "source"
+
+ dest_dict['role'] = "dest"
+ dest_dict['start_vm_for_migration'] = "yes"
+
+ # Report the parameters we've received
+ print "Test parameters:"
+ keys = vm_dict.keys()
+ keys.sort()
+ for key in keys:
+ print " " + str(key) + " = " + str(vm_dict[key])
+
+ source_control_file = ''.join([control_string % source_dict])
+ dest_control_file = ''.join([control_string % dest_dict])
+
+ dest_command = subcommand(dest_at.run,
+ [dest_control_file, dest.hostname])
+ source_command = subcommand(source_at.run,
+ [source_control_file, source.hostname])
+
+ parallel([dest_command, source_command])
+
+# Grab the pairs (and failures)
+(pairs, failures) = utils.form_ntuples_from_machines(machines, 2)
+
+# Log the failures
+for failure in failures:
+ job.record("FAIL", failure[0], "kvm", failure[1])
+
+# Now run through each pair and run
+job.parallel_simple(run, pairs, log=False)