You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
219 lines
7.2 KiB
219 lines
7.2 KiB
# -*- coding: utf-8 -*-
|
|
|
|
# Copyright (C) 2011 Adam D. Barratt <adsb@debian.org>
|
|
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
|
|
import apt_pkg
|
|
import logging
|
|
from britney2 import SuiteClass
|
|
|
|
|
|
class MigrationItem(object):
|
|
|
|
def __init__(self, package=None, version=None, architecture=None,
|
|
suite=None, is_removal=False, is_cruft_removal=False):
|
|
|
|
if architecture is None:
|
|
architecture = 'source'
|
|
|
|
if is_cruft_removal:
|
|
is_removal = True
|
|
|
|
self._package = package
|
|
self._version = version
|
|
self._architecture = architecture
|
|
self._suite = suite
|
|
self._is_removal = is_removal
|
|
self._is_cruft_removal = is_cruft_removal
|
|
self._uvname = self.get_uvname()
|
|
self._name = self.get_name()
|
|
|
|
def get_name(self):
|
|
name = self._package
|
|
if self._architecture != "source":
|
|
name = "%s/%s" % (name, self._architecture)
|
|
if self._version:
|
|
name = "%s/%s" % (name, self._version)
|
|
if self._suite.excuses_suffix:
|
|
name = "%s_%s" % (name, self._suite.excuses_suffix)
|
|
if self._is_removal:
|
|
name = "-%s" % (name)
|
|
return name
|
|
|
|
def get_uvname(self):
|
|
name = self._package
|
|
if self._architecture != "source":
|
|
name = "%s/%s" % (name, self._architecture)
|
|
if self._suite.excuses_suffix:
|
|
name = "%s_%s" % (name, self._suite.excuses_suffix)
|
|
if self._is_removal:
|
|
name = "-%s" % (name)
|
|
return name
|
|
|
|
def __str__(self):
|
|
if self.version is not None:
|
|
return self.name
|
|
else:
|
|
return self.uvname
|
|
|
|
def __eq__(self, other):
|
|
isequal = False
|
|
if self.uvname == other.uvname:
|
|
if self.version is None or other.version is None:
|
|
isequal = True
|
|
else:
|
|
isequal = self.version == other.version
|
|
|
|
return isequal
|
|
|
|
def __hash__(self):
|
|
return hash((self.uvname, self.version))
|
|
|
|
def __lt__(self, other):
|
|
return (self.uvname, self.version) < (other.uvname, other.version)
|
|
|
|
@property
|
|
def name(self):
|
|
return self._name
|
|
|
|
@property
|
|
def is_removal(self):
|
|
return self._is_removal
|
|
|
|
@property
|
|
def architecture(self):
|
|
return self._architecture
|
|
|
|
@property
|
|
def package(self):
|
|
return self._package
|
|
|
|
@property
|
|
def suite(self):
|
|
return self._suite
|
|
|
|
@property
|
|
def version(self):
|
|
return self._version
|
|
|
|
@property
|
|
def uvname(self):
|
|
return self._uvname
|
|
|
|
@property
|
|
def is_cruft_removal(self):
|
|
return self._is_cruft_removal
|
|
|
|
|
|
class MigrationItemFactory(object):
|
|
|
|
def __init__(self, suites):
|
|
self._suites = suites
|
|
self._all_architectures = frozenset(suites.target_suite.binaries)
|
|
logger_name = ".".join((self.__class__.__module__, self.__class__.__name__))
|
|
self.logger = logging.getLogger(logger_name)
|
|
|
|
def generate_removal_for_cruft_item(self, pkg_id):
|
|
return MigrationItem(package=pkg_id.package_name,
|
|
version=pkg_id.version,
|
|
architecture=pkg_id.architecture,
|
|
suite=self._suites.target_suite,
|
|
is_cruft_removal=True,
|
|
)
|
|
|
|
@staticmethod
|
|
def _is_right_version(suite, package_name, expected_version):
|
|
if package_name not in suite.sources:
|
|
return False
|
|
|
|
actual_version = suite.sources[package_name].version
|
|
if apt_pkg.version_compare(actual_version, expected_version) != 0:
|
|
return False
|
|
|
|
return True
|
|
|
|
def _find_suite_for_item(self, suites, suite_name, package_name, version, auto_correct):
|
|
suite = suites.by_name_or_alias[suite_name]
|
|
assert suite.suite_class != SuiteClass.TARGET_SUITE
|
|
if version is not None and auto_correct and not self._is_right_version(suite, package_name, version):
|
|
for s in suites.source_suites:
|
|
if self._is_right_version(s, package_name, version):
|
|
suite = s
|
|
break
|
|
return suite
|
|
|
|
def parse_item(self, item_text, versioned=True, auto_correct=True):
|
|
"""
|
|
|
|
:param item_text: The string describing the item (e.g. "glibc/2.5")
|
|
:param versioned: If true, a two-part item is assumed to be versioned.
|
|
otherwise, it is assumed to be versionless. This determines how
|
|
items like "foo/bar" is parsed (if versioned, "bar" is assumed to
|
|
be a version and otherwise "bar" is assumed to be an architecture).
|
|
If in doubt, use versioned=True with auto_correct=True and the
|
|
code will figure it out on its own.
|
|
:param auto_correct: If True, minor issues are automatically fixed
|
|
where possible. This includes handling architecture and version
|
|
being in the wrong order and missing/omitting a suite reference
|
|
for items. This feature is useful for migration items provided
|
|
by humans (e.g. via hints) to avoid rejecting the input over
|
|
trivial/minor issues with the input.
|
|
When False, there will be no attempt to correct the migration
|
|
input.
|
|
:return: A MigrationItem matching the spec
|
|
"""
|
|
suites = self._suites
|
|
version = None
|
|
architecture = None
|
|
is_removal = False
|
|
if item_text.startswith('-'):
|
|
item_text = item_text[1:]
|
|
is_removal = True
|
|
parts = item_text.split('/', 3)
|
|
package_name = parts[0]
|
|
suite_name = suites.primary_source_suite.name
|
|
if '_' in package_name:
|
|
package_name, suite_name = package_name.split('_', 2)
|
|
|
|
if len(parts) == 3:
|
|
architecture = parts[1]
|
|
version = parts[2]
|
|
elif len(parts) == 2:
|
|
if versioned:
|
|
version = parts[1]
|
|
else:
|
|
architecture = parts[1]
|
|
|
|
if auto_correct and version in self._all_architectures:
|
|
(architecture, version) = (version, architecture)
|
|
|
|
if architecture is None:
|
|
architecture = 'source'
|
|
|
|
if '_' in architecture:
|
|
architecture, suite_name = architecture.split('_', 2)
|
|
|
|
if is_removal:
|
|
suite = suites.target_suite
|
|
else:
|
|
suite = self._find_suite_for_item(suites, suite_name, package_name, version, auto_correct)
|
|
|
|
return MigrationItem(package=package_name,
|
|
version=version,
|
|
architecture=architecture,
|
|
suite=suite,
|
|
is_removal=is_removal,
|
|
)
|
|
|
|
def parse_items(self, *args, **kwargs):
|
|
return [self.parse_item(x, **kwargs) for x in args]
|