def version_in(version: str, ver: PrototypeImport) -> bool: # log.debug('version_in: %s < %s > %s', ver.min_version, version, ver.max_version) if ver.min_strict: if rpm.compare_versions(version, ver.min_version) <= 0: return False elif ver.min_version: if rpm.compare_versions(version, ver.min_version) < 0: return False if ver.max_strict: if rpm.compare_versions(version, ver.max_version) >= 0: return False elif ver.max_version: if rpm.compare_versions(version, ver.max_version) > 0: return False return True
def version_in(version, ver): # log.debug('version_in: %s < %s > %s', ver.min_version, version, ver.max_version) if ver.min_strict: if rpm.compare_versions(version, ver.min_version) <= 0: return False else: if rpm.compare_versions(version, ver.min_version) < 0: return False if ver.max_strict: if rpm.compare_versions(version, ver.max_version) >= 0: return False else: if rpm.compare_versions(version, ver.max_version) > 0: return False return True
def _run_action_and_assert_result( obj: Union[Cluster, Service, Host, Component, Provider], action_name: str, expected_status="success", timeout=None, **kwargs, ): """ Run action and assert that status equals to 'status' argument """ obj_name = obj.name if not isinstance(obj, Host) else obj.fqdn with allure.step( f"Perform action '{action_name}' for {obj.__class__.__name__} '{obj_name}'" ), _suggest_action_if_not_exists(obj, action_name): if rpm.compare_versions( obj.adcm_version, "2021.02.04.13") >= 0 and "verbose" not in kwargs: kwargs["verbose"] = options.verbose_actions # pylint: disable=no-member obj.reread() try: action = obj.action(name=action_name) _add_actions_info(action=action, expected_status=expected_status) task = action.run(**kwargs) except ErrorMessage as err: ADCMError.raise_if_suitable(err.error.title) raise wait_for_task_and_assert_result(task=task, action_name=action_name, status=expected_status, timeout=timeout) return task
def determine_cves(package, version, os, cve_data): vulnerabilities = [] if package in cve_data: cves = cve_data[package] for cve in cves: if os in cves[cve]["releases"].keys(): urgency = cves[cve]["releases"][os]["urgency"] if "fixed_version" in cves[cve]["releases"][os]: fixed = cves[cve]["releases"][os]["fixed_version"] vulnerable = rpm.compare_versions(fixed, version) > 0 else: fixed = False vulnerable = True if vulnerable: latest = cves[cve]["releases"][os]["repositories"][os] vulnerability = { "cve": cve, "urgency": urgency, "fixed": fixed, "installed": version, "latest": latest, } vulnerabilities.append(vulnerability) return vulnerabilities
def _check_min_version(self): try: version = self._api.objects.info.list()['adcm_version'] except (KeyError, AttributeError): version = "0" if rpm.compare_versions(self._MIN_VERSION, version) > 0: raise ADCMApiError( "That client supports ADCM versions >= {}".format( self._MIN_VERSION))
def rpm_nvr_compare(nvr_a, nvr_b): """Compare the version-release parts of two name-release-version strings by RPM rules.""" n_a, v_a, r_a = nvr_a.rsplit('-', 2) n_b, v_b, r_b = nvr_b.rsplit('-', 2) if n_a != n_b: raise ValueError(f"{nvr_a} and {nvr_b} have different names") return compare_versions(nvr_a, nvr_b)
def check_upgrade_version(obj: Union[Cluster, HostProvider], upgrade: Upgrade) -> Tuple[bool, str]: proto = obj.prototype # log.debug('check %s < %s > %s', upgrade.min_version, proto.version, upgrade.max_version) if upgrade.min_strict: if rpm.compare_versions(proto.version, upgrade.min_version) <= 0: msg = '{} version {} is less than or equal to upgrade min version {}' return False, msg.format(proto.type, proto.version, upgrade.min_version) else: if rpm.compare_versions(proto.version, upgrade.min_version) < 0: msg = '{} version {} is less than upgrade min version {}' return False, msg.format(proto.type, proto.version, upgrade.min_version) if upgrade.max_strict: if rpm.compare_versions(proto.version, upgrade.max_version) >= 0: msg = '{} version {} is more than or equal to upgrade max version {}' return False, msg.format(proto.type, proto.version, upgrade.max_version) else: if rpm.compare_versions(proto.version, upgrade.max_version) > 0: msg = '{} version {} is more than upgrade max version {}' return False, msg.format(proto.type, proto.version, upgrade.max_version) return True, ''
def __new__(cls, *args, **kwargs): """ Set PATH=None, if adcm version < `2021.03.12.16`. See ADCM-1439. This method is associated with the action of the `legacy_server_implementaion()` decorator. """ wrapper = args[0] instance = super().__new__(cls) # !!! If you change the version, do not forget to change it in the component() # and component_list() methods of the Service class as well as in the comments to them if rpm.compare_versions(wrapper.adcm_version, '2021.03.12.16') < 0: instance.PATH = None return instance
def upgrade_adcm(adcm, bundle): old_proto = adcm.prototype new_proto = Prototype.objects.get(type='adcm', bundle=bundle) if rpm.compare_versions(old_proto.version, new_proto.version) >= 0: msg = 'Current adcm version {} is more than or equal to upgrade version {}' err('UPGRADE_ERROR', msg.format(old_proto.version, new_proto.version)) with transaction.atomic(): adcm.prototype = new_proto adcm.save() switch_config(adcm, new_proto, old_proto) log.info('upgrade adcm OK from version %s to %s', old_proto.version, adcm.prototype.version) return adcm
def check_upgrade_version(obj, upgrade): proto = obj.prototype # log.debug('check %s < %s > %s', upgrade.min_version, proto.version, upgrade.max_version) if upgrade.min_strict: if rpm.compare_versions(proto.version, upgrade.min_version) <= 0: msg = '{} version {} is less than or equal to upgrade min version {}' return False, msg.format(proto.type, proto.version, upgrade.min_version) else: if rpm.compare_versions(proto.version, upgrade.min_version) < 0: msg = '{} version {} is less than upgrade min version {}' return False, msg.format(proto.type, proto.version, upgrade.min_version) if upgrade.max_strict: if rpm.compare_versions(proto.version, upgrade.max_version) >= 0: msg = '{} version {} is more than or equal to upgrade max version {}' return False, msg.format(proto.type, proto.version, upgrade.max_version) else: if rpm.compare_versions(proto.version, upgrade.max_version) > 0: msg = '{} version {} is more than upgrade max version {}' return False, msg.format(proto.type, proto.version, upgrade.max_version) return True, ''
def order_model_versions(model): items = [] for obj in model.objects.all(): items.append(obj) ver = "" count = 0 for obj in sorted( items, key=functools.cmp_to_key(lambda obj1, obj2: rpm.compare_versions( obj1.version, obj2.version))): if ver != obj.version: count += 1 # log.debug("MODEL %s count: %s, %s %s", model, count, obj.name, obj.version) obj.version_order = count ver = obj.version # Update all table in one time. That is much faster than one by one method model.objects.bulk_update(items, ['version_order'])
def process_adcm(): sp = StagePrototype.objects.get(type='adcm') adcm = ADCM.objects.filter() if adcm: old_proto = adcm[0].prototype new_proto = sp if old_proto.version == new_proto.version: log.debug('adcm vesrion %s, skip upgrade', old_proto.version) elif rpm.compare_versions(old_proto.version, new_proto.version) < 0: bundle = copy_stage('adcm', sp) upgrade_adcm(adcm[0], bundle) else: msg = 'Current adcm version {} is more than or equal to upgrade version {}' err('UPGRADE_ERROR', msg.format(old_proto.version, new_proto.version)) else: bundle = copy_stage('adcm', sp) init_adcm(bundle)
def run(self, **args) -> "Task": with allure_step(f"Run action {self.name}"): if 'hc' in args: allure_attach_json(args.get('hc'), name="Hostcomponent map") if 'config' in args and 'config_diff' in args: raise TypeError( "only one argument is expected 'config' or 'config_diff'") if 'config' not in args: args['config'] = self._get_config() if 'config_diff' in args: config_diff = args.pop('config_diff') for item in self.config['config']: if item['type'] == 'group': continue key, subkey = item['name'], item['subname'] if subkey and subkey in config_diff.get(key, {}): args['config'][key][subkey] = config_diff[key][ subkey] elif not subkey and key in config_diff: args['config'][key] = config_diff[key] # check backward compatibility for `verbose` option if rpm.compare_versions(self.adcm_version, '2021.02.04.13') >= 0: args.setdefault('verbose', False) elif 'verbose' in args: warnings.warn( f"ADCM {self.adcm_version} doesn't support action " f"argument 'verbose'. It will be skipped") args.pop('verbose') try: data = self._subcall("run", "create", **args) except ErrorMessage as error: if (getattr(error.error, 'title', '') == '409 Conflict' and 'has issues' in getattr(error.error, '_data', {}).get('desc', '')): raise ActionHasIssues from error raise error return Task(self._api, task_id=data["id"])
def _filter_adcm_versions_from_tags(adcm_tags: List[str], min_ver: str) -> Iterator[str]: """ >>> this = _filter_adcm_versions_from_tags >>> list(this(["2021021506","2021030114","2021031007","latest","2021.05.26.12","2021.06.17.06"], "2019.03.01.14")) ['2021021506', '2021030114', '2021031007', '2021.05.26.12', '2021.06.17.06'] >>> list(this(["2021021506","2021030114","2021031007","latest","2021.05.26.12","2021.06.17.06"], "2021.03.01.14")) ['2021030114', '2021031007', '2021.05.26.12', '2021.06.17.06'] >>> list(this(["2021021506","2021030114","2021031007","latest","2021.05.26.12","2021.06.17.06"], "2021.05.26.12")) ['2021.05.26.12', '2021.06.17.06'] >>> list(this(["2021021506","2021030114","2021031007","latest","2021.05.26.12","2021.06.17.06"], "2022.05.26.12")) [] """ return filter( lambda x: (tag := x.replace(".", "")) and (tag.isdigit()) # noqa: W503 and (rpm.compare_versions(f"{tag[:4]}.{tag[4:6]}.{tag[6:8]}.{tag[8:10]}", min_ver[:13]) != -1), # noqa: W503 adcm_tags, )
def test_compare_versions(self): test_versions = [ ('~', 'aoi', -1), ('aoi', '~', 1), ('~', '~', 0), ('~', '~a', -1), ('1a', 'a1', 1), ('1a', '1b', -1), ('a1', 'a2', -1), ('1.2.3', '1.2.4', -1), ('1.02.4', '1.02a.4', 1), ('1.02a.4', '1.02b.4', -1), ('12345.6', '12345.6', 0), ('0.2.3', '1.2.4', -1), ('~1.2.3', '1.2.3', -1), ('1.2.3.a', '1.2.3.~alpha', 1) ] for a, b, exp in test_versions: res = rpm.compare_versions(a, b) self.assertEqual(exp, res, msg='Got {0} when comparing {1} to ' '{2}'.format(res, a, b))
def test_compare_versions(ver_a, ver_b, exp): res = rpm.compare_versions(ver_a, ver_b) assert exp == res
def check_adcm_version_changed(before: str, after: str) -> None: """Check if 'after' version is more recent that 'before'""" if rpm.compare_versions(after, before) < 1: raise AssertionError( "ADCM version after upgrade is older or equal to the version before" )
def _check_min_version(self): if rpm.compare_versions(self._MIN_VERSION, self._api.adcm_version) > -1: raise ADCMApiError( "The client supports ADCM versions newer than '{}'".format( self._MIN_VERSION))
def wrapper(self, *args, **kwargs): # adcm_version >= turnover_versions if rpm.compare_versions(self.adcm_version, turnover_version) < 0: return oldfunc(self, *args, **kwargs) return func(self, *args, **kwargs)
def wrapper(*args, **kwargs): # The ADCM version must be greater than or equal to the method version # args[0].adcm_version >= version if rpm.compare_versions(args[0].adcm_version, version) < 0: raise TooOldServerVersion(func.__name__, version) return func(*args, **kwargs)
def check_adcm_version(bundle): if not bundle.adcm_min_version: return if rpm.compare_versions(bundle.adcm_min_version, ADCM_VERSION) > 0: msg = 'This bundle required ADCM version equal to {} or newer.' err('BUNDLE_VERSION_ERROR', msg.format(bundle.adcm_min_version))
def rpm_cmp_reverse(obj1, obj2): return rpm.compare_versions(obj2.name, obj1.name)