python.Checks.FrozenTier0PolicyCheck Class Reference

Inheritance diagram for python.Checks.FrozenTier0PolicyCheck:

Collaboration diagram for python.Checks.FrozenTier0PolicyCheck:

Public Member Functions
None	__init__ (self, TestSetup setup, str input_format, int max_events)
bool	run (self, WorkflowTest test)
Optional[Path]	reference_file (self, "WorkflowTest" test, str file_name)

Public Attributes
	format
	max_events
	detailed_comparison
	setup
	logger

Detailed Description

Run Frozen Tier0 Policy Check.

Definition at line 105 of file Checks.py.

Constructor & Destructor Documentation

__init__()

None python.Checks.FrozenTier0PolicyCheck.__init__	(		self,
		TestSetup	setup,
		str	input_format,
		int	max_events
	)

Definition at line 108 of file Checks.py.

    def __init__(self, setup: TestSetup, input_format: str, max_events: int) -> None:
        super().__init__(setup)
        self.format = input_format
        self.max_events = str(max_events)
        self.detailed_comparison = setup.detailed_comparison
 

Member Function Documentation

reference_file()

Optional[Path] python.Test.WorkflowCheck.reference_file (   self, "WorkflowTest"  test, str  file_name  )

inherited

Definition at line 91 of file Tools/WorkflowTestRunner/python/Test.py.

    def reference_file(self, test: "WorkflowTest", file_name: str) -> Optional[Path]:
        reference_path: Path = test.reference_path
        reference_file = reference_path / file_name
 
        # Read references from CVMFS
        if self.setup.validation_only:
            # Resolve the subfolder first. Results are stored like: main_folder/branch/test/version/.
            reference_revision = references_map[f"{test.ID}"]
            cvmfs_path = Path(references_CVMFS_path)
            rel_path = Path(self.setup.release_ID) / test.ID / reference_revision
            reference_path = cvmfs_path / rel_path
            reference_file = reference_path / file_name
 
            if not reference_path.exists():
                self.logger.error(f"CVMFS reference location {reference_path} does not exist!")
                return None
 
            if references_override_url is not None:
                import requests
 
                url = references_override_url
                if not url.endswith("/"): url += "/"
                url += str(rel_path / file_name)
                self.logger.info("Checking for reference override at %s", url)
                if requests.head(url).ok: # file exists at url
                    reference_file = Path.cwd() / f"reference_{file_name}"
                    self.logger.info("Downloading reference from %s to %s", url, reference_file)
                    r = requests.get(url, stream=True)
                    with reference_file.open('wb') as f:
                        for chunk in r.iter_content(chunk_size=1024):
                            if chunk: # filter out keep-alive new chunks
                                f.write(chunk)
                else:
                    self.logger.info("No reference override found")
 
        return reference_file
 
 

run()

bool python.Checks.FrozenTier0PolicyCheck.run	(		self,
		WorkflowTest	test
	)

Definition at line 114 of file Checks.py.

    def run(self, test: WorkflowTest) -> bool:
        self.logger.info("---------------------------------------------------------------------------------------")
        self.logger.info(f"Running {test.ID} Frozen Tier0 Policy Check on {self.format} for {self.max_events} events")
 
        diff_rules_path: Path = self.setup.diff_rules_path
        diff_rules_exclusion_filename: str = f"{test.ID}_{self.format}_diff-exclusion-list.txt"
        diff_rules_interest_filename: str = f"{test.ID}_{self.format}_diff-interest-list.txt"
        diff_rules_file = None
 
        file_name = f"my{self.format}.pool.root"
        if test.type == WorkflowType.Derivation:
            file_name = f"{self.format}.myOutput.pool.root"
        reference_file = self.reference_file(test, file_name)
        if reference_file is None:
            self.logger.error(f"Reference file {file_name} not found")
            return False
 
        if self.setup.validation_only:
            cvmfs_path = Path(references_CVMFS_path)
            diff_rules_path = cvmfs_path / self.setup.release_ID / test.ID
 
        self.logger.info(f"Reading the reference file from location {reference_file}")
 
        # try to get the exclusion list or the list of branches of interest
        branches_of_interest = False
        if self.setup.diff_rules_path is None:
            diff_rules_exclusion_local_path = test.validation_path / diff_rules_exclusion_filename
            diff_rules_interest_local_path = test.validation_path / diff_rules_interest_filename
            subprocess.Popen(["/bin/bash", "-c", f"cd {test.validation_path}; get_files -remove -data {diff_rules_exclusion_filename}"], stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
            subprocess.Popen(["/bin/bash", "-c", f"cd {test.validation_path}; get_files -remove -data {diff_rules_interest_filename}"], stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
            if not diff_rules_exclusion_local_path.exists() and not diff_rules_interest_local_path.exists():
                self.logger.info(f"Neither '{diff_rules_exclusion_local_path}' nor '{diff_rules_interest_local_path}' files exist in the release.")
            elif diff_rules_exclusion_local_path.exists():
                diff_rules_file = diff_rules_exclusion_local_path
            elif diff_rules_interest_local_path.exists():
                diff_rules_file = diff_rules_interest_local_path
                branches_of_interest = True
 
        if diff_rules_file is None and diff_rules_path is not None:
            diff_rules_file = diff_rules_path / diff_rules_exclusion_filename
            if not diff_rules_file.exists():
                diff_rules_file = diff_rules_path / diff_rules_interest_filename
                if diff_rules_file.exists():
                    branches_of_interest = True
 
        if diff_rules_file is not None and diff_rules_file.exists():
            self.logger.info(f"Reading the diff rules file from location {diff_rules_file}")
            diff_root_list = []
            with diff_rules_file.open() as f:
                for line in f:
                    stripped_line = line.rstrip()
                    if stripped_line and stripped_line[0] != '#':
                        diff_root_list.append(r"'{}'".format(stripped_line))
        else:
            self.logger.info("No diff rules file exists, using the default list")
            diff_root_list = [r"'index_ref'", r"'(.*)_timings(.*)'", r"'(.*)_mems(.*)'"]
 
        validation_file = test.validation_path / file_name
        log_file = test.validation_path / f"diff-root-{test.ID}.{self.format}.log"
        diff_root_list = " ".join(diff_root_list)
        diff_root_mode = "--branches-of-interest" if branches_of_interest else "--ignore-leaves"
 
        comparison_mode = "detailed" if self.detailed_comparison else "semi-detailed"
        comparison_command = f"acmd.py diff-root {reference_file} {validation_file} --order-trees --nan-equal --exact-branches --mode {comparison_mode} --error-mode resilient {diff_root_mode} {diff_root_list} --entries {self.max_events} > {log_file} 2>&1"
        output, error = subprocess.Popen(["/bin/bash", "-c", comparison_command], stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
        output, error = output.decode("utf-8"), error.decode("utf-8")
 
        # We want to catch/print both container additions/subtractions as well as
        # changes in these containers.  `allGood_return_code` is meant to catch
        # other issues found in the diff (not expected, but just to be safe)
        passed_frozen_tier0_test = True
        all_good = False
        with log_file.open() as file:
            for line in file:
                if "WARNING" in line:  # Catches container addition/subtractions
                    self.logger.error(line.strip())
                    passed_frozen_tier0_test = False
                if "leaves differ" in line:  # Catches changes in branches
                    self.logger.error(line.strip())
                    passed_frozen_tier0_test = False
                if "ERROR" in line:  # Catches other issues (including unmatched branches)
                    self.logger.error(line.strip())
                    passed_frozen_tier0_test = False
                if "INFO all good." in line:
                    all_good = True
 
        result = passed_frozen_tier0_test and all_good
        if result:
            self.logger.info("Passed!\n")
        else:
            # print CI helper directly to avoid logger decorations
            if self.setup.disable_release_setup:
                self.logger.print(f"ATLAS-CI-ADD-LABEL: {test.run.value}-{test.type.value}-output-changed")
                self.logger.print("")
 
            if "DAOD" in self.format:
                self.logger.error(f"Your change breaks the frozen derivation policy in test {test.ID}.")
                self.logger.error("Please make sure you explain the reason for the change and ask relevant experts for approval.")
            else:
                self.logger.error(f"Your change breaks the frozen tier0 policy in test {test.ID}.")
                self.logger.error("Please make sure this has been discussed in the correct meeting (RIG or Simulation) meeting and approved by the relevant experts.")
 
            # copy the artifacts
            if self.setup.disable_release_setup:
                comparison_command = f"CopyCIArtifact.sh {validation_file}"
                output, error = subprocess.Popen(["/bin/bash", "-c", comparison_command], stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
                output, error = output.decode("utf-8"), error.decode("utf-8")
 
                if error or not output:
                    self.logger.error(f"Tried copying '{validation_file}' to the CI artifacts area but it failed.")
                    self.logger.error(f"  {error.strip()}")
                else:
                    self.logger.error(output)
 
            with log_file.open() as file:
                for line in file:
                    self.logger.info(f"  {line.strip()}")
                self.logger.info("-----------------------------------------------------\n")
 
        return result
 
 

Member Data Documentation

detailed_comparison

python.Checks.FrozenTier0PolicyCheck.detailed_comparison

Definition at line 112 of file Checks.py.

format

python.Checks.FrozenTier0PolicyCheck.format

Definition at line 110 of file Checks.py.

logger

python.Test.WorkflowCheck.logger

inherited

Definition at line 89 of file Tools/WorkflowTestRunner/python/Test.py.

max_events

python.Checks.FrozenTier0PolicyCheck.max_events

Definition at line 111 of file Checks.py.

setup

python.Test.WorkflowCheck.setup

inherited

Definition at line 88 of file Tools/WorkflowTestRunner/python/Test.py.

---

The documentation for this class was generated from the following file:

• Checks.py