示例#1
0
    def get_guest_free_mem(cls, vm):
        """
        Guest OS reported free memory size in MB.

        :param vm: VM Object
        :return: free memory report by guest OS in MB
        """
        os_type = vm.params.get("os_type")
        timeout = float(vm.params.get("login_timeout", 600))
        session = vm.wait_for_login(timeout=timeout)
        return utils_misc.get_free_mem(session, os_type)
示例#2
0
    def get_guest_free_mem(cls, vm):
        """
        Guest OS reported free memory size in MB.

        :param vm: VM Object
        :return: free memory report by guest OS in MB
        """
        os_type = vm.params.get("os_type")
        timeout = float(vm.params.get("login_timeout", 600))
        session = vm.wait_for_login(timeout=timeout)
        return utils_misc.get_free_mem(session, os_type)
示例#3
0
def run(test, params, env):
    """
    KVM guest stop test:
    1) Log into a guest
    2) Check is HeavyLoad.exe installed , download and
       install it if not installed.
    3) Start Heavyload to make guest in heavyload
    4) Check vm is alive
    5) Stop heavyload process and clean temp file.

    :param test: kvm test object
    :param params: Dictionary with the test parameters
    :param env: Dictionary with test environment.
    """

    def loop_session_cmd(session, cmd):
        def session_cmd(session, cmd):
            try:
                return session.cmd_status(cmd) == 0
            except (aexpect.ShellStatusError, aexpect.ShellTimeoutError):
                pass

        count = 0
        while count < 3:
            ret = session_cmd(session, cmd)
            if ret is not None:
                return ret
            count += 1
        return None

    def add_option(cmd, key, val):
        """
        Append options into command;
        """
        if re.match(r".*/%s.*", cmd, re.I):
            if val:
                rex = r"/%s\b+\S+\b+" % key
                val = "/%s %s " % (key, val)
                cmd = re.sub(rex, val, cmd, re.I)
        else:
            cmd += " /%s %s " % (key, val)
        return cmd

    tmp_dir = data_dir.get_tmp_dir()
    install_path = params["install_path"].rstrip("\\")
    heavyload_bin = '"%s\heavyload.exe"' % install_path
    start_cmd = "%s /CPU /MEMORY /FILE " % heavyload_bin
    stop_cmd = "taskkill /T /F /IM heavyload.exe"
    stop_cmd = params.get("stop_cmd", stop_cmd)
    start_cmd = params.get("start_cmd", start_cmd)
    check_running_cmd = "tasklist|findstr /I heavyload"
    check_running_cmd = params.get("check_running_cmd", check_running_cmd)
    test_installed_cmd = "dir '%s'|findstr /I heavyload" % install_path
    test_installed_cmd = params.get("check_installed_cmd", test_installed_cmd)

    vm = env.get_vm(params["main_vm"])
    vm.verify_alive()
    timeout = float(params.get("login_timeout", 240))
    session = vm.wait_for_login(timeout=timeout)
    try:
        installed = session.cmd_status(test_installed_cmd) == 0
        if not installed:
            download_url = params.get("download_url")
            if download_url:
                dst = r"c:\\"
                pkg_md5sum = params["pkg_md5sum"]
                error.context("Download HeavyLoadSetup.exe", logging.info)
                pkg = utils.unmap_url_cache(tmp_dir,
                                            download_url, pkg_md5sum)
                vm.copy_files_to(pkg, dst)
            else:
                dst = r"%s:\\" % utils_misc.get_winutils_vol(session)

            error.context("Install HeavyLoad in guest", logging.info)
            install_cmd = params["install_cmd"]
            install_cmd = re.sub(r"DRIVE:\\+", dst, install_cmd)
            session.cmd(install_cmd)
            config_cmd = params.get("config_cmd")
            if config_cmd:
                session.cmd(config_cmd)

        error.context("Start heavyload in guest", logging.info)
        # genery heavyload command automaticly
        if params.get("autostress") == "yes":
            free_mem = utils_misc.get_free_mem(session, "windows")
            free_disk = utils_misc.get_free_disk(session, "C:")
            start_cmd = '"%s\heavyload.exe"' % params["install_path"]
            start_cmd = add_option(start_cmd, 'CPU', params["smp"])
            start_cmd = add_option(start_cmd, 'MEMORY', free_mem)
            start_cmd = add_option(start_cmd, 'FILE', free_disk)
        else:
            start_cmd = params["start_cmd"]
        # reformat command to ensure heavyload started as except
        test_timeout = int(params.get("timeout", "60"))
        steping = 60
        if test_timeout < 60:
            logging.warn("Heavyload use minis as unit of timeout,"
                         "values is too small, use default: 60s")
            test_timeout = 60
            steping = 30
        test_timeout = test_timeout / 60
        start_cmd = add_option(start_cmd, 'DURATION', test_timeout)
        start_cmd = add_option(start_cmd, 'START', '')
        start_cmd = add_option(start_cmd, 'AUTOEXIT', '')
        logging.info("heavyload cmd: %s" % start_cmd)
        session.sendline(start_cmd)
        if not loop_session_cmd(session, check_running_cmd):
            raise error.TestError("heavyload process is not started")

        error.context("Verify vm is alive", logging.info)
        utils_misc.wait_for(vm.verify_alive,
                            timeout=test_timeout, step=steping)
    finally:
        error.context("Stop load and clean tmp files", logging.info)
        if not installed and download_url:
            utils.system("rm -f %s/HeavyLoad*.exe" % tmp_dir)
            session.cmd("del /f /s %sHeavyLoad*.exe" % dst)
        if loop_session_cmd(session, check_running_cmd):
            if not loop_session_cmd(session, stop_cmd):
                raise error.TestFail("Unable to terminate heavyload process")
        if session:
            session.close()
示例#4
0
def run(test, params, env):
    """
    Memory leak check after nic hotplug/hotunplug
    1) Boot a guest
    2) Check free memory
    3) Hotplug nic 100 times(windows) or add 300 vlan(linux)
    4) Hotunplug nic 100 times(windows) or del 300 vlan(linux)
    5) Check free memory again

    :param test: kvm test object.
    :param params: Dictionary with test parameters.
    :param env: Dictionary with the test environment.
    """

    params["start_vm"] = "yes"
    env_process.preprocess_vm(test, params, env, params["main_vm"])

    vm = env.get_vm(params["main_vm"])
    vm.verify_alive()
    timeout = int(params.get("login_timeout", 360))
    os_type = params.get("os_type")
    if os_type == "windows":
        session = vm.wait_for_login(timeout=timeout)
    else:
        session = vm.wait_for_serial_login(timeout=timeout)

    free_mem_before_nichotplug = utils_misc.get_free_mem(session, os_type)
    logging.info("Guest free memory before nic hotplug: %d",
                 free_mem_before_nichotplug)

    if os_type == "windows":
        error_context.context("Add network devices through monitor cmd",
                              logging.info)
        pci_model = params.get("pci_model")
        netdst = params.get("netdst", "virbr0")
        nettype = params.get("nettype", "bridge")
        for i in range(1, 100):
            nic_name = 'hotadded%s' % i
            vm.hotplug_nic(nic_model=pci_model,
                           nic_name=nic_name,
                           netdst=netdst,
                           nettype=nettype,
                           queues=params.get('queues'))
            time.sleep(3)
            vm.hotunplug_nic(nic_name)
            time.sleep(3)
    else:
        session.cmd("swapoff -a")
        mac = vm.get_mac_address()
        guest_nic = utils_net.get_linux_ifname(session, mac)
        for i in range(1, 300):
            session.cmd("ip link add link %s name %s.%s type vlan id %s" %
                        (guest_nic, guest_nic, i, i))
        time.sleep(3)
        for i in range(1, 300):
            session.cmd("ip link delete %s.%s" % (guest_nic, i))

    free_mem_after_nichotplug = utils_misc.get_free_mem(session, os_type)
    logging.info("Guest free memory after nic hotplug: %d",
                 free_mem_after_nichotplug)

    mem_reduced = free_mem_before_nichotplug - free_mem_after_nichotplug
    if (os_type == "windows" and mem_reduced > 1024) \
            or (os_type == "linux" and mem_reduced > 200):
        test.error("There might be memory leak after hotplug nic. "
                   "Memory reduced %d" % mem_reduced)
    error_context.context("Memory reduced = %d" % mem_reduced, logging.info)

    session.close()
示例#5
0
def run(test, params, env):
    """
    KVM guest stop test:
    1) Log into a guest
    2) Check is HeavyLoad.exe installed , download and
       install it if not installed.
    3) Start Heavyload to make guest in heavyload
    4) Check vm is alive
    5) Stop heavyload process and clean temp file.

    :param test: kvm test object
    :param params: Dictionary with the test parameters
    :param env: Dictionary with test environment.
    """
    def loop_session_cmd(session, cmd):
        def session_cmd(session, cmd):
            try:
                return session.cmd_status(cmd) == 0
            except (aexpect.ShellStatusError, aexpect.ShellTimeoutError):
                pass

        count = 0
        while count < 3:
            ret = session_cmd(session, cmd)
            if ret is not None:
                return ret
            count += 1
        return None

    def add_option(cmd, key, val):
        """
        Append options into command;
        """
        if re.match(r".*/%s.*", cmd, re.I):
            if val:
                rex = r"/%s\b+\S+\b+" % key
                val = "/%s %s " % (key, val)
                cmd = re.sub(rex, val, cmd, re.I)
        else:
            cmd += " /%s %s " % (key, val)
        return cmd

    tmp_dir = data_dir.get_tmp_dir()
    install_path = params["install_path"].rstrip("\\")
    heavyload_bin = '"%s\heavyload.exe"' % install_path
    start_cmd = "%s /CPU /MEMORY /FILE " % heavyload_bin
    stop_cmd = "taskkill /T /F /IM heavyload.exe"
    stop_cmd = params.get("stop_cmd", stop_cmd)
    start_cmd = params.get("start_cmd", start_cmd)
    check_running_cmd = "tasklist|findstr /I heavyload"
    check_running_cmd = params.get("check_running_cmd", check_running_cmd)
    test_installed_cmd = "dir '%s'|findstr /I heavyload" % install_path
    test_installed_cmd = params.get("check_installed_cmd", test_installed_cmd)

    vm = env.get_vm(params["main_vm"])
    vm.verify_alive()
    timeout = float(params.get("login_timeout", 240))
    session = vm.wait_for_login(timeout=timeout)
    try:
        installed = session.cmd_status(test_installed_cmd) == 0
        if not installed:
            download_url = params.get("download_url")
            if download_url:
                dst = r"c:\\"
                pkg_md5sum = params["pkg_md5sum"]
                error.context("Download HeavyLoadSetup.exe", logging.info)
                pkg = utils.unmap_url_cache(tmp_dir, download_url, pkg_md5sum)
                vm.copy_files_to(pkg, dst)
            else:
                dst = r"%s:\\" % utils_misc.get_winutils_vol(session)

            error.context("Install HeavyLoad in guest", logging.info)
            install_cmd = params["install_cmd"]
            install_cmd = re.sub(r"DRIVE:\\+", dst, install_cmd)
            session.cmd(install_cmd)
            config_cmd = params.get("config_cmd")
            if config_cmd:
                session.cmd(config_cmd)

        error.context("Start heavyload in guest", logging.info)
        # genery heavyload command automaticly
        if params.get("autostress") == "yes":
            free_mem = utils_misc.get_free_mem(session, "windows")
            free_disk = utils_misc.get_free_disk(session, "C:")
            start_cmd = '"%s\heavyload.exe"' % params["install_path"]
            start_cmd = add_option(start_cmd, 'CPU', params["smp"])
            start_cmd = add_option(start_cmd, 'MEMORY', free_mem)
            start_cmd = add_option(start_cmd, 'FILE', free_disk)
        else:
            start_cmd = params["start_cmd"]
        # reformat command to ensure heavyload started as except
        test_timeout = int(params.get("timeout", "60"))
        steping = 60
        if test_timeout < 60:
            logging.warn("Heavyload use minis as unit of timeout,"
                         "values is too small, use default: 60s")
            test_timeout = 60
            steping = 30
        test_timeout = test_timeout / 60
        start_cmd = add_option(start_cmd, 'DURATION', test_timeout)
        start_cmd = add_option(start_cmd, 'START', '')
        start_cmd = add_option(start_cmd, 'AUTOEXIT', '')
        logging.info("heavyload cmd: %s" % start_cmd)
        session.sendline(start_cmd)
        if not loop_session_cmd(session, check_running_cmd):
            raise error.TestError("heavyload process is not started")

        sleep_before_migration = int(params.get("sleep_before_migration", "0"))
        time.sleep(sleep_before_migration)

        error.context("Verify vm is alive", logging.info)
        utils_misc.wait_for(vm.verify_alive,
                            timeout=test_timeout,
                            step=steping)
    finally:
        # in migration test, no need to stop heavyload on src host
        cleanup_in_the_end = params.get("unload_stress_in_the_end", "yes")
        if cleanup_in_the_end == "yes":
            error.context("Stop load and clean tmp files", logging.info)
            if not installed and download_url:
                utils.system("rm -f %s/HeavyLoad*.exe" % tmp_dir)
                session.cmd("del /f /s %sHeavyLoad*.exe" % dst)
            if loop_session_cmd(session, check_running_cmd):
                if not loop_session_cmd(session, stop_cmd):
                    raise error.TestFail("Unable to terminate heavyload "
                                         "process")
        if session:
            session.close()
示例#6
0
def run(test, params, env):
    """
    KVM guest stop test:
    1) Log into a guest
    2) Check is HeavyLoad.exe installed , download and
       install it if not installed.
    3) Start Heavyload to make guest in heavyload
    4) Check vm is alive
    5) Stop heavyload process and clean temp file.

    :param test: kvm test object
    :param params: Dictionary with the test parameters
    :param env: Dictionary with test environment.
    """
    def loop_session_cmd(session, cmd):
        def session_cmd(session, cmd):
            try:
                return session.cmd_status(cmd) == 0
            except (aexpect.ShellStatusError, aexpect.ShellTimeoutError):
                pass

        count = 0
        while count < 3:
            ret = session_cmd(session, cmd)
            if ret is not None:
                return ret
            count += 1
        return None

    def add_option(cmd, key, val):
        """
        Append options into command;
        """
        if re.match(r".*/%s.*", cmd, re.I):
            if val:
                rex = r"/%s\b+\S+\b+" % key
                val = "/%s %s " % (key, val)
                cmd = re.sub(rex, val, cmd, re.I)
        else:
            cmd += " /%s %s " % (key, val)
        return cmd

    tmp_dir = data_dir.get_tmp_dir()
    install_path = params["install_path"].rstrip("\\")
    heavyload_bin = r'"%s\heavyload.exe"' % install_path
    start_cmd = "%s /CPU /MEMORY /FILE " % heavyload_bin
    stop_cmd = "taskkill /T /F /IM heavyload.exe"
    stop_cmd = params.get("stop_cmd", stop_cmd)
    start_cmd = params.get("start_cmd", start_cmd)
    check_running_cmd = "tasklist|findstr /I heavyload"
    check_running_cmd = params.get("check_running_cmd", check_running_cmd)
    test_installed_cmd = 'dir "%s"|findstr /I heavyload' % install_path
    test_installed_cmd = params.get("check_installed_cmd", test_installed_cmd)

    vm = env.get_vm(params["main_vm"])
    vm.verify_alive()
    timeout = float(params.get("login_timeout", 240))
    session = vm.wait_for_login(timeout=timeout)

    installed = session.cmd_status(test_installed_cmd) == 0
    if not installed:
        download_url = params.get("download_url")
        if download_url:
            dst = r"c:\\"
            pkg_md5sum = params["pkg_md5sum"]
            error_context.context("Download HeavyLoadSetup.exe", test.log.info)
            pkg_name = os.path.basename(download_url)
            pkg_path = os.path.join(tmp_dir, pkg_name)
            download.get_file(download_url, pkg_path, hash_expected=pkg_md5sum)
            vm.copy_files_to(pkg_path, dst)
        else:
            dst = r"%s:\\" % utils_misc.get_winutils_vol(session)

        error_context.context("Install HeavyLoad in guest", test.log.info)
        install_cmd = params["install_cmd"]
        install_cmd = re.sub(r"DRIVE:\\+", dst, install_cmd)
        session.cmd(install_cmd)
        config_cmd = params.get("config_cmd")
        if config_cmd:
            session.cmd(config_cmd)

    error_context.context("Start heavyload in guest", test.log.info)
    # genery heavyload command automaticly
    if params.get("autostress") == "yes":
        free_mem = utils_misc.get_free_mem(session, "windows")
        free_disk = utils_misc.get_free_disk(session, "C:")
        start_cmd = r'"%s\heavyload.exe"' % params["install_path"]
        start_cmd = add_option(start_cmd, 'CPU', vm.cpuinfo.smp)
        start_cmd = add_option(start_cmd, 'MEMORY', free_mem)
        start_cmd = add_option(start_cmd, 'FILE', free_disk)
    else:
        start_cmd = params["start_cmd"]
    # reformat command to ensure heavyload started as except
    test_timeout = int(params.get("timeout", "60"))
    steping = 60
    if test_timeout < 60:
        test.log.warn(
            "Heavyload use mins as unit of timeout, given timeout "
            "is too small (%ss), force set to 60s", test_timeout)
        test_timeout = 60
        steping = 30
    start_cmd = add_option(start_cmd, 'DURATION', test_timeout / 60)
    start_cmd = add_option(start_cmd, 'START', '')
    start_cmd = add_option(start_cmd, 'AUTOEXIT', '')
    test.log.info("heavyload cmd: %s", start_cmd)
    session.sendline(start_cmd)
    if not loop_session_cmd(session, check_running_cmd):
        test.error("heavyload process is not started")

    sleep_before_migration = int(params.get("sleep_before_migration", "0"))
    time.sleep(sleep_before_migration)

    error_context.context("Verify vm is alive", test.log.info)
    utils_misc.wait_for(vm.verify_alive,
                        timeout=test_timeout * 1.2,
                        step=steping)

    if not session.cmd_status(check_running_cmd):
        test.fail("heavyload doesn't exist normally")
    if session:
        session.close()
def run(test, params, env):
    """
    Memory leak check after nic hotplug/hotunplug
    1) Boot a guest
    2) Check free memory
    3) Hotplug nic 100 times(windows) or add 300 vlan(linux)
    4) Hotunplug nic 100 times(windows) or del 300 vlan(linux)
    5) Check free memory again

    :param test: kvm test object.
    :param params: Dictionary with test parameters.
    :param env: Dictionary with the test environment.
    """

    params["start_vm"] = "yes"
    env_process.preprocess_vm(test, params, env, params["main_vm"])

    vm = env.get_vm(params["main_vm"])
    vm.verify_alive()
    timeout = int(params.get("login_timeout", 360))
    session = vm.wait_for_serial_login(timeout=timeout)
    os_type = params.get("os_type")

    free_mem_before_nichotplug = utils_misc.get_free_mem(session,
                                                         os_type)
    logging.info("Guest free memory before nic hotplug: %d",
                 free_mem_before_nichotplug)

    if os_type == "windows":
        error_context.context("Add network devices through monitor cmd",
                              logging.info)
        pci_model = params.get("pci_model")
        netdst = params.get("netdst", "virbr0")
        nettype = params.get("nettype", "bridge")
        for i in range(1, 100):
            nic_name = 'hotadded%s' % i
            vm.hotplug_nic(nic_model=pci_model, nic_name=nic_name,
                           netdst=netdst, nettype=nettype,
                           queues=params.get('queues'))
            time.sleep(3)
            vm.hotunplug_nic(nic_name)
            time.sleep(3)
    else:
        session.cmd("swapoff -a")
        mac = vm.get_mac_address()
        guest_nic = utils_net.get_linux_ifname(session, mac)
        for i in range(1, 300):
            session.cmd("ip link add link %s %s.%s type vlan id %s" %
                        (guest_nic, guest_nic, i, i))
        time.sleep(3)
        for i in range(1, 300):
            session.cmd("ip link delete %s.%s" %
                        (guest_nic, i))

    free_mem_after_nichotplug = utils_misc.get_free_mem(session,
                                                        os_type)
    logging.info("Guest free memory after nic hotplug: %d",
                 free_mem_after_nichotplug)

    mem_reduced = free_mem_before_nichotplug - free_mem_after_nichotplug
    if (os_type == "windows" and mem_reduced > 1024) \
            or (os_type == "linux" and mem_reduced > 200):
        test.error("There might be memory leak after hotplug nic. "
                   "Memory reduced %d" % mem_reduced)
    error_context.context("Memory reduced = %d" % mem_reduced,
                          logging.info)

    session.close()