def run_selenium(self): """ fake to run the full lifecycle flow of this deployment """ lh.section("Runner of type {0}".format(str(self.name)), "<3") self.old_installer.load_config() self.old_installer.caclulate_file_locations() self.basecfg.set_directories(self.old_installer.cfg) if self.do_starter_test: lh.section("PREPARING DEPLOYMENT of {0}".format(str(self.name)), ) self.starter_prepare_env() self.finish_setup() # create the instances... for starter in self.starter_instances: # attach the PID of the starter instance: starter.attach_running_starter() # find out about its processes: starter.detect_instances() print(self.starter_instances) self.selenium.connect_server(self.get_frontend_instances(), '_system', self.cfg) self.selenium.check_old(self.old_installer.cfg) if self.new_installer: self.versionstr = "NEW[" + self.new_cfg.version + "] " lh.section("UPGRADE OF DEPLOYMENT {0}".format(str(self.name)), ) self.cfg.set_directories(self.new_installer.cfg) self.new_cfg.set_directories(self.new_installer.cfg) if self.do_starter_test: lh.section("TESTS FOR {0}".format(str(self.name)), ) #self.test_setup() #self.jam_attempt() #self.starter_shutdown() if self.selenium: self.selenium.disconnect() lh.section("Runner of type {0} - Finished!".format(str(self.name)))
def main(**kwargs): """ main """ kwargs['stress_upgrade'] = False kwargs['package_dir'] = Path(kwargs['package_dir']) kwargs['test_data_dir'] = Path(kwargs['test_data_dir']) kwargs['alluredir'] = Path(kwargs['alluredir']) kwargs['hb_cli_cfg'] = HotBackupCliCfg("disabled", "", "", "", "", "", "") kwargs['base_config'] = InstallerBaseConfig.from_dict(**kwargs) do_install = kwargs['mode'] in ["all", "install"] do_uninstall = kwargs['mode'] in ["all", "uninstall"] launch_dir = Path.cwd() if "WORKSPACE" in os.environ: launch_dir = Path(os.environ["WORKSPACE"]) if not kwargs['test_data_dir'].is_absolute(): kwargs['test_data_dir'] = launch_dir / kwargs['test_data_dir'] if not kwargs['test_data_dir'].exists(): kwargs['test_data_dir'].mkdir(parents=True, exist_ok=True) os.chdir(kwargs['test_data_dir']) if not kwargs['package_dir'].is_absolute(): kwargs['package_dir'] = (launch_dir / kwargs['package_dir']).resolve() if not kwargs['package_dir'].exists(): kwargs['package_dir'].mkdir(parents=True, exist_ok=True) init_allure(results_dir=kwargs['alluredir'], clean=kwargs['clean_alluredir'], zip_package=kwargs['zip_package']) lh.section("startup") install_config = InstallerConfig( kwargs['new_version'], kwargs['verbose'], kwargs['enterprise'], kwargs['encryption_at_rest'], kwargs['zip_package'], kwargs['src_testing'], kwargs['hb_cli_cfg'], kwargs['package_dir'], kwargs['test_data_dir'], kwargs['mode'], kwargs['publicip'], kwargs['interactive'], False, False) install_config.source = True inst = make_installer(install_config) inst.cfg.scenario = Path(kwargs['scenario']) runner = Testing(RunnerType.TESTING, False, inst, kwargs['selenium'], kwargs['selenium_driver_args'], "bla", False, False) runner.do_install = do_install runner.do_uninstall = do_uninstall failed = False if not runner.starter_prepare_env_impl(): failed = True if len(kwargs['frontends']) == 0: kill_all_processes() return 0 if not failed else 1
def run_perf_test(self, deployment_mode, versions: list, frontends, scenario, run_props: RunProperties): # fmt: on """ main """ do_install = deployment_mode in ["all", "install"] do_uninstall = deployment_mode in ["all", "uninstall"] installers = create_config_installer_set( versions, self.base_config, deployment_mode, run_props ) lh.section("configuration") print( """ mode: {mode} {cfg_repr} """.format( **{"mode": str(deployment_mode), "cfg_repr": repr(installers[0][0])} ) ) inst = installers[0][1] split_host = re.compile(r"([a-z]*)://([0-9.:]*):(\d*)") if len(frontends) > 0: for frontend in frontends: print("remote") host_parts = re.split(split_host, frontend) inst.cfg.add_frontend(host_parts[1], host_parts[2], host_parts[3]) inst.cfg.scenario = Path(scenario) runner = ClusterPerf( RunnerType.CLUSTER, self.abort_on_error, installers, self.selenium, self.selenium_driver_args, "perf", run_props, use_auto_certs=self.use_auto_certs ) runner.do_install = do_install runner.do_uninstall = do_uninstall failed = False if not runner.run(): failed = True if len(frontends) == 0: kill_all_processes() return failed
def progress(self, is_sub, msg, separator="x", supress_allure=False): """report user message, record for error handling.""" if self.selenium: self.state += self.selenium.get_progress() if is_sub: if separator == "x": separator = "=" lh.subsection(msg, separator) self.state += " - " + msg else: if separator == "x": separator = "#" lh.section(msg, separator) self.state += "*** " + msg if not supress_allure: with step("Progress: " + msg): pass
def __init__(self, version, verbose, package_dir, enterprise, enterprise_magic, zip_package, source, httpuser, httppassvoid, remote_host): """ main """ lh.section("configuration") print("version: " + str(version)) print("using enterpise: " + str(enterprise)) print("using zip: " + str(zip_package)) print("package directory: " + str(package_dir)) print("verbose: " + str(verbose)) self.user = httpuser self.passvoid = httppassvoid self.enterprise_magic = enterprise_magic if remote_host != "": self.remote_host = remote_host else: # dns split horizon... if source in ["ftp:stage1", "ftp:stage2"]: self.remote_host = "Nas02.arangodb.biz" else: self.remote_host = "fileserver.arangodb.com" lh.section("startup") if verbose: logging.info("setting debug level to debug (verbose)") logging.getLogger().setLevel(logging.DEBUG) self.package_dir = Path(package_dir) self.cfg = InstallerConfig( version, verbose, enterprise, False, # don't care for enc at rest zip_package, self.package_dir, Path("/"), "", "127.0.0.1", False, False) self.inst = make_installer(self.cfg) self.is_nightly = self.inst.semver.prerelease == "nightly" self.calculate_package_names() self.packages = []
def run_upgrade( old_version, new_version, verbose, package_dir, test_data_dir, zip_package, hot_backup, hb_provider, hb_storage_path_prefix, interactive, starter_mode, stress_upgrade, abort_on_error, publicip, selenium, selenium_driver_args, run_props: RunProperties, ): """execute upgrade tests""" lh.configure_logging(verbose) lh.section("startup") for runner_type in STARTER_MODES[starter_mode]: if not run_props.enterprise and runner_type == RunnerType.DC2DC: continue # pylint: disable=too-many-function-args installers = create_config_installer_set( [old_version, new_version], verbose, zip_package, hot_backup, hb_provider, hb_storage_path_prefix, Path(package_dir), Path(test_data_dir), "all", # deployment_mode publicip, interactive, stress_upgrade, run_props, ) lh.section("configuration") print( """ starter mode: {starter_mode} old version: {old_version} {cfg_repr} """.format( **{ "starter_mode": str(starter_mode), "old_version": old_version, "cfg_repr": repr(installers[1][0]), } ) ) runner = None installers[0][0].add_frontend("http", "127.0.0.1", "8529") runner = None if runner_type: runner = make_runner(runner_type, abort_on_error, selenium, selenium_driver_args, installers, run_props) if runner: runner.run_selenium()
def run_upgrade(old_version, new_version, verbose, package_dir, test_data_dir, enterprise, encryption_at_rest, zip_package, interactive, starter_mode, stress_upgrade, publicip, selenium, selenium_driver_args): """ execute upgrade tests """ lh.section("configuration") print("old version: " + str(old_version)) print("version: " + str(new_version)) print("using enterpise: " + str(enterprise)) print("using zip: " + str(zip_package)) print("package directory: " + str(package_dir)) print("starter mode: " + str(starter_mode)) print("public ip: " + str(publicip)) print("interactive: " + str(interactive)) print("verbose: " + str(verbose)) lh.section("startup") if verbose: logging.info("setting debug level to debug (verbose)") logging.getLogger().setLevel(logging.DEBUG) if starter_mode == 'all': starter_mode = [ RunnerType.LEADER_FOLLOWER, RunnerType.ACTIVE_FAILOVER, RunnerType.CLUSTER ] if enterprise: starter_mode.append(RunnerType.DC2DC) elif starter_mode == 'LF': starter_mode = [RunnerType.LEADER_FOLLOWER] elif starter_mode == 'AFO': starter_mode = [RunnerType.ACTIVE_FAILOVER] elif starter_mode == 'CL': starter_mode = [RunnerType.CLUSTER] elif starter_mode == 'DC': if enterprise: starter_mode = [RunnerType.DC2DC] else: starter_mode = [None] elif starter_mode == 'none': starter_mode = [None] else: raise Exception("invalid starter mode: " + starter_mode) for runner_type in starter_mode: install_config_old = InstallerConfig(old_version, verbose, enterprise, encryption_at_rest, zip_package, Path(package_dir), Path(test_data_dir), 'all', publicip, interactive, stress_upgrade) old_inst = make_installer(install_config_old) install_config_new = InstallerConfig(new_version, verbose, enterprise, encryption_at_rest, zip_package, Path(package_dir), Path(test_data_dir), 'all', publicip, interactive, stress_upgrade) new_inst = make_installer(install_config_new) install_config_old.add_frontend("http", "127.0.0.1", "8529") runner = None if runner_type: runner = make_runner(runner_type, selenium, selenium_driver_args, install_config_old, old_inst, install_config_new, new_inst) if runner: runner.run_selenium()
def run_test(old_version, new_version, verbose, package_dir, test_data_dir, enterprise, encryption_at_rest, zip_package, interactive, mode, starter_mode, publicip, selenium, selenium_driver_args): """ main """ lh.section("configuration") print("version: " + str(new_version)) print("using enterpise: " + str(enterprise)) print("using encryption at rest: " + str(encryption_at_rest)) print("using zip: " + str(zip_package)) print("package directory: " + str(package_dir)) print("mode: " + str(mode)) print("starter mode: " + str(starter_mode)) print("public ip: " + str(publicip)) print("interactive: " + str(interactive)) print("verbose: " + str(verbose)) if mode not in ['all', 'install', 'system', 'tests', 'uninstall']: raise Exception("unsupported mode %s!" % mode) do_install = mode in ["all", "install"] do_uninstall = mode in ["all", "uninstall"] lh.section("startup") if verbose: logging.info("setting debug level to debug (verbose)") logging.getLogger().setLevel(logging.DEBUG) install_config = InstallerConfig(new_version, verbose, enterprise, encryption_at_rest, zip_package, Path(package_dir), Path(test_data_dir), mode, publicip, interactive, False) inst = make_installer(install_config) if starter_mode == 'all': starter_mode = [ RunnerType.LEADER_FOLLOWER, RunnerType.ACTIVE_FAILOVER, RunnerType.CLUSTER ] if enterprise: starter_mode.append(RunnerType.DC2DC) elif starter_mode == 'LF': starter_mode = [RunnerType.LEADER_FOLLOWER] elif starter_mode == 'AFO': starter_mode = [RunnerType.ACTIVE_FAILOVER] elif starter_mode == 'CL': starter_mode = [RunnerType.CLUSTER] elif starter_mode == 'DC': starter_mode = [RunnerType.DC2DC] elif starter_mode == 'DCendurance': starter_mode = [RunnerType.DC2DCENDURANCE] elif starter_mode == 'none': starter_mode = [RunnerType.NONE] else: raise Exception("invalid starter mode: " + starter_mode) count = 1 for runner_type in starter_mode: assert runner_type runner = make_runner(runner_type, selenium, selenium_driver_args, inst.cfg, inst, None) # install on first run: runner.do_install = (count == 1) and do_install # only uninstall after the last test: runner.do_uninstall = (count == len(starter_mode)) and do_uninstall failed = False if not runner.run(): failed = True kill_all_processes() count += 1 return 0 if not failed else 1
def run_test(old_version, new_version, verbose, package_dir, test_data_dir, enterprise, encryption_at_rest, zip_package, interactive, mode, starter_mode, publicip, scenario, frontends, selenium, selenium_driver_args): """ main """ lh.section("configuration") print("version: " + str(new_version)) print("using enterpise: " + str(enterprise)) print("using zip: " + str(zip_package)) print("package directory: " + str(package_dir)) print("mode: " + str(mode)) print("starter mode: " + str(starter_mode)) print("public ip: " + str(publicip)) print("interactive: " + str(interactive)) print("scenario: " + str(scenario)) print("verbose: " + str(verbose)) if mode not in ['all', 'install', 'system', 'tests', 'uninstall']: raise Exception("unsupported mode %s!" % mode) do_install = mode in ["all", "install"] do_uninstall = mode in ["all", "uninstall"] lh.section("startup") if verbose: logging.info("setting debug level to debug (verbose)") logging.getLogger().setLevel(logging.DEBUG) install_config = InstallerConfig(new_version, verbose, enterprise, encryption_at_rest, zip_package, Path(package_dir), Path(test_data_dir), mode, publicip, interactive, False) split_host = re.compile(r'([a-z]*)://([0-9.:]*):(\d*)') inst = make_installer(install_config) if len(frontends) > 0: for frontend in frontends: print('remote') host_parts = re.split(split_host, frontend) inst.cfg.add_frontend(host_parts[1], host_parts[2], host_parts[3]) inst.cfg.scenario = Path(scenario) runner = ClusterPerf(RunnerType.CLUSTER, inst.cfg, inst, None, None, selenium, selenium_driver_args) runner.do_install = do_install runner.do_uninstall = do_uninstall failed = False if not runner.run(): failed = True if len(frontends) == 0: kill_all_processes() return 0 if not failed else 1
def __init__( self, options: DownloadOptions, hb_cli_cfg: HotBackupCliCfg, version: str, enterprise: bool, zip_package: bool, src_testing: bool, source, existing_version_states={}, new_version_states={}, git_version="", ): """main""" lh.section("configuration") self.launch_dir = Path.cwd() if "WORKSPACE" in os.environ: self.launch_dir = Path(os.environ["WORKSPACE"]) if not options.package_dir.is_absolute(): options.package_dir = (self.launch_dir / options.package_dir).resolve() print("version: " + str(version)) print("using enterpise: " + str(enterprise)) print("using zip: " + str(zip_package)) print("package directory: " + str(options.package_dir)) print("verbose: " + str(options.verbose)) self.options = options self.is_nightly = semver.VersionInfo.parse( version).prerelease == "nightly" self.source = source if not self.is_nightly and self.source == 'nightlypublic': self.source = 'public' if options.remote_host != "": # external DNS to wuerg around docker dns issues... self.remote_host = options.remote_host else: # dns split horizon... if source in ["ftp:stage1", "ftp:stage2"]: self.remote_host = "nas01.arangodb.biz" elif source in ["http:stage2"]: self.remote_host = "download.arangodb.com" else: self.remote_host = "download.arangodb.com" lh.section("startup") self.cfg = InstallerConfig( version=version, verbose=options.verbose, enterprise=enterprise, encryption_at_rest=False, zip_package=zip_package, src_testing=src_testing, hb_cli_cfg=hb_cli_cfg, package_dir=options.package_dir, test_dir=Path("/"), deployment_mode="all", publicip="127.0.0.1", interactive=False, stress_upgrade=False, ssl=False, ) self.inst = make_installer(self.cfg) self.path_architecture = "" if self.is_nightly or self.cfg.semver > semver.VersionInfo.parse( "3.9.99"): machine = platform.machine() if machine == 'AMD64': machine = 'x86_64' self.path_architecture = machine + '/' self.calculate_package_names() self.packages = [] self.existing_version_states = existing_version_states self.new_version_states = new_version_states self.version_content = None self.version_content = None if version.find("-nightly") >= 0: self.version_state_id = version + "_sourceInfo.log" if self.version_state_id in self.existing_version_states: self.version_content = self.existing_version_states[ self.version_state_id] self.fresh_content = self.get_version_info(git_version) self.new_version_states[self.version_state_id] = self.fresh_content
def run_test(self, deployment_mode, versions: list, run_props: RunProperties): # fmt: on """ main """ results = [] do_install = deployment_mode in ["all", "install"] do_uninstall = deployment_mode in ["all", "uninstall"] installers = create_config_installer_set( versions, self.base_config, deployment_mode, run_props ) lh.section("configuration") print( """ mode: {mode} {cfg_repr} """.format( **{"mode": str(deployment_mode), "cfg_repr": repr(installers[0][0])} ) ) count = 1 for runner_type in STARTER_MODES[self.base_config.starter_mode]: with AllureTestSuiteContext(properties=run_props, versions=versions, parent_test_suite_name=None, auto_generate_parent_test_suite_name=True, suite_name=runner_strings[runner_type], runner_type=None, installer_type=installers[0][1].installer_type): with RtaTestcase(runner_strings[runner_type] + " main flow") as testcase: if not run_props.supports_dc2dc() and runner_type == RunnerType.DC2DC: testcase.context.status = Status.SKIPPED testcase.context.statusDetails = StatusDetails( message="DC2DC is not applicable to Community packages.\nDC2DC is not supported on Windows.") continue one_result = { "testrun name": run_props.testrun_name, "testscenario": runner_strings[runner_type], "success": True, "messages": [], "progress": "", } runner = make_runner( runner_type, self.abort_on_error, self.selenium, self.selenium_driver_args, installers, run_props, use_auto_certs=self.use_auto_certs, ) # install on first run: runner.do_install = (count == 1) and do_install # only uninstall after the last test: runner.do_uninstall = (count == len( STARTER_MODES[deployment_mode])) and do_uninstall try: runner.run() runner.cleanup() testcase.context.status = Status.PASSED # pylint: disable=broad-except except Exception as ex: one_result["success"] = False one_result["messages"].append(str(ex)) one_result["progress"] += runner.get_progress() runner.take_screenshot() runner.agency_acquire_dump() runner.search_for_warnings() runner.quit_selenium() kill_all_processes() runner.zip_test_dir() self.copy_packages_to_result(installers) testcase.context.status = Status.FAILED testcase.context.statusDetails = StatusDetails(message=str(ex), trace="".join( traceback.TracebackException.from_exception( ex).format())) lh.section("uninstall on error") installers[0][1].un_install_debug_package() installers[0][1].un_install_server_package() installers[0][1].cleanup_system() if self.abort_on_error: raise ex traceback.print_exc() lh.section("uninstall on error") try: runner.cleanup() finally: pass results.append(one_result) continue if runner.ui_tests_failed: failed_test_names = [f'"{row["Name"]}"' for row in runner.ui_test_results_table if not row["Result"] == "PASSED"] one_result["success"] = False # pylint: disable=line-too-long one_result[ "messages"].append( f'The following UI tests failed: {", ".join(failed_test_names)}. See allure report for details.') kill_all_processes() count += 1 return results
def run_upgrade(self, versions: list, run_props: RunProperties): """execute upgrade tests""" lh.section("startup") results = [] for runner_type in STARTER_MODES[self.base_config.starter_mode]: installers = create_config_installer_set( versions, self.base_config, "all", run_props, ) old_inst = installers[0][1] new_inst = installers[1][1] with AllureTestSuiteContext( properties=run_props, versions=versions, parent_test_suite_name=None, auto_generate_parent_test_suite_name=True, suite_name=runner_strings[runner_type], runner_type=None, installer_type=new_inst.installer_type, ): with RtaTestcase(runner_strings[runner_type] + " main flow") as testcase: if not run_props.supports_dc2dc() and runner_type == RunnerType.DC2DC: testcase.context.status = Status.SKIPPED testcase.context.statusDetails = StatusDetails( message="DC2DC is not applicable to Community packages.\nDC2DC is not supported on Windows." ) continue one_result = { "testrun name": run_props.testrun_name, "testscenario": runner_strings[runner_type], "success": True, "messages": [], "progress": "", } try: kill_all_processes() runner = None lh.section("configuration") print( """ starter mode: {starter_mode} old version: {old_version} {cfg_repr} """.format( **{ "starter_mode": str(self.base_config.starter_mode), "old_version": str(versions[0]), "cfg_repr": repr(installers[1][0]), } ) ) if runner_type: runner = make_runner( runner_type, self.abort_on_error, self.selenium, self.selenium_driver_args, installers, run_props, use_auto_certs=self.use_auto_certs, ) if runner: try: runner.run() runner.cleanup() testcase.context.status = Status.PASSED except Exception as ex: one_result["success"] = False one_result["messages"].append(str(ex)) one_result["progress"] += runner.get_progress() runner.take_screenshot() runner.agency_acquire_dump() runner.search_for_warnings() runner.quit_selenium() kill_all_processes() runner.zip_test_dir() self.copy_packages_to_result(installers) testcase.context.status = Status.FAILED testcase.context.statusDetails = StatusDetails( message=str(ex), trace="".join(traceback.TracebackException.from_exception(ex).format()), ) if self.abort_on_error: raise ex one_result["progress"] += str(ex) + "".join( traceback.TracebackException.from_exception(ex).format() ) traceback.print_exc() lh.section("uninstall on error") old_inst.un_install_debug_package() old_inst.un_install_server_package() old_inst.cleanup_system() try: runner.cleanup() finally: pass results.append(one_result) continue if runner.ui_tests_failed: failed_test_names = [ f'"{row["Name"]}"' for row in runner.ui_test_results_table if not row["Result"] == "PASSED" ] one_result["success"] = False one_result["messages"].append( f'The following UI tests failed: {", ".join(failed_test_names)}.' + "See allure report for details." ) lh.section("uninstall") new_inst.un_install_server_package() lh.section("check system") new_inst.check_uninstall_cleanup() lh.section("remove residuals") try: old_inst.cleanup_system() except Exception: print("Ignoring old cleanup error!") try: print("Ignoring new cleanup error!") new_inst.cleanup_system() except Exception: print("Ignoring general cleanup error!") except Exception as ex: print("Caught. " + str(ex)) one_result["success"] = False one_result["messages"].append(str(ex)) one_result["progress"] += "\naborted outside of testcodes" if self.abort_on_error: print("re-throwing.") raise ex traceback.print_exc() kill_all_processes() if runner: try: runner.cleanup() except Exception as exception: print("Ignoring runner cleanup error! Exception:") print(str(exception)) print("".join(traceback.TracebackException.from_exception(exception).format())) try: print("Cleaning up system after error:") old_inst.un_install_debug_package() old_inst.un_install_server_package() old_inst.cleanup_system() except Exception: print("Ignoring old cleanup error!") try: print("Ignoring new cleanup error!") new_inst.un_install_debug_package() new_inst.un_install_server_package() new_inst.cleanup_system() except Exception: print("Ignoring new cleanup error!") results.append(one_result) return results
def run(self): """ run the full lifecycle flow of this deployment """ # pylint: disable=R0915 disable=R0912 if self.do_starter_test and not self.remote: self.detect_file_ulimit() lh.section("Runner of type {0}".format(str(self.name)), "<3") if self.do_install or self.do_system_test: lh.section("INSTALLATION for {0}".format(str(self.name)), ) self.install(self.old_installer) if self.do_starter_test: lh.section("PREPARING DEPLOYMENT of {0}".format(str(self.name)), ) self.starter_prepare_env() self.starter_run() self.finish_setup() self.make_data() if self.selenium: self.selenium.connect_server(self.get_frontend_instances(), '_system', self.cfg) self.selenium.check_old(self.old_installer.cfg) ti.prompt_user( self.basecfg, "{0}{1} Deployment started. Please test the UI!".format( (self.versionstr), str(self.name))) if self.hot_backup: lh.section("TESTING HOTBACKUP") self.before_backup() # TODO generate name? self.backup_name = self.create_backup("thy_name_is") self.tcp_ping_all_nodes() self.create_non_backup_data() backups = self.list_backup() print(backups) self.upload_backup(backups[0]) self.tcp_ping_all_nodes() self.delete_backup(backups[0]) self.tcp_ping_all_nodes() backups = self.list_backup() if len(backups) != 0: raise Exception("expected backup to be gone, " "but its still there: " + str(backups)) self.download_backup(self.backup_name) self.tcp_ping_all_nodes() backups = self.list_backup() if backups[0] != self.backup_name: raise Exception("downloaded backup has different name? " + str(backups)) time.sleep(20) # TODO fix self.restore_backup(backups[0]) self.tcp_ping_all_nodes() self.after_backup() self.check_data_impl() if not self.check_non_backup_data(): raise Exception("data created after backup" " is still there??") self.create_non_backup_data() if self.new_installer: self.versionstr = "NEW[" + self.new_cfg.version + "] " lh.section("UPGRADE OF DEPLOYMENT {0}".format(str(self.name)), ) if self.cfg.have_debug_package: print('removing *old* debug package in advance') self.old_installer.un_install_debug_package() self.new_installer.upgrade_package(self.old_installer) # only install debug package for new package. lh.subsection('installing debug package:') self.cfg.have_debug_package = self.new_installer.install_debug_package( ) if self.cfg.have_debug_package: self.new_installer.gdb_test() self.new_installer.stop_service() self.cfg.set_directories(self.new_installer.cfg) self.new_cfg.set_directories(self.new_installer.cfg) self.old_installer.un_install_package_for_upgrade() self.upgrade_arangod_version() #make sure to pass new version self.make_data_after_upgrade() if self.hot_backup: lh.section("TESTING HOTBACKUP AFTER UPGRADE") self.before_backup() backups = self.list_backup() print(backups) self.upload_backup(backups[0]) self.tcp_ping_all_nodes() self.delete_backup(backups[0]) self.tcp_ping_all_nodes() backups = self.list_backup() if len(backups) != 0: raise Exception("expected backup to be gone, " "but its still there: " + str(backups)) self.download_backup(self.backup_name) self.tcp_ping_all_nodes() backups = self.list_backup() if backups[0] != self.backup_name: raise Exception("downloaded backup has different name? " + str(backups)) time.sleep(20) # TODO fix self.restore_backup(backups[0]) self.tcp_ping_all_nodes() self.after_backup() if not self.check_non_backup_data(): raise Exception("data created after " "backup is still there??") self.check_data_impl() else: logging.info("skipping upgrade step no new version given") if self.do_starter_test: lh.section("TESTS FOR {0}".format(str(self.name)), ) self.test_setup() self.jam_attempt() self.starter_shutdown() if self.do_uninstall: self.uninstall(self.old_installer if not self.new_installer else self.new_installer) self.selenium.disconnect() lh.section("Runner of type {0} - Finished!".format(str(self.name)))