def get_distro_series_info_row(series):
"""Returns the distro series row information from python-distro-info.
"""
info = UbuntuDistroInfo()
for row in info._avail(info._date):
if row['series'] == series:
return row
return None
def get_release_title(self, release):
info = UbuntuDistroInfo()
for row in info._avail(info._date):
row_dict = row
if not isinstance(row, dict):
row_dict = row.__dict__
if row_dict['series'] == release:
return info._format("fullname", row)
return None
def test_get_supported_commissioning_releases_excludes_non_lts(self):
supported = ['precise', 'trusty', 'vivid', 'wily', 'xenial']
self.patch_autospec(UbuntuDistroInfo,
"supported").return_value = supported
osystem = UbuntuOS()
releases = osystem.get_supported_commissioning_releases()
self.assertIsInstance(releases, list)
udi = UbuntuDistroInfo()
non_lts_releases = [name for name in supported if not udi.is_lts(name)]
for release in non_lts_releases:
self.assertNotIn(release, releases)
def get_distro_series_info_row(series):
"""Returns the distro series row information from python-distro-info."""
info = UbuntuDistroInfo()
for row in info._avail(info._date):
# LP: #1711191 - distro-info 0.16+ no longer returns dictionaries or
# lists, and it now returns objects instead. As such, we need to
# handle both cases for backwards compatibility.
if not isinstance(row, dict):
row = row.__dict__
if row["series"] == series:
return row
return None
def is_distro_valid(self, distro, force=False):
if force:
return UbuntuDistroInfo().valid(distro)
if distro == self.get_host_distro_release():
return True
supported_distros = UbuntuDistroInfo().supported()
try:
supported_distros.index(distro)
except ValueError:
return False
return True
def is_distro_valid(self, distro, force=False):
if force:
return UbuntuDistroInfo().valid(distro)
if distro == self.get_host_distro_release():
return True
supported_distros = UbuntuDistroInfo().supported()
try:
supported_distros.index(distro)
except ValueError:
return False
return True
def get_release_from_distro_info(string):
"""Convert an Ubuntu release or version into a release dict.
This data is pulled from the UbuntuDistroInfo library which contains
additional information such as the release, EOL, and code name."""
ubuntu = UbuntuDistroInfo()
release_found = False
# We can only look at release names for 12.04+ as previous versions
# have overlapping first letters(e.g Warty and Wily) which break looking
# up old style kernels(e.g hwe-w).
try:
ubuntu_rows = ubuntu._rows
except AttributeError:
ubuntu_rows = [row.__dict__ for row in ubuntu._releases]
for row in ubuntu_rows:
if (
int(row["version"].split(".")[0]) >= 12
and row["series"].startswith(string)
or row["version"].startswith(string)
):
release_found = True
break
if release_found:
return row
else:
return None
def make_boot_sources(self):
kernels = []
ubuntu = UbuntuDistroInfo()
for row in ubuntu._rows:
release_year = int(row['version'].split('.')[0])
if release_year < 12:
continue
elif release_year < 16:
style = row['series'][0]
else:
style = row['version']
for kflavor in [
'generic', 'lowlatency', 'edge', 'lowlatency-edge'
]:
if kflavor == 'generic':
kernel = "hwe-%s" % style
else:
kernel = "hwe-%s-%s" % (style, kflavor)
arch = factory.make_name('arch')
architecture = "%s/%s" % (arch, kernel)
release = row['series'].split(' ')[0]
factory.make_usable_boot_resource(
name="ubuntu/" + release,
kflavor=kflavor,
extra={'subarches': kernel},
architecture=architecture,
rtype=BOOT_RESOURCE_TYPE.SYNCED)
factory.make_BootSourceCache(os="ubuntu",
arch=arch,
subarch=kernel,
release=release)
kernels.append((kernel, '%s (%s)' % (release, kernel)))
return kernels
def make_boot_source_cache(self):
# Disable boot sources signals otherwise the test fails due to unrun
# post-commit tasks at the end of the test.
self.useFixture(SignalsDisabled("bootsources"))
ubuntu = UbuntuDistroInfo()
try:
ubuntu_rows = ubuntu._rows
except AttributeError:
ubuntu_rows = [row.__dict__ for row in ubuntu._releases]
supported_releases = [
release
for release in ubuntu_rows
if int(release["version"].split(".")[0]) >= 12
]
release = random.choice(supported_releases)
ga_or_hwe = random.choice(["hwe", "ga"])
subarch = "%s-%s" % (ga_or_hwe, release["version"].split(" ")[0])
factory.make_BootSourceCache(
os="ubuntu",
arch=factory.make_name("arch"),
subarch=subarch,
release=release["series"],
release_codename=release["codename"],
release_title=release["version"],
support_eol=release.get("eol_server", release.get("eol-server")),
)
return release
def make_boot_source_cache(self):
# Disable boot sources signals otherwise the test fails due to unrun
# post-commit tasks at the end of the test.
self.useFixture(SignalsDisabled("bootsources"))
ubuntu = UbuntuDistroInfo()
try:
ubuntu_rows = ubuntu._rows
except AttributeError:
ubuntu_rows = [row.__dict__ for row in ubuntu._releases]
supported_releases = [
release for release in ubuntu_rows
if int(release['version'].split('.')[0]) >= 12
]
release = random.choice(supported_releases)
ga_or_hwe = random.choice(['hwe', 'ga'])
subarch = "%s-%s" % (ga_or_hwe, release['version'].split(' ')[0])
factory.make_BootSourceCache(
os='ubuntu',
arch=factory.make_name('arch'),
subarch=subarch,
release=release['series'],
release_codename=release['codename'],
release_title=release['version'],
support_eol=release.get('eol_server', release.get('eol-server')),
)
return release
def make_kernel_string(self,
can_be_release_or_version=False,
generic_only=False):
ubuntu = UbuntuDistroInfo()
# Only select from MAAS supported releases so we don't have to deal
# with versions name overlap(e.g Warty and Wily).
try:
ubuntu_rows = ubuntu._rows
except AttributeError:
ubuntu_rows = [row.__dict__ for row in ubuntu._releases]
supported_releases = [
release for release in ubuntu_rows
if int(release["version"].split(".")[0]) >= 12
]
release = random.choice(supported_releases)
# Remove 'LTS' from version if it exists
version_str = release["version"].split(" ")[0]
strings = [
"hwe-%s" % release["series"][0],
"hwe-%s" % version_str,
"hwe-%s-edge" % version_str,
]
if not generic_only:
strings += [
"hwe-%s-lowlatency" % version_str,
"hwe-%s-lowlatency-edge" % version_str,
]
if can_be_release_or_version:
strings += [release["series"], version_str]
return random.choice(strings)
def pick_release(self):
ubuntu = UbuntuDistroInfo()
supported_releases = [
release for release in ubuntu._rows
if int(release['version'].split('.')[0]) >= 12
]
return random.choice(supported_releases)
def get_distro_codename(self, distro):
ubuntu_distro_info = UbuntuDistroInfo()
for row in ubuntu_distro_info._rows:
if row['series'] == distro:
return row['codename']
return None
def pick_release(self):
ubuntu = UbuntuDistroInfo()
try:
ubuntu_rows = ubuntu._rows
except AttributeError:
ubuntu_rows = [row.__dict__ for row in ubuntu._releases]
supported_releases = [
release for release in ubuntu_rows
if int(release["version"].split(".")[0]) >= 12
]
return random.choice(supported_releases)
def get_uploads_per_release(email):
"""
Takes an email and returns an ordered dict of uploads per release.
"""
uploads_per_release = OrderedDict([])
for d in UbuntuDistroInfo().all:
release_uploads = len(Uploads.objects.filter(
email_changer=email).filter(release__icontains=d))
if uploads_per_release or release_uploads > 0:
uploads_per_release[d] = release_uploads
return uploads_per_release
def get_uploads_per_release(email):
"""
Takes an email and returns an ordered dict of uploads per release.
"""
uploads_per_release = OrderedDict([])
person = get_object_or_404(Person, email=email, authoritative_person=None)
for d in UbuntuDistroInfo().all:
release_uploads = len(Activity.objects.filter(
person=person).filter(release__icontains=d))
if uploads_per_release or release_uploads > 0:
uploads_per_release[d] = release_uploads
return uploads_per_release
def check_supported_distribution(changes, profile, interface):
"""
The ``supported-distribution`` checker is a stock dput checker that checks
packages intended for upload for a valid upload distribution.
Profile key: supported-distribution
"""
suite = changes['Distribution']
if profile.get('codenames'):
if '-' in suite:
release, pocket = suite.split('-', 1)
else:
release, pocket = suite, 'release'
codenames = profile['codenames']
if codenames == 'ubuntu':
distro_info = UbuntuDistroInfo()
pockets = profile['supported-distribution']
logger.critical(pockets)
if pocket not in pockets['known']:
raise UnknownDistribution("Unkown pocket: %s" % pocket)
if pocket not in pockets['allowed']:
raise UnknownDistribution(
"Uploads aren't permitted to pocket: %s" % pocket)
elif codenames == 'debian':
distro_info = DebianDistroInfo()
else:
raise UnknownDistribution("distro-info doesn't know about %s"
% codenames)
try:
codename = distro_info.codename(release, default=release)
if codename not in distro_info.all:
raise UnsupportedDistribution('Unknown release %s' % release)
if codename not in distro_info.supported():
raise UnsupportedDistribution('Unsupported release %s'
% release)
except DistroDataOutdated:
logger.warn('distro-info is outdated, '
'unable to check supported releases')
class UbuntuRelease(object):
all_codenames = UbuntuDistroInfo().all
def __init__(self, codename):
if codename not in UbuntuRelease.all_codenames:
raise ValueError("Unknown codename '{}'".format(codename))
self.codename = codename
def __eq__(self, other):
return UbuntuRelease.all_codenames.index(
self.codename) == UbuntuRelease.all_codenames.index(other)
def __le__(self, other):
return UbuntuRelease.all_codenames.index(
self.codename) <= UbuntuRelease.all_codenames.index(other)
def _get_release_names():
global _DEBIAN_RELEASES, _UBUNTU_RELEASES
try:
from distro_info import DebianDistroInfo, UbuntuDistroInfo
except ImportError:
warning("distro_info not available. Unable to retrieve current "
"list of releases.")
_DEBIAN_RELEASES = []
_UBUNTU_RELEASES = []
else:
# distro info is not available
_DEBIAN_RELEASES = DebianDistroInfo().all
_UBUNTU_RELEASES = UbuntuDistroInfo().all
_DEBIAN_RELEASES.extend(['stable', 'testing', 'unstable', 'frozen'])
def make_boot_sources(self):
kernels = []
ubuntu = UbuntuDistroInfo()
# LP: #1711191 - distro-info 0.16+ no longer returns dictionaries or
# lists, and it now returns objects instead. As such, we need to
# handle both cases for backwards compatibility.
try:
ubuntu_rows = ubuntu._rows
except AttributeError:
ubuntu_rows = [row.__dict__ for row in ubuntu._releases]
for row in ubuntu_rows:
release_year = int(row["version"].split(".")[0])
if release_year < 12:
continue
elif release_year < 16:
style = row["series"][0]
else:
style = row["version"]
for kflavor in [
"generic",
"lowlatency",
"edge",
"lowlatency-edge",
]:
if kflavor == "generic":
kernel = "hwe-%s" % style
else:
kernel = "hwe-%s-%s" % (style, kflavor)
arch = factory.make_name("arch")
architecture = "%s/%s" % (arch, kernel)
release = row["series"].split(" ")[0]
factory.make_usable_boot_resource(
name="ubuntu/" + release,
kflavor=kflavor,
extra={"subarches": kernel},
architecture=architecture,
rtype=BOOT_RESOURCE_TYPE.SYNCED,
)
factory.make_BootSourceCache(os="ubuntu",
arch=arch,
subarch=kernel,
release=release)
kernels.append((kernel, "%s (%s)" % (release, kernel)))
return kernels
def make_kernel_string(
self, can_be_release_or_version=False, generic_only=False):
ubuntu = UbuntuDistroInfo()
# Only select from MAAS supported releases so we don't have to deal
# with versions name overlap(e.g Warty and Wily).
supported_releases = [
release for release in ubuntu._rows
if int(release['version'].split('.')[0]) >= 12
]
release = random.choice(supported_releases)
# Remove 'LTS' from version if it exists
version_str = release['version'].split(' ')[0]
strings = [
"hwe-%s" % release['series'][0], "hwe-%s" % version_str,
"hwe-%s-edge" % version_str,
]
if not generic_only:
strings += [
"hwe-%s-lowlatency" % version_str,
"hwe-%s-lowlatency-edge" % version_str,
]
if can_be_release_or_version:
strings += [release['series'], version_str]
return random.choice(strings)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
ubuntu = UbuntuDistroInfo()
# We can't test with releases older than Precise as they have duplicate
# names(e.g Wily and Warty) which will break the old style kernel
# tests.
try:
ubuntu_rows = ubuntu._rows
except AttributeError:
ubuntu_rows = [row.__dict__ for row in ubuntu._releases]
valid_releases = [
row
for row in ubuntu_rows
if int(row["version"].split(".")[0]) >= 12
]
release = random.choice(valid_releases)
# Remove 'LTS' from version if it exists
version_str = release["version"].split(" ")[0]
# Convert the version into a list of ints
version_tuple = tuple([int(seg) for seg in version_str.split(".")])
self.scenarios = (
(
"Release name",
{
"string": release["series"],
"expected": version_tuple + tuple([0]),
},
),
(
"Release version",
{
"string": version_str,
"expected": version_tuple + tuple([0]),
},
),
(
"Old style kernel",
{
"string": "hwe-%s" % release["series"][0],
"expected": version_tuple + tuple([0]),
},
),
(
"GA kernel",
{
"string": "ga-%s" % version_str,
"expected": version_tuple + tuple([0]),
},
),
(
"GA low latency kernel",
{
"string": "ga-%s-lowlatency" % version_str,
"expected": version_tuple + tuple([0]),
},
),
(
"New style kernel",
{
"string": "hwe-%s" % version_str,
"expected": version_tuple + tuple([1]),
},
),
(
"New style edge kernel",
{
"string": "hwe-%s-edge" % version_str,
"expected": version_tuple + tuple([2]),
},
),
(
"New style low latency kernel",
{
"string": "hwe-%s-lowlatency" % version_str,
"expected": version_tuple + tuple([1]),
},
),
(
"New style edge low latency kernel",
{
"string": "hwe-%s-lowlatency-edge" % version_str,
"expected": version_tuple + tuple([2]),
},
),
(
"Rolling kernel",
{"string": "hwe-rolling", "expected": tuple([999, 999, 1])},
),
(
"Rolling edge kernel",
{
"string": "hwe-rolling-edge",
"expected": tuple([999, 999, 2]),
},
),
(
"Rolling lowlatency kernel",
{
"string": "hwe-rolling-lowlatency",
"expected": tuple([999, 999, 1]),
},
),
(
"Rolling lowlatency edge kernel",
{
"string": "hwe-rolling-lowlatency-edge",
"expected": tuple([999, 999, 2]),
},
),
)
class UbuntuDistroInfoTestCase(unittest.TestCase):
"""TestCase object for distro_info.UbuntuDistroInfo"""
#pylint: disable=C0103
def setUp(self):
self._distro_info = UbuntuDistroInfo()
self._date = datetime.date(2011, 1, 10)
#pylint: enable=C0103
def test_all(self):
"""Test: List all known Ubuntu distributions."""
all_distros = set(["warty", "hoary", "breezy", "dapper", "edgy",
"feisty", "gutsy", "hardy", "intrepid", "jaunty",
"karmic", "lucid", "maverick", "natty"])
self.assertEqual(all_distros - set(self._distro_info.all), set())
def test_devel(self):
"""Test: Get latest development Ubuntu distribution."""
self.assertEqual(self._distro_info.devel(self._date), "natty")
def test_lts(self):
"""Test: Get latest long term support (LTS) Ubuntu distribution."""
self.assertEqual(self._distro_info.lts(self._date), "lucid")
def test_stable(self):
"""Test: Get latest stable Ubuntu distribution."""
self.assertEqual(self._distro_info.stable(self._date), "maverick")
def test_supported(self):
"""Test: List all supported Ubuntu distribution."""
supported = ["dapper", "hardy", "karmic", "lucid", "maverick", "natty"]
self.assertEqual(self._distro_info.supported(self._date), supported)
def test_unsupported(self):
"""Test: List all unsupported Ubuntu distributions."""
unsupported = ["warty", "hoary", "breezy", "edgy", "feisty", "gutsy",
"intrepid", "jaunty"]
self.assertEqual(self._distro_info.unsupported(self._date), unsupported)
def test_current_unsupported(self):
"""Test: List all unsupported Ubuntu distributions today."""
unsupported = set(["warty", "hoary", "breezy", "edgy", "feisty",
"gutsy", "intrepid", "jaunty"])
self.assertEqual(unsupported -
set(self._distro_info.unsupported()), set())
def test_valid(self):
"""Test: Check for valid Ubuntu distribution."""
self.assertTrue(self._distro_info.valid("lucid"))
self.assertFalse(self._distro_info.valid("42"))
def test_is_lts(self):
"""Test: Check if Ubuntu distribution is an LTS."""
self.assertTrue(self._distro_info.is_lts("lucid"))
self.assertFalse(self._distro_info.is_lts("42"))
self.assertFalse(self._distro_info.is_lts("warty"))
def test_codename(self):
"""Test: Check result set to codename."""
self.assertEqual(self._distro_info.lts(self._date, "codename"), "lucid")
self.assertEqual(self._distro_info.devel(self._date, result="codename"),
"natty")
def test_fullname(self):
"""Test: Check result set to fullname."""
self.assertEqual(self._distro_info.stable(self._date, "fullname"),
'Ubuntu 10.10 "Maverick Meerkat"')
self.assertEqual(self._distro_info.lts(self._date, result="fullname"),
'Ubuntu 10.04 LTS "Lucid Lynx"')
def test_release(self):
"""Test: Check result set to release."""
self.assertEqual(self._distro_info.devel(self._date, "release"),
"11.04")
self.assertEqual(self._distro_info.lts(self._date, result="release"),
"10.04 LTS")
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import os, re
from flask import Flask, Response, Markup, request, render_template, make_response
from distro_info import DebianDistroInfo, UbuntuDistroInfo
debian = DebianDistroInfo()
ubuntu = UbuntuDistroInfo()
supported = list(reversed(debian.supported())) + list(
reversed(ubuntu.supported()))
app = Flask(__name__)
_pattern = re.compile("^([0-9a-f]{8})$")
def get_file_path(remote_addr, file_name, series=None, code=None):
if code and code == "default":
return os.path.join(app.root_path, file_name)
ip_addr = ''
if code and _pattern.match(code):
for i in (0, 2, 4, 6):
ip_addr = ip_addr + str(int("0x" + code[i:i + 2], 16)) + '.'
else:
ip_addr = ip_addr[:-1]
if series and series in supported:
if ip_addr:
def setUp(self):
self._distro_info = UbuntuDistroInfo()
self._date = datetime.date(2011, 1, 10)
def get_lts_release(self):
return UbuntuDistroInfo().lts()
def test_get_release_title(self):
osystem = UbuntuOS()
info = UbuntuDistroInfo()
release = random.choice(info.all)
self.assertEqual(osystem.get_release_title(release),
self.get_release_title(release))
def test_is_release_supported(self):
osystem = UbuntuOS()
info = UbuntuDistroInfo()
self.assertTrue(osystem.is_release_supported(random.choice(info.all)))
def sponsor_patch(bug_number, build, builder, edit, keyid, lpinstance, update,
upload, workdir):
workdir = os.path.realpath(os.path.expanduser(workdir))
_create_and_change_into(workdir)
launchpad = Launchpad.login_with("sponsor-patch", lpinstance)
bug = launchpad.bugs[bug_number]
(patch, branch) = get_patch_or_branch(bug)
task = get_open_ubuntu_bug_task(launchpad, bug, branch)
dsc_file = task.download_source()
_download_and_change_into(task, dsc_file, patch, branch)
source_package = SourcePackage(task.package, builder, workdir, branch)
if is_sync(bug) and not edit:
successful = source_package.reload_changelog()
if successful:
source_package.check_sync_request_version(bug_number, task)
previous_version = task.get_previous_version()
successful = source_package.check_version(previous_version)
if successful:
if build:
dist = UbuntuDistroInfo().devel()
successful = source_package.build(update, dist)
update = False
else:
# We are going to run lintian, so we need a source package
successful = source_package.build_source(
None, upload, previous_version)
if successful:
series = task.get_debian_source_series()
if source_package.sync(upload, series, bug_number, bug.owner.name):
return
else:
edit = True
else:
edit = True
if patch:
edit |= patch.apply(task)
elif branch:
edit |= merge_branch(branch)
while True:
if edit:
edit_source()
# All following loop executions require manual editing.
edit = True
_update_maintainer_field()
if not source_package.reload_changelog():
continue
if not source_package.check_version(task.get_version()):
continue
_update_timestamp()
if not source_package.build_source(keyid, upload,
task.get_previous_version()):
continue
source_package.generate_debdiff(dsc_file)
# Make sure that the Launchpad bug will be closed
if not source_package.is_fixed(bug):
continue
if not source_package.check_target(upload, launchpad):
continue
if build:
successful_built = source_package.build(update)
update = False
if not successful_built:
continue
if not source_package.ask_and_upload(upload):
continue
# Leave while loop if everything worked
break
class UbuntuOS(OperatingSystem):
"""Ubuntu operating system."""
name = "ubuntu"
title = "Ubuntu"
def __init__(self):
self.ubuntu_distro_info = UbuntuDistroInfo()
def get_boot_image_purposes(self, arch, subarch, release, label):
"""Gets the purpose of each boot image."""
return [
BOOT_IMAGE_PURPOSE.COMMISSIONING,
BOOT_IMAGE_PURPOSE.INSTALL,
BOOT_IMAGE_PURPOSE.XINSTALL,
BOOT_IMAGE_PURPOSE.DISKLESS,
]
def is_release_supported(self, release):
"""Return True when the release is supported, False otherwise."""
row = self.get_distro_series_info_row(release)
return row is not None
def get_lts_release(self):
"""Return the latest Ubuntu LTS release."""
return self.ubuntu_distro_info.lts()
def get_default_release(self):
"""Gets the default release to use when a release is not
explicit."""
return self.get_lts_release()
def get_supported_commissioning_releases(self):
"""Gets the supported commissioning releases for Ubuntu. This
only exists on Ubuntu, because that is the only operating
system that supports commissioning.
"""
unsupported_releases = ['precise']
return [
name for name in self.ubuntu_distro_info.supported()
if name not in unsupported_releases
if self.ubuntu_distro_info.is_lts(name)
]
def get_default_commissioning_release(self):
"""Gets the default commissioning release for Ubuntu. This only exists
on Ubuntu, because that is the only operating system that supports
commissioning.
"""
return self.get_lts_release()
def get_distro_series_info_row(self, release):
"""Returns the distro series row information from python-distro-info.
"""
info = self.ubuntu_distro_info
for row in info._avail(info._date):
if row['series'] == release:
return row
return None
def get_release_title(self, release):
"""Return the title for the given release."""
row = self.get_distro_series_info_row(release)
if row is None:
return None
return self.ubuntu_distro_info._format("fullname", row)
def get_xinstall_parameters(self, arch, subarch, release, label):
"""Return the xinstall image name and type for this operating system.
:param arch: Architecture of boot image.
:param subarch: Sub-architecture of boot image.
:param release: Release of boot image.
:param label: Label of boot image.
:return: tuple with name of root image and image type
"""
with ClusterConfiguration.open() as config:
squashfs_path = os.path.join(config.tftp_root, 'ubuntu', arch,
subarch, release, label, 'squashfs')
if os.path.exists(squashfs_path):
return ('squashfs', 'squashfs')
else:
return ('root-tgz', 'tgz')
def setUp(self): # pylint: disable=invalid-name
self._distro_info = UbuntuDistroInfo()
self._date = datetime.date(2011, 1, 10)
def __init__(self):
self.ubuntu_distro_info = UbuntuDistroInfo()
