def install_debug_package(self): """ installing debug package """ cmd = 'dpkg -i ' + str(self.cfg.package_dir / self.debug_package) lh.log_cmd(cmd) os.environ['DEBIAN_FRONTEND'] = 'readline' debug_install = pexpect.spawnu(cmd) try: logging.info("waiting for the installation to finish") debug_install.expect(pexpect.EOF, timeout=60) except pexpect.exceptions.EOF: logging.info("TIMEOUT!") debug_install.close(force=True) ascii_print(debug_install.before) print() logging.info(str(self.debug_package) + ' Installation successfull') self.cfg.have_debug_package = True while debug_install.isalive(): progress('.') if debug_install.exitstatus != 0: debug_install.close(force=True) ascii_print(debug_install.before) raise Exception( str(self.debug_package) + " debug installation didn't finish successfully!") return self.cfg.have_debug_package
def install_rpm_package(self, package: str, upgrade: bool = False): """installing rpm package""" print("installing rpm package: %s" % package) if upgrade: option = "--upgrade" else: option = "--install" cmd = f"rpm {option} {package}" lh.log_cmd(cmd) install = pexpect.spawnu(cmd) install.logfile = sys.stdout try: logging.info("waiting for the installation to finish") install.expect(pexpect.EOF, timeout=90) output = install.before install.wait() except pexpect.exceptions.TIMEOUT as ex: logging.info("TIMEOUT!") install.close(force=True) output = install.before raise Exception( "Installation of the package {} didn't finish within 90 seconds! Output:\n{}" .format(str(package), output)) from ex if install.exitstatus != 0: install.close(force=True) raise Exception( "Installation of the package {} didn't finish successfully! Output:\n{}" .format(str(package), output)) logging.info(str(self.debug_package) + " Installation successfull") return True
def stop_service(self): logging.info("stopping service") cmd = ["service", "arangodb3", "stop"] lh.log_cmd(cmd) run_cmd_and_log_stdout(cmd) while self.check_service_up(): time.sleep(1)
def create_dump_for_exe(exe_file: str, dump_file_dir: str): """run given executable with \"-?\" command line parameter and create a memory dump when it terminates""" exe_file = Path(exe_file) exe_name = exe_file.name with step(f"Create a memory dump of the program: {exe_name}"): dump_filename = None cmd = [ "procdump", "-ma", "-t", "-x", dump_file_dir, str(exe_file), "-?" ] lh.log_cmd(cmd) with psutil.Popen(cmd, bufsize=-1, stdout=subprocess.PIPE, stderr=subprocess.PIPE) as proc: (procdump_out, procdump_err) = proc.communicate() procdump_str = str(procdump_out, "UTF-8") attach(procdump_str, "procdump sdtout") attach(str(procdump_err), "procdump stderr") success_string = "Dump 1 complete" filename_regex = re.compile( r"^(\[\d{2}:\d{2}:\d{2}\] Dump 1 initiated: )(?P<filename>.*)$", re.MULTILINE) match = re.search(filename_regex, procdump_str) if procdump_str.find(success_string) < 0 or not match: raise Exception( "procdump wasn't able to create a dump file: " + procdump_str) dump_filename = match.group("filename") return dump_filename
def create_arangosh_dump(installer, dump_file_dir: str): """create arangosh memory dump file""" dump_filename = None with step("Start arangosh process"): exe_file = installer.cfg.bin_dir / "arangosh.exe" cmd = [str(exe_file)] arangosh_proc = psutil.Popen(cmd, bufsize=-1, stdout=subprocess.PIPE, stderr=subprocess.PIPE) arangosh_pid = arangosh_proc.pid with step("Create a dump of arangosh process"): cmd = ["procdump", "-ma", str(arangosh_pid), dump_file_dir] lh.log_cmd(cmd) with psutil.Popen(cmd, bufsize=-1, stdout=subprocess.PIPE, stderr=subprocess.PIPE) as proc: (procdump_out, procdump_err) = proc.communicate() procdump_str = str(procdump_out, "UTF-8") attach(procdump_str, "procdump sdtout") attach(str(procdump_err), "procdump stderr") success_string = "Dump 1 complete" filename_regex = re.compile( r"^(\[\d{2}:\d{2}:\d{2}\] Dump 1 initiated: )(?P<filename>.*)$", re.MULTILINE) match = re.search(filename_regex, procdump_str) if procdump_str.find(success_string) < 0 or not match: raise Exception( "procdump wasn't able to create a dump file: " + procdump_str) dump_filename = match.group("filename") with step("Kill arangosh process"): arangosh_proc.kill() return dump_filename
def run_command(self, cmd, verbose=True): """ launch a command, print its name """ run_cmd = [ self.cfg.bin_dir / "arangosh", "--log.level", "v8=debug", "--server.endpoint", self.connect_instance.get_endpoint() ] run_cmd += [ "--server.username", str(self.cfg.username) ] run_cmd += [ "--server.password", str(self.connect_instance.get_passvoid()) ] # if self.cfg.username: # run_cmd += [ "--server.username", str(self.cfg.username) ] # if self.cfg.passvoid: # run_cmd += [ "--server.password", str(self.cfg.passvoid) ] run_cmd += [ "--javascript.execute-string", str(cmd[1]) ] if len(cmd) > 2: run_cmd += cmd[2:] arangosh_run = None if verbose: lh.log_cmd(run_cmd) arangosh_run = psutil.Popen(run_cmd) else: arangosh_run = psutil.Popen(run_cmd, stdout = DEVNULL, stderr = DEVNULL) exitcode = arangosh_run.wait(timeout=60) # logging.debug("exitcode {0}".format(exitcode)) return exitcode == 0
def run_backup(self, arguments, name, silent=False): """ launch the starter for this instance""" if not silent: logging.info("running hot backup " + name) args = [self.cfg.bin_dir / 'arangobackup'] + arguments + self.moreopts if not silent: lh.log_cmd(args) instance = psutil.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE) (output, err) = instance.communicate() if len(err) > 0: ascii_print(str(err)) success = True if not silent: for line in output.splitlines(): strline = str(line) ascii_print(strline) if strline.find('ERROR') >= 0: success = False if instance.returncode != 0: raise Exception("arangobackup exited " + str(instance.returncode)) if not success: raise Exception("arangobackup indicated 'ERROR' in its output!") return output.splitlines()
def run_backup(self, arguments, name, silent=False, expect_to_fail=False, timeout=20): """run arangobackup""" if not silent: logging.info("running hot backup " + name) run_cmd = copy.deepcopy(self.cfg.default_backup_args) if self.cfg.verbose: run_cmd += ["--log.level=debug"] run_cmd += arguments lh.log_cmd(arguments, not silent) def inspect_line_result(line): strline = str(line) if strline.find("ERROR") >= 0: return True return False success, output, _, error_found = self.run_arango_tool_monitored( self.cfg.bin_dir / "arangobackup", run_cmd, timeout, inspect_line_result, self.cfg.verbose and not silent, expect_to_fail, ) if not success: raise Exception("arangobackup exited " + str(output)) if not success or error_found: raise Exception("arangobackup indicated 'ERROR' in its output: %s" % ascii_convert_str(output)) return output
def run_starter(self): """ launch the starter for this instance""" logging.info("running starter " + self.name) args = [self.cfg.bin_dir / 'arangodb' ] + self.hotbackup + self.arguments lh.log_cmd(args) self.instance = psutil.Popen(args) self.wait_for_logfile()
def run_starter(self, expect_to_fail=False): """launch the starter for this instance""" logging.info("running starter " + self.name) args = [self.cfg.bin_dir / "arangodb"] + self.hotbackup_args + self.arguments lh.log_cmd(args) self.instance = psutil.Popen(args) logging.info("my starter has PID:" + str(self.instance.pid)) if not expect_to_fail: self.wait_for_logfile()
def start_service(self): assert self.instance logging.info("starting service") cmd = ["service", "arangodb3", "start"] lh.log_cmd(cmd) run_cmd_and_log_stdout(cmd) time.sleep(0.1) self.instance.detect_pid(1) # should be owned by init
def launch(self, testcase_no, moreopts=[]): """run arangobench""" testcase = BENCH_TODOS[testcase_no] arguments = [self.cfg.real_bin_dir / "arangobench" ] + self.moreopts + moreopts for key in testcase.keys(): arguments.append("--" + key) arguments.append(str(testcase[key])) lh.log_cmd(arguments, self.cfg.verbose) self.arguments = arguments self.instance = psutil.Popen(arguments) print("az" * 40)
def un_install_package(self): cmd = ('dpkg --purge ' + 'arangodb3' + ('e' if self.cfg.enterprise else '')) lh.log_cmd(cmd) uninstall = pexpect.spawnu(cmd) try: uninstall.expect(['Purging', 'which isn\'t installed']) ascii_print(uninstall.before) uninstall.expect(pexpect.EOF) ascii_print(uninstall.before) except pexpect.exceptions.EOF: ascii_print(uninstall.before) sys.exit(1)
def un_install_server_package_impl(self): """ uninstall server package """ cmd = "dpkg --purge " + "arangodb3" + ("e" if self.cfg.enterprise else "") lh.log_cmd(cmd) uninstall = pexpect.spawnu(cmd) try: uninstall.expect(["Purging", "which isn't installed"]) ascii_print(uninstall.before) uninstall.expect(pexpect.EOF) ascii_print(uninstall.before) except pexpect.exceptions.EOF as ex: ascii_print(uninstall.before) raise ex self.instance.search_for_warnings()
def upgrade_server_package(self, old_installer): logging.info("upgrading Arangodb debian package") self.backup_dirs_number_before_upgrade = self.count_backup_dirs() os.environ["DEBIAN_FRONTEND"] = "readline" cmd = "dpkg -i " + str(self.cfg.package_dir / self.server_package) lh.log_cmd(cmd) server_upgrade = pexpect.spawnu(cmd) server_upgrade.logfile = sys.stdout while True: try: i = server_upgrade.expect( [ "Upgrading database files", "Database files are up-to-date", "arangod.conf", ], timeout=120, ) if i == 0: logging.info("X" * 80) ascii_print(server_upgrade.before) logging.info("X" * 80) logging.info("[X] Upgrading database files") break if i == 1: logging.info("X" * 80) ascii_print(server_upgrade.before) logging.info("X" * 80) logging.info("[ ] Update not needed.") break if i == 2: # modified arangod.conf... ascii_print(server_upgrade.before) server_upgrade.sendline("Y") # fallthrough - repeat. except pexpect.exceptions.EOF as ex: logging.info("X" * 80) ascii_print(server_upgrade.before) logging.info("X" * 80) logging.info("[E] Upgrade failed!") raise Exception("Upgrade failed!") from ex try: logging.info("waiting for the upgrade to finish") server_upgrade.expect(pexpect.EOF, timeout=30) ascii_print(server_upgrade.before) except pexpect.exceptions.EOF: logging.info("TIMEOUT!") self.set_system_instance() self.instance.detect_pid(1) # should be owned by init
def upgrade_server_package(self, old_installer): logging.info("upgrading Arangodb rpm package") self.cfg.passvoid = "RPM_passvoid_%d" % os.getpid() self.cfg.log_dir = Path("/var/log/arangodb3") self.cfg.dbdir = Path("/var/lib/arangodb3") self.cfg.appdir = Path("/var/lib/arangodb3-apps") self.cfg.cfgdir = Path("/etc/arangodb3") self.set_system_instance() # https://access.redhat.com/solutions/1189 cmd = "rpm --upgrade " + str( self.cfg.package_dir / self.server_package) lh.log_cmd(cmd) server_upgrade = pexpect.spawnu(cmd) server_upgrade.logfile = sys.stdout try: server_upgrade.expect( "First Steps with ArangoDB:|server " "will now shut down due to upgrade," "database initialization or admin restoration.") print(server_upgrade.before) except pexpect.exceptions.EOF as exc: lh.line("X") ascii_print(server_upgrade.before) lh.line("X") print("exception : " + str(exc)) lh.line("X") logging.error("Upgrade failed!") raise exc logging.debug("found: upgrade message") logging.info("waiting for the upgrade to finish") try: server_upgrade.expect(pexpect.EOF, timeout=30) ascii_print(server_upgrade.before) except pexpect.exceptions.EOF as ex: logging.error("TIMEOUT! while upgrading package") raise ex logging.debug("upgrade successfully finished") self.start_service()
def install_package(self): logging.info("installing Arangodb debian Tar package") logging.debug("package dir: {0.cfg.package_dir}- " "server_package: {0.server_package}".format(self)) if not self.cfg.installPrefix.exists(): self.cfg.installPrefix.mkdir() cmd = [ self.tar, '-xf', str(self.cfg.package_dir / self.server_package), '-C', str(self.cfg.installPrefix), '--strip-components', '1' ] lh.log_cmd(cmd) install = psutil.Popen(cmd) if install.wait() != 0: raise Exception("extracting the Archive failed!") print() logging.info('Installation successfull')
def create_arangod_dump(installer, starter_dir: str, dump_file_dir: str): """create arangod memory dump file""" starter = StarterManager( basecfg=installer.cfg, install_prefix=Path(starter_dir), instance_prefix="single", expect_instances=[InstanceType.SINGLE], mode="single", jwt_str="single", ) dump_filename = None try: with step("Start a single server deployment"): starter.run_starter() starter.detect_instances() starter.detect_instance_pids() starter.set_passvoid("") pid = starter.all_instances[0].pid with step("Create a dump of arangod process"): cmd = ["procdump", "-ma", str(pid), dump_file_dir] lh.log_cmd(cmd) with psutil.Popen(cmd, bufsize=-1, stdout=subprocess.PIPE, stderr=subprocess.PIPE) as proc: (procdump_out, procdump_err) = proc.communicate() procdump_str = str(procdump_out, "UTF-8") attach(procdump_str, "procdump sdtout") attach(str(procdump_err), "procdump stderr") success_string = "Dump 1 complete" filename_regex = re.compile( r"^(\[\d{2}:\d{2}:\d{2}\] Dump 1 initiated: )(?P<filename>.*)$", re.MULTILINE) match = re.search(filename_regex, procdump_str) if procdump_str.find(success_string) < 0 or not match: raise Exception( "procdump wasn't able to create a dump file: " + procdump_str) dump_filename = match.group("filename") finally: starter.terminate_instance() kill_all_processes() return dump_filename
def uninstall_package(self, package_name, force=False): """uninstall package""" os.environ["DEBIAN_FRONTEND"] = "readline" force = "--force-depends" if force else "" cmd = f"dpkg --purge {force} {package_name}" lh.log_cmd(cmd) uninstall = pexpect.spawnu(cmd) try: uninstall.expect(["Removing", "which isn't installed"]) ascii_print(uninstall.before) uninstall.expect(pexpect.EOF, timeout=30) ascii_print(uninstall.before) except pexpect.exceptions.EOF as ex: ascii_print(uninstall.before) raise ex while uninstall.isalive(): progress(".") if uninstall.exitstatus != 0: uninstall.close(force=True) ascii_print(uninstall.before) raise Exception("Uninstallation of package %s didn't finish successfully!" % package_name)
def install_client_package_impl(self): """install client package""" cmd = "dpkg -i " + str(self.cfg.package_dir / self.client_package) lh.log_cmd(cmd) os.environ["DEBIAN_FRONTEND"] = "readline" client_install = pexpect.spawnu(cmd) try: logging.info("waiting for the installation to finish") client_install.expect(pexpect.EOF, timeout=60) except pexpect.exceptions.EOF: logging.info("TIMEOUT!") client_install.close(force=True) ascii_print(client_install.before) print() logging.info(str(self.client_package) + " Installation successful") while client_install.isalive(): progress(".") if client_install.exitstatus != 0: client_install.close(force=True) ascii_print(client_install.before) raise Exception(str(self.debug_package) + " client package installation didn't finish successfully!")
def un_install_debug_package(self): os.environ['DEBIAN_FRONTEND'] = 'readline' cmd = ('dpkg --purge ' + 'arangodb3' + ('e-dbg' if self.cfg.enterprise else '-dbg')) lh.log_cmd(cmd) uninstall = pexpect.spawnu(cmd) try: uninstall.expect(['Removing', 'which isn\'t installed']) ascii_print(uninstall.before) uninstall.expect(pexpect.EOF, timeout=30) ascii_print(uninstall.before) except pexpect.exceptions.EOF: ascii_print(uninstall.before) sys.exit(1) while uninstall.isalive(): progress('.') if uninstall.exitstatus != 0: uninstall.close(force=True) ascii_print(uninstall.before) raise Exception( "Debug package uninstallation didn't finish successfully!")
def install_server_package_impl(self): # pylint: disable=too-many-statements self.cfg.log_dir = Path("/var/log/arangodb3") self.cfg.dbdir = Path("/var/lib/arangodb3") self.cfg.appdir = Path("/var/lib/arangodb3-apps") self.cfg.cfgdir = Path("/etc/arangodb3") self.set_system_instance() logging.info("installing Arangodb RPM package") package = self.cfg.package_dir / self.server_package if not package.is_file(): logging.info("package doesn't exist: %s", str(package)) raise Exception("failed to find package") cmd = "rpm " + "-i " + str(package) lh.log_cmd(cmd) server_install = pexpect.spawnu(cmd) server_install.logfile = sys.stdout reply = None try: server_install.expect("the current password is") ascii_print(server_install.before) server_install.expect(pexpect.EOF, timeout=60) reply = server_install.before ascii_print(reply) except pexpect.exceptions.EOF as ex: ascii_print(server_install.before) logging.info("Installation failed!") raise ex while server_install.isalive(): progress(".") if server_install.exitstatus != 0: raise Exception("server installation " "didn't finish successfully!") start = reply.find("'") end = reply.find("'", start + 1) self.cfg.passvoid = reply[start + 1:end] self.start_service() self.instance.detect_pid(1) # should be owned by init pwcheckarangosh = ArangoshExecutor(self.cfg, self.instance) if not pwcheckarangosh.js_version_check(): logging.error( "Version Check failed -" "probably setting the default random password didn't work! %s", self.cfg.passvoid, ) # should we wait for user here? or mark the error in a special way self.stop_service() self.cfg.passvoid = "RPM_passvoid_%d" % os.getpid() lh.log_cmd("/usr/sbin/arango-secure-installation") with pexpect.spawnu("/usr/sbin/arango-secure-installation") as etpw: etpw.logfile = sys.stdout result = None try: ask_for_pass = [ "Please enter a new password for the ArangoDB root user:"******"Please enter password for root user:"******"Not asked for password") etpw.sendline(self.cfg.passvoid) result = etpw.expect("Repeat password: "******"Not asked to repeat the password") ascii_print(etpw.before) logging.info("password should be set to: " + self.cfg.passvoid) etpw.sendline(self.cfg.passvoid) logging.info("expecting eof") logging.info("password should be set to: " + self.cfg.passvoid) result = etpw.expect(pexpect.EOF) logging.info("password should be set to: " + self.cfg.passvoid) ascii_print(etpw.before) # except pexpect.exceptions.EOF: except Exception as exc: logging.error("setting our password failed!") logging.error("X" * 80) logging.error("XO" * 80) logging.error(repr(self.cfg)) logging.error("X" * 80) logging.error("result: " + str(result)) logging.error("X" * 80) ascii_print(etpw.before) logging.error("X" * 80) raise exc self.start_service() self.instance.detect_pid(1) # should be owned by init
def run_monitored(self, executeable, args, timeout=60, result_line=dummy_line_result, verbose=False, expect_to_fail=False): """ run a script in background tracing with a dynamic timeout that its got output (is still alive...) """ run_cmd = [executeable] + args lh.log_cmd(run_cmd, verbose) with Popen( run_cmd, stdout=PIPE, stderr=PIPE, close_fds=ON_POSIX, cwd=self.cfg.test_data_dir.resolve(), ) as process: queue = Queue() thread1 = Thread( name="readIO", target=enqueue_stdout, args=(process.stdout, queue, self.connect_instance), ) thread2 = Thread( name="readErrIO", target=enqueue_stderr, args=(process.stderr, queue, self.connect_instance), ) thread1.start() thread2.start() try: print("me PID:%d launched PID:%d with LWPID:%d and LWPID:%d" % (os.getpid(), process.pid, thread1.native_id, thread2.native_id)) except AttributeError: print( "me PID:%d launched PID:%d with LWPID:N/A and LWPID:N/A" % (os.getpid(), process.pid)) # ... do other things here # out = logfile.open('wb') # read line without blocking have_timeout = False line_filter = False tcount = 0 close_count = 0 result = [] while not have_timeout: if not verbose: progress("sj" + str(tcount)) line = "" try: line = queue.get(timeout=1) line_filter = line_filter or result_line(line) except Empty: tcount += 1 if verbose: progress("T " + str(tcount)) have_timeout = tcount >= timeout else: tcount = 0 if isinstance(line, tuple): if verbose: print("e: " + str(line[0])) if not str(line[0]).startswith("#"): result.append(line) else: close_count += 1 if close_count == 2: print(" done!") break timeout_str = "" if have_timeout: timeout_str = "TIMEOUT OCCURED!" print(timeout_str) timeout_str += "\n" process.kill() rc_exit = process.wait() thread1.join() thread2.join() attach(str(rc_exit), f"Exit code: {str(rc_exit)}") if have_timeout or rc_exit != 0: res = (False, timeout_str + convert_result(result), rc_exit, line_filter) if expect_to_fail: return res raise CliExecutionException("Execution failed.", res, have_timeout) if not expect_to_fail: if len(result) == 0: res = (True, "", 0, line_filter) else: res = (True, convert_result(result), 0, line_filter) return res if len(result) == 0: res = (True, "", 0, line_filter) else: res = (True, convert_result(result), 0, line_filter) raise CliExecutionException( "Execution was expected to fail, but exited successfully.", res, have_timeout)
def run_script_monitored(self, cmd, args, timeout, result_line, process_control=False, verbose=True): # pylint: disable=R0913 disable=R0902 disable=R0915 disable=R0912 """ runs a script in background tracing with a dynamic timeout that its got output (is still alive...) """ run_cmd = [ self.cfg.bin_dir / "arangosh", "--server.endpoint", self.connect_instance.get_endpoint(), "--log.level", "v8=debug", "--log.foreground-tty", "true" ] if process_control: run_cmd += ['--javascript.allow-external-process-control', 'true'] run_cmd += [ "--server.username", str(self.cfg.username) ] run_cmd += [ "--server.password", str(self.connect_instance.get_passvoid()) ] run_cmd += [ "--javascript.execute", str(cmd[1]) ] if len(cmd) > 2: run_cmd += cmd[2:] if len(args) > 0: run_cmd += ['--'] + args if verbose: lh.log_cmd(run_cmd) process = Popen(run_cmd, stdout=PIPE, stderr=PIPE, close_fds=ON_POSIX) queue = Queue() thread1 = Thread(target=enqueue_stdout, args=(process.stdout, queue, self.connect_instance)) thread2 = Thread(target=enqueue_stderr, args=(process.stderr, queue, self.connect_instance)) thread1.start() thread2.start() # ... do other things here # out = logfile.open('wb') # read line without blocking have_timeout = False tcount = 0 close_count = 0 result = [] while not have_timeout: if not verbose: progress("sj" + str(tcount)) line = '' try: line = queue.get(timeout=1) result_line(line) except Empty: tcount += 1 if verbose: progress('T ' + str(tcount)) have_timeout = tcount >= timeout else: tcount = 0 if isinstance(line, tuple): if verbose: print("e: " + str(line[0])) if not str(line[0]).startswith('#'): result.append(line) else: close_count += 1 if close_count == 2: print(' done!') break if have_timeout: print(" TIMEOUT OCCURED!") process.kill() rc_exit = process.wait() print(rc_exit) thread1.join() thread2.join() if have_timeout or rc_exit != 0: return (False, convert_result(result)) if len(result) == 0: return (True, "") return (True, convert_result(result))
def upgrade_package(self, old_installer): logging.info("upgrading Arangodb debian package") os.environ['DEBIAN_FRONTEND'] = 'readline' server_upgrade = pexpect.spawnu('dpkg -i ' + str(self.cfg.package_dir / self.server_package)) try: i == server_upgrade.expect( ['Upgrading database files', 'Database files are up-to-date']) ascii_print(server_upgrade.before) if i == 0: logging.info("Upgrading database files...") elif i == 1: logging.info("Database already up-to-date!") except pexpect.exceptions.EOF: logging.info("X" * 80) ascii_print(server_upgrade.before) logging.info("X" * 80) logging.info("[E] Upgrade failed!") sys.exit(1) cmd = 'dpkg -i ' + str(self.cfg.package_dir / self.server_package) lh.log_cmd(cmd) server_upgrade = pexpect.spawnu(cmd) while True: try: i = server_upgrade.expect([ 'Upgrading database files', 'Database files are up-to-date', 'arangod.conf' ], timeout=60) if i == 0: logging.info("X" * 80) ascii_print(server_upgrade.before) logging.info("X" * 80) logging.info("[X] Upgrading database files") break if i == 1: logging.info("X" * 80) ascii_print(server_upgrade.before) logging.info("X" * 80) logging.info("[ ] Update not needed.") break if i == 2: # modified arangod.conf... ascii_print(server_upgrade.before) server_upgrade.sendline('Y') # fallthrough - repeat. except pexpect.exceptions.EOF: logging.info("X" * 80) ascii_print(server_upgrade.before) logging.info("X" * 80) logging.info("[E] Upgrade failed!") sys.exit(1) try: logging.info("waiting for the upgrade to finish") server_upgrade.expect(pexpect.EOF, timeout=30) ascii_print(server_upgrade.before) except pexpect.exceptions.EOF: logging.info("TIMEOUT!")
def install_package(self): # pylint: disable=too-many-statements logging.info("installing Arangodb debian package") server_not_started = False os.environ['DEBIAN_FRONTEND'] = 'readline' self.cfg.passvoid = "sanoetuh" # TODO logging.debug("package dir: {0.cfg.package_dir}- " "server_package: {0.server_package}".format(self)) cmd = 'dpkg -i ' + str(self.cfg.package_dir / self.server_package) lh.log_cmd(cmd) server_install = pexpect.spawnu(cmd) try: logging.debug("expect: user1") i = server_install.expect(['user:'******'arangod.conf'], timeout=120) # there are remaints of previous installations. # We overwrite existing config files. if i == 1: server_install.sendline('Y') ascii_print(server_install.before) server_install.expect('user:'******'user:'******'is-active arangodb3.service'") >= 0 except pexpect.exceptions.EOF: logging.info("TIMEOUT!") while server_install.isalive(): progress('.') if server_install.exitstatus != 0: raise Exception( "server installation didn't finish successfully!") print() logging.info('Installation successfull') self.set_system_instance() if server_not_started: logging.info('Environment did not start arango service,' 'doing this now!') self.start_service() self.instance.detect_pid(1) # should be owned by init
def un_install_server_package_impl(self): """ uninstall the server package """ self.stop_service() cmd = ["rpm", "-e", "arangodb3" + ("e" if self.cfg.enterprise else "")] lh.log_cmd(cmd) run_cmd_and_log_stdout(cmd)