def test_read_RHEL_treeinfo(self):
for i in os.listdir(self.treeinfo_path):
if "RHEL" not in i:
continue
if "optional" in i:
continue
path = os.path.join(self.treeinfo_path, i)
ti = TreeInfo()
ti.load(path)
self.assertEqual(ti.release.short, "RHEL")
self.assertEqual(ti.release.name, "Red Hat Enterprise Linux")
self.assertEqual(ti.release.version, str(ti.release.version))
# variants
self.assertEqual(len(ti.variants), 2)
# variant: BaseOS
var = ti.variants["BaseOS"]
self.assertEqual(var.id, "BaseOS")
self.assertEqual(var.uid, "BaseOS")
self.assertEqual(var.name, "BaseOS")
self.assertEqual(var.type, "variant")
self.assertEqual(var.paths.packages, "Packages")
self.assertEqual(var.paths.repository, ".")
# variant: AppStream
var = ti.variants["AppStream"]
self.assertEqual(var.id, "AppStream")
self.assertEqual(var.uid, "AppStream")
self.assertEqual(var.name, "AppStream")
self.assertEqual(var.type, "variant")
self.assertEqual(var.paths.packages, "Packages")
def test_f20(self):
ti = TreeInfo()
ti.load(os.path.join(DIR, "treeinfo/fedora-20-Fedora.x86_64"))
# product
self.assertEqual(ti.release.name, "Fedora")
self.assertEqual(ti.release.short, "Fedora")
self.assertEqual(ti.release.version, "20")
# tree
self.assertEqual(ti.tree.arch, "x86_64")
# XXX: converts float to int
self.assertEqual(ti.tree.build_timestamp, 1386857206)
# variants
self.assertEqual(len(ti.variants), 1)
# variant: Fedora
var = ti.variants["Fedora"]
self.assertEqual(var.id, "Fedora")
self.assertEqual(var.uid, "Fedora")
self.assertEqual(var.name, "Fedora")
self.assertEqual(var.type, "variant")
self.assertEqual(var.paths.packages, "Packages")
self.assertEqual(var.paths.repository, ".")
# stage2
self.assertEqual(ti.stage2.mainimage, "LiveOS/squashfs.img")
self.assertEqual(ti.stage2.instimage, None)
# images
expected_images = {
"kernel": "images/pxeboot/vmlinuz",
"initrd": "images/pxeboot/initrd.img",
"upgrade": "images/pxeboot/upgrade.img",
"boot.iso": "images/boot.iso",
}
self.assertEqual(ti.images.images["x86_64"], expected_images)
expected_images = {
"kernel": "images/pxeboot/vmlinuz",
"initrd": "images/pxeboot/initrd.img",
"upgrade": "images/pxeboot/upgrade.img",
}
self.assertEqual(ti.images.images["xen"], expected_images)
# checksums
expected_checksums = {
"images/boot.iso": ("sha256", "376be7d4855ad6281cb139430606a782fd6189dcb01d7b61448e915802cc350f"),
"images/efiboot.img": ("sha256", "3bcba2a9b45366ab3f6d82dbe512421ddcb693f3bcbd9e30cc57aa0fa13c7835"),
"images/macboot.img": ("sha256", "698b3492534399e31fa1033f51f25b85d463e743f6a26322a9b117f9aac4fdf3"),
"images/pxeboot/initrd.img": ("sha256", "d0a81824e3425b6871ec4896a66e891aed35e291c50dfa30b08f6fc6ab04ca8b"),
"images/pxeboot/upgrade.img": ("sha256", "a274b8756290447950f1e48cff9d9d6fd1144579ad98ed9f91929ff9ac1bbfa9"),
"images/pxeboot/vmlinuz": ("sha256", "d3a2fbfcf08ac76dfb8135771380ec97ae3129b4e623891adb21bb1cd8ba59f6"),
"repodata/repomd.xml": ("sha256", "108b4102829c0839c7712832577fe7da24f0a9491f4dc25d4145efe6aced2ebf"),
}
self.assertEqual(ti.checksums.checksums, expected_checksums)
self._test_identity(ti)
def test_f21_server(self):
ti = TreeInfo()
ti.load(os.path.join(DIR, "treeinfo/fedora-21-Alpha-Server.x86_64"))
# product
self.assertEqual(ti.release.name, "Fedora")
self.assertEqual(ti.release.short, "Fedora")
self.assertEqual(ti.release.version, "21")
# tree
self.assertEqual(ti.tree.arch, "x86_64")
# XXX: converts float to int
self.assertEqual(ti.tree.build_timestamp, 1410862874)
# variants
self.assertEqual(len(ti.variants), 1)
# variant: Server
var = ti.variants["Server"]
self.assertEqual(var.id, "Server")
self.assertEqual(var.uid, "Server")
self.assertEqual(var.name, "Server")
self.assertEqual(var.type, "variant")
self.assertEqual(var.paths.packages, "Packages")
self.assertEqual(var.paths.repository, ".")
# stage2
self.assertEqual(ti.stage2.mainimage, "LiveOS/squashfs.img")
self.assertEqual(ti.stage2.instimage, None)
# images
expected_images = {
"kernel": "images/pxeboot/vmlinuz",
"initrd": "images/pxeboot/initrd.img",
"upgrade": "images/pxeboot/upgrade.img",
"boot.iso": "images/boot.iso",
}
self.assertEqual(ti.images.images["x86_64"], expected_images)
expected_images = {
"kernel": "images/pxeboot/vmlinuz",
"initrd": "images/pxeboot/initrd.img",
"upgrade": "images/pxeboot/upgrade.img",
}
self.assertEqual(ti.images.images["xen"], expected_images)
# checksums
expected_checksums = {
"images/boot.iso": ("sha256", "e9c8b207d25c4af1a36c43a4cc3bf27dd2aefa9757eac63a8147e12e415f45f3"),
"images/efiboot.img": ("sha256", "0655a92312272a2ee929f579c7ac5086c0ab75b7453a0293a38502d69a8335d3"),
"images/macboot.img": ("sha256", "c25721c2e69ea82eedd78107baf69fc0d2900c5a23d0b689140edc2b372393f9"),
"images/pxeboot/initrd.img": ("sha256", "b6cffe60149c0396b3413bf3f73c3a1aa3090048302daeeeb8830911d903aa2f"),
"images/pxeboot/upgrade.img": ("sha256", "260ab3a63fb4ef1f0427a6b46d494c638760e0bb4e7e9f58295d0cf4e77886fc"),
"images/pxeboot/vmlinuz": ("sha256", "974cbed883608046bacfc7a4f232320750150c2821edcd4650fbbe709a6c1d3d"),
"repodata/repomd.xml": ("sha256", "1799b6652f287c73e1f1107ef5efe73a0714aaf34e8e9b81a08d3f741f5dc178"),
}
self.assertEqual(ti.checksums.checksums, expected_checksums)
self._test_identity(ti)
def get_kickstart_data(remote):
"""
Get Kickstart data from remote.
"""
kickstart = {}
namespaces = [".treeinfo", "treeinfo"]
for namespace in namespaces:
downloader = remote.get_downloader(url=urljoin(remote.url, namespace))
try:
result = downloader.fetch()
except ClientResponseError as exc:
if 404 == exc.status:
continue
raise
kickstart = TreeInfo()
kickstart.load(f=result.path)
parser = SortedConfigParser()
kickstart.serialize(parser)
kickstart_parsed = parser._sections
sha256 = result.artifact_attributes["sha256"]
kickstart = KickstartData(kickstart_parsed).to_dict(hash=sha256)
break
return kickstart
def test_treeinfo_compute_checksum(self):
tmp_file = os.path.join(self.tmp_dir, "file")
open(tmp_file, "w").write("test")
expected_checksum = "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"
ti = TreeInfo()
ti.checksums.add("file", "sha256", None, self.tmp_dir)
self.assertEqual(ti.checksums.checksums["file"], ["sha256", expected_checksum])
def test_create(self):
ti = TreeInfo()
ti.release.name = "Fedora"
ti.release.short = "F"
ti.release.version = "20"
ti.tree.arch = "x86_64"
ti.tree.build_timestamp = 123456
variant = Variant(ti)
variant.id = "Fedora"
variant.uid = "Fedora"
variant.name = "Fedora"
variant.type = "variant"
variant.paths.repository = "repo"
variant.paths.packages = "pkgs"
variant.paths.source_repository = "src repo"
variant.paths.source_packages = "src pkgs"
variant.paths.debug_repository = "debug repo"
variant.paths.debug_packages = "debug pkgs"
variant.paths.identity = "cert.pem"
ti.variants.add(variant)
ti.dump(self.ini_path)
self._test_identity(ti)
def test_centos8_baseos(self):
"""Publish CentOS 8 BaseOS."""
publication_href = self.rpm_publish(url=CENTOS8_BASEOS_URL)
# Test that the .treeinfo file is available and AppStream sub-repo is published correctly
body = {"publication": publication_href, "name": "centos8", "base_path": "centos8"}
response = self.client.using_handler(api.json_handler).post(RPM_DISTRIBUTION_PATH, body)
distribution_task = self.client.get(response["task"])
distribution_href = distribution_task["created_resources"][0]
self.addCleanup(self.client.delete, distribution_href)
distribution = self.client.get(distribution_href)
treeinfo_file = utils.http_get(urljoin(distribution["base_url"], ".treeinfo"))
treeinfo = TreeInfo()
with NamedTemporaryFile("wb") as temp_file:
temp_file.write(treeinfo_file)
temp_file.flush()
treeinfo.load(f=temp_file.name)
for variant_name, variant in treeinfo.variants.variants.items():
if variant_name == "BaseOS":
self.assertEqual(variant.paths.repository, ".")
self.assertEqual(variant.paths.packages, "Packages")
elif variant_name == "AppStream":
self.assertEqual(variant.paths.repository, "AppStream")
self.assertEqual(variant.paths.packages, "AppStream/Packages")
# Find the first package in the 'AppStream/Packages/a/' directory and download it
parser = PackagesHtmlParser()
a_packages_href = urljoin(
distribution["base_url"], "{}/a/".format(variant.paths.packages)
)
a_packages_listing = utils.http_get(a_packages_href)
parser.feed(a_packages_listing.__str__())
full_package_path = urljoin(a_packages_href, parser.package_href)
utils.http_get(full_package_path)
def test_read_treeinfo(self):
for i in os.listdir(self.treeinfo_path):
if i in ("fedora-8-Everything.x86_64", "fedora-8-Everything.ppc", "fedora-8-Everything.i386"):
# version == "development" -> can't read correctly
continue
path = os.path.join(self.treeinfo_path, i)
ti = TreeInfo()
ti.load(path)
self.assertEqual(ti.release.short, "Fedora")
self.assertEqual(ti.release.name, "Fedora")
self.assertEqual(ti.release.version, str(int(ti.release.version)))
def test_read_RHEL_Server_optional_treeinfo(self):
path = os.path.join(self.treeinfo_path, "RHEL-7-Server-optional.x86_64")
ti = TreeInfo()
ti.load(path)
var = ti.variants["Server-optional"]
self.assertEqual(var.id, "optional")
self.assertEqual(var.uid, "Server-optional")
self.assertEqual(var.name, "optional")
self.assertEqual(var.type, "optional")
self.assertEqual(var.paths.packages, "Packages")
self.assertEqual(var.paths.repository, ".")
def test_create_with_two_variants(self):
ti = TreeInfo()
ti.release.name = "Fedora"
ti.release.short = "F"
ti.release.version = "20"
ti.tree.arch = "x86_64"
ti.tree.build_timestamp = 123456
variant_1 = Variant(ti)
variant_1.id = "AppStream"
variant_1.uid = "AppStream"
variant_1.name = "AppStream"
variant_1.type = "variant"
variant_1.paths.repository = "repo"
variant_1.paths.packages = "pkgs"
variant_1.paths.source_repository = "src repo"
variant_1.paths.source_packages = "src pkgs"
variant_1.paths.debug_repository = "debug repo"
variant_1.paths.debug_packages = "debug pkgs"
variant_1.paths.identity = "cert.pem"
ti.variants.add(variant_1)
variant_2 = Variant(ti)
variant_2.id = "BaseOS"
variant_2.uid = "BaseOS"
variant_2.name = "BaseOS"
variant_2.type = "variant"
variant_2.paths.repository = "repo_2"
variant_2.paths.packages = "pkgs_2"
variant_2.paths.source_repository = "src repo 2"
variant_2.paths.source_packages = "src pkgs 2"
variant_2.paths.debug_repository = "debug repo 2"
variant_2.paths.debug_packages = "debug pkgs 2"
variant_2.paths.identity = "cert2.pem"
ti.variants.add(variant_2)
ti.dump(self.ini_path, main_variant='BaseOS')
with open(
self.ini_path, 'r'
) as treeinfo_1, open(
os.path.join(DIR, "treeinfo/multivariants_treeinfo")
) as treeinfo_2:
treeinfo_1_lines = treeinfo_1.readlines()
treeinfo_2_lines = treeinfo_2.readlines()
self.assertEqual(
treeinfo_1_lines,
treeinfo_2_lines,
)
def _load_tree_info(self, root_url, file_path=None, file_content=None):
"""Load the treeinfo metadata.
:param root_url: a URL of the installation root
:param file_path: a path to a treeinfo file or None
:param file_content: a content of a treeinfo file or None
:raise InvalidTreeInfoError: if the metadata is invalid
"""
try:
# Load and validate the metadata.
tree_info = TreeInfo()
if file_content:
tree_info.loads(file_content)
else:
tree_info.load(file_path)
tree_info.validate()
log.debug("Loaded treeinfo metadata:\n%s", tree_info.dumps())
# Load the release version.
release_version = tree_info.release.version.lower()
# Create repositories for variants and optional variants.
# Child variants (like addons) will be ignored.
repo_list = []
for name in tree_info.variants:
log.debug("Processing the '%s' variant.", name)
# Get the variant metadata.
data = tree_info.variants[name]
# Create the repo metadata.
repo_md = TreeInfoRepoMetadata(
repo_name=name,
tree_info=data,
root_url=root_url,
)
repo_list.append(repo_md)
except configparser.Error as e:
log.debug("Failed to load treeinfo metadata: %s", e)
raise InvalidTreeInfoError("Invalid metadata: {}".format(str(e))) from None
# Update this treeinfo representation.
self._root_url = root_url
self._repositories = repo_list
self._release_version = release_version
log.debug("The treeinfo metadata is loaded.")
def _test_identity(self, ti):
first = os.path.join(self.tmp_dir, "first")
second = os.path.join(self.tmp_dir, "second")
# write original file
ti.dump(first)
# read file and write it back
ti = TreeInfo()
ti.load(first)
ti.dump(second)
# check if first and second files are identical
self.assertSameFiles(first, second)
def _load_tree_info(self, root_path, file_path=None, file_content=None):
"""Load the treeinfo metadata.
:param root_path: a path to the installation root
:param file_path: a path to a treeinfo file or None
:param file_content: a content of a treeinfo file or None
:raise InvalidTreeInfoError: if the metadata is invalid
"""
try:
# Load and validate the metadata.
tree_info = TreeInfo()
if file_content:
tree_info.loads(file_content)
else:
tree_info.load(file_path)
tree_info.validate()
# Load the release version.
release_version = tree_info.release.version.lower()
# Load the repositories.
repo_list = []
for name in tree_info.variants:
# Get the variant metadata.
data = tree_info.variants[name]
# Create the repo metadata.
repo_md = TreeInfoRepoMetadata(
repo_name=name,
tree_info=data,
root_path=root_path,
)
repo_list.append(repo_md)
except configparser.Error as e:
log.debug("Failed to load treeinfo metadata: %s", e)
raise InvalidTreeInfoError("Invalid metadata: {}".format(
str(e))) from None
# Update this treeinfo representation.
self._root_path = root_path
self._repositories = repo_list
self._release_version = release_version
log.debug("The treeinfo metadata is loaded.")
def append_custom_repo_to_treeinfo(treeinfo_content, path):
ti = TreeInfo()
ti.loads(treeinfo_content)
variant = Variant(ti)
variant.id = CUSTOM_REPO_NAME
variant.uid = CUSTOM_REPO_NAME
variant.name = CUSTOM_REPO_NAME
variant.paths.repository = os.path.join(".", CUSTOM_REPO_NAME)
variant.paths.packages = os.path.join(".", CUSTOM_REPO_NAME, PACKAGES_DIR)
variant.type = "variant"
ti.variants.add(variant)
ti.dump(path)
def test_parse_opensuse_treeinfo(self):
ti = TreeInfo()
ti.load(os.path.join(self.treeinfo_path, "opensuse"))
self.assertEqual(ti.release.name, "openSUSE Leap")
self.assertEqual(ti.release.short, "openSUSE Leap")
self.assertEqual(ti.release.version, "15.1")
self.assertEqual(ti.variants.variants, {})
self.assertEqual(ti.tree.arch, "x86_64")
self.assertEqual(ti.tree.platforms, set(["x86_64", "xen"]))
self.assertEqual(
ti.images.images,
{
"x86_64": {
"initrd": "boot/x86_64/loader/initrd",
"kernel": "boot/x86_64/loader/linux",
},
"xen": {
"initrd": "boot/x86_64/loader/initrd",
"kernel": "boot/x86_64/loader/linux",
},
},
)
def __init__(self):
self._tree_info = TreeInfo()
self._meta_repos = []
self._path = ""
def _clear(self):
"""Clear metadata repositories."""
self._tree_info = TreeInfo()
self._meta_repos = []
self._path = ""
