def pre_start(self): """ Create mandatory directories and install files from given templates using the drivers context before starting the application binary. """ super(App, self).pre_start() self._make_dirs() if self.cfg.path_cleanup is True: name = os.path.basename(self.cfg.binary) else: name = "{}-{}".format(os.path.basename(self.cfg.binary), uuid.uuid4()) self.binary = self._prepare_binary(self.cfg.binary) if os.path.isfile(self.binary): target = os.path.join(self._binpath, name) if self.cfg.binary_strategy == "copy": shutil.copyfile(self.binary, target) self.binary = target elif self.cfg.binary_strategy == "link" and not IS_WIN: os.symlink(os.path.abspath(self.binary), target) self.binary = target # else binary_strategy is noop then we don't do anything makedirs(self.app_path) self.std = StdFiles(self.app_path) if self.cfg.install_files: self._install_files()
def pre_start(self): """ Create mandatory directories and install files from given templates using the drivers context before starting the application binary. """ super(App, self).pre_start() self._make_dirs() if self.cfg.binary_copy: if self.cfg.path_cleanup is True: name = os.path.basename(self.cfg.binary) else: name = '{}-{}'.format(os.path.basename(self.cfg.binary), uuid.uuid4()) target = os.path.join(self._binpath, name) shutil.copyfile(self.cfg.binary, target) self.binary = target else: self.binary = self.cfg.binary makedirs(self.app_path) self.std = StdFiles(self.app_path) if self.cfg.install_files: self._install_files()
def make_runpath_dirs(self): """ Creates runpath related directories. """ if self._runpath is None: raise RuntimeError( "{} runpath cannot be None".format(self.__class__.__name__) ) self.logger.test_info( f"Testplan has runpath: {self._runpath} and pid {os.getpid()}" ) self._scratch = os.path.join(self._runpath, "scratch") if self.cfg.path_cleanup is False: makedirs(self._runpath) makedirs(self._scratch) else: makeemptydirs(self._runpath) makeemptydirs(self._scratch) with open( os.path.join(self._runpath, self.runid_filename), "wb" ) as fp: pass
def _make_dirs(self): bin_dir = os.path.join(self.runpath, 'bin') etc_dir = os.path.join(self.runpath, 'etc') for directory in (bin_dir, etc_dir): makedirs(directory) self._binpath = bin_dir self._etcpath = etc_dir
def export(self, source): json_path = self.cfg.json_path if len(source): test_plan_schema = TestReportSchema(strict=True) data = test_plan_schema.dump(source).data attachments_dir = os.path.join( os.path.dirname(json_path), defaults.ATTACHMENTS ) # Save the Testplan report. if self.cfg.split_json_report: ( structure_filename, assertions_filename, ) = gen_attached_report_names(json_path) structure_filepath = os.path.join( attachments_dir, structure_filename ) assertions_filepath = os.path.join( attachments_dir, assertions_filename ) meta, structure, assertions = self.split_json_report(data) makedirs(attachments_dir) with open(structure_filepath, "w") as json_file: json.dump(structure, json_file) with open(assertions_filepath, "w") as json_file: json.dump(assertions, json_file) save_attachments(report=source, directory=attachments_dir) meta["version"] = 2 # Modify dict ref may change the original `TestReport` object meta["attachments"] = copy.deepcopy(meta["attachments"]) meta["attachments"][structure_filename] = structure_filepath meta["attachments"][assertions_filename] = assertions_filepath meta["structure_file"] = structure_filename meta["assertions_file"] = assertions_filename with open(json_path, "w") as json_file: json.dump(meta, json_file) else: save_attachments(report=source, directory=attachments_dir) data["version"] = 1 with open(json_path, "w") as json_file: json.dump(data, json_file) self.logger.exporter_info( "JSON generated at %s", os.path.abspath(json_path) ) else: self.logger.exporter_info( "Skipping JSON creation for empty report: %s", source.name )
def pre_start(self): super(KafkaStandalone, self).pre_start() self.log_path = os.path.join(self.runpath, "log") self.etc_path = os.path.join(self.runpath, "etc") for directory in (self.log_path, self.etc_path): if self.cfg.path_cleanup is False: makedirs(directory) else: makeemptydirs(directory) self.config = os.path.join(self.runpath, "etc", "server.properties") instantiate(self.cfg.cfg_template, self.context_input(), self.config)
def _pull_files(self): """Pull custom files from remote host.""" pull_dst = os.path.join(self.runpath, "pulled_files") makedirs(pull_dst) for entry in self.cfg.pull: self._transfer_data( source=entry, remote_source=True, target=pull_dst, exclude=self.cfg.pull_exclude, )
def save_attachments(report, directory): """ Save the report attachments to the given directory. :param report: Testplan report. :type report: ``testplan.testing.report.TestReport`` :param directory: Directory to save attachments in. :type directory: ``str`` """ attachments = getattr(report, 'attachments', None) if attachments: for dst, src in attachments.items(): dst_path = os.path.join(directory, dst) makedirs(os.path.dirname(dst_path)) copyfile(src=src, dst=dst_path)
def starting(self): """ Create mandatory directories, install files from given templates using the drivers context and starts the application binary. """ super(App, self).starting() self._make_dirs() if self.cfg.binary_copy: if self.cfg.path_cleanup is True: name = os.path.basename(self.cfg.binary) else: name = '{}-{}'.format(os.path.basename(self.cfg.binary), uuid.uuid4()) target = os.path.join(self._binpath, name) shutil.copyfile(self.cfg.binary, target) self.binary = target else: self.binary = self.cfg.binary makedirs(self.app_path) self.std = StdFiles(self.app_path) if self.cfg.install_files: self._install_files() cmd = ' '.join(self.cmd) if self.cfg.shell else self.cmd cwd = self.cfg.working_dir or self.runpath try: self.logger.debug('{driver} driver command: {cmd},{linesep}' '\trunpath: {runpath}{linesep}' '\tout/err files {out} - {err}'.format( driver=self.uid(), cmd=cmd, runpath=self.runpath, linesep=os.linesep, out=self.std.out_path, err=self.std.err_path)) self.proc = subprocess.Popen(cmd, shell=self.cfg.shell, stdout=self.std.out, stderr=self.std.err, cwd=cwd, env=self.cfg.env) except Exception: TESTPLAN_LOGGER.error( 'Error while App[%s] driver executed command: %s', self.cfg.name, cmd if self.cfg.shell else ' '.join(cmd)) raise
def _pull_files(self): """Push custom files to be available on remotes.""" for entry in [itm.rstrip('/') for itm in self.cfg.pull]: # Prepare target path for possible windows usage. dirname = os.sep.join(os.path.dirname(entry).split('/')) try: makedirs(dirname) except Exception as exc: self.logger.error('Cound not create {} directory - {}'.format( dirname, exc)) else: self._transfer_data(source=entry, remote_source=True, target=dirname, exclude=self.cfg.pull_exclude)
def save_attachments(report: TestReport, directory: str) -> Dict[str, str]: """ Saves the report attachments to the given directory. :param report: Testplan report. :param directory: directory to save attachments in :return: dictionary of destination paths """ moved_attachments = {} attachments = getattr(report, "attachments", None) if attachments: for dst, src in attachments.items(): dst_path = os.path.join(directory, dst) makedirs(os.path.dirname(dst_path)) copyfile(src=src, dst=dst_path) moved_attachments[dst] = dst_path return moved_attachments
def make_runpath_dirs(self): """ Creates runpath related directories. """ self._runpath = self.generate_runpath() self._scratch = os.path.join(self._runpath, "scratch") if self.runpath is None: raise RuntimeError("{} runpath cannot be None".format( self.__class__.__name__)) self.logger.debug("{} has {} runpath and pid {}".format( self.__class__.__name__, self.runpath, os.getpid())) if self.cfg.path_cleanup is False: makedirs(self._runpath) makedirs(self._scratch) else: makeemptydirs(self._runpath) makeemptydirs(self._scratch)
def setup(self, env, result): makedirs(os.path.dirname(self._tmp_file)) if not os.path.exists(self._tmp_file): self._iteration = 0 else: with open(self._tmp_file, "r") as fp: try: self._iteration = int(fp.read()) except Exception: self._iteration = 0 if self._iteration == self._max_retries: # iter starts from zero os.remove(self._tmp_file) else: with open(self._tmp_file, "w") as fp: fp.write(str(self._iteration + 1)) result.log("Suite setup in iteration {}".format(self._iteration))
def setup(self, env, result): """ Create a tmp text file which record how many times the suite has been executed, should remove it after the last rerun. """ makedirs(os.path.dirname(self._tmp_file)) if not os.path.exists(self._tmp_file): self._iteration = 0 else: with open(self._tmp_file, "r") as fp: self._iteration = int(fp.read()) if self._iteration == self._max_rerun: os.remove(self._tmp_file) else: with open(self._tmp_file, "w") as fp: fp.write(str(self._iteration + 1)) result.log("Suite setup in iteration {}".format(self._iteration))
def pre_start(self): """ Create mandatory directories and install files from given templates using the drivers context before starting zookeeper. """ super(ZookeeperStandalone, self).pre_start() self.zkdata_path = os.path.join(self.runpath, "zkdata") self.zklog_path = os.path.join(self.runpath, "zklog") self.etc_path = os.path.join(self.runpath, "etc") self.env["ZOO_LOG_DIR"] = self.zklog_path for directory in (self.zkdata_path, self.zklog_path, self.etc_path): if self.cfg.path_cleanup is False: makedirs(directory) else: makeemptydirs(directory) self.config = os.path.join(self.runpath, "etc", "zookeeper.cfg") if self.port == 0: raise RuntimeError("Zookeeper doesn't support random port") instantiate(self.cfg.cfg_template, self.context_input(), self.config)
def make_runpath_dirs(self): """ Creates runpath related directories. """ self.define_runpath() if self._runpath is None: raise RuntimeError( f"{self.__class__.__name__} runpath cannot be None") self._scratch = os.path.join(self._runpath, "scratch") self.logger.debug("%s has %s runpath and pid %d", self, self.runpath, os.getpid()) if self.cfg.path_cleanup is False: makedirs(self._runpath) makedirs(self._scratch) else: makeemptydirs(self._runpath) makeemptydirs(self._scratch)
def __init__( self, dirpath, description=None, ignore=None, only=None, recursive=False, dst_path=None, scratch_path=None, ): self.source_path = dirpath self.ignore = ignore self.only = only self.recursive = recursive self.dst_path = (dst_path or hashlib.md5( self.source_path.encode("utf-8")).hexdigest()) self.file_list = traverse_dir( self.source_path, topdown=True, ignore=ignore, only=only, recursive=recursive, include_subdir=False, ) if scratch_path: # will best effort make a copy of the file for fpath in self.file_list: src_path = os.path.join(self.source_path, fpath) dst_path = os.path.join(scratch_path, self.dst_path, fpath) makedirs(os.path.dirname(dst_path)) try: shutil.copyfile(src_path, dst_path) except Exception: break else: self.source_path = os.path.join(scratch_path, self.dst_path) super(Directory, self).__init__(description=description)