Files
gns3-server/tests/utils/test_images.py
T
YueGuobin de986e890e feat: name nodes and templates in Docker image delete conflicts
The compute translates the container ids in a daemon delete conflict
into the GNS3 node and project behind each container. Leftover
containers from closed projects and containers created outside GNS3
are named as such.

The controller lists the templates referencing the image in the
conflict error, matched through the canonical image name. After a
successful deletion it emits a docker.image.deleted notification with
those templates: their nodes can no longer start.
2026-11-06 22:05:52 +08:00

266 lines
9.1 KiB
Python

#
# Copyright (C) 2014 GNS3 Technologies Inc.
#
# 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 3 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.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import os
import threading
import pytest
from gns3server.utils import force_unix_path
from gns3server.utils.images import (
canonical_docker_image_name,
images_directories,
list_images,
md5sum,
remove_checksum,
)
def test_images_directories(tmpdir, config):
path1 = tmpdir / "images1" / "QEMU" / "test1.bin"
path1.write("1", ensure=True)
path1 = force_unix_path(str(path1))
path2 = tmpdir / "images2" / "test2.bin"
path2.write("1", ensure=True)
path2 = force_unix_path(str(path2))
config.settings.Server.images_path = str(tmpdir / "images1")
config.settings.Server.additional_images_paths = "/tmp/null24564;" + str(tmpdir / "images2")
# /tmp/null24564 is ignored because doesn't exists
res = images_directories("qemu")
assert res[0] == force_unix_path(str(tmpdir / "images1" / "QEMU"))
assert res[1] == force_unix_path(str(tmpdir / "images2"))
assert res[2] == force_unix_path(str(tmpdir / "images1"))
assert len(res) == 3
def test_md5sum(tmpdir):
fake_img = str(tmpdir / "hello载")
with open(fake_img, "w+") as f:
f.write("hello")
assert md5sum(fake_img) == "5d41402abc4b2a76b9719d911017c592"
with open(str(tmpdir / "hello载.md5sum")) as f:
assert f.read() == "5d41402abc4b2a76b9719d911017c592"
def test_md5sum_stopped_event(tmpdir):
fake_img = str(tmpdir / "hello_stopped")
with open(fake_img, "w+") as f:
f.write("hello")
event = threading.Event()
event.set()
assert md5sum(fake_img, stopped_event=event) is None
assert not os.path.exists(str(tmpdir / "hello_stopped.md5sum"))
def test_md5sum_existing_digest(tmpdir):
fake_img = str(tmpdir / "hello")
with open(fake_img, "w+") as f:
f.write("hello")
with open(str(tmpdir / "hello.md5sum"), "w+") as f:
f.write("aaaaa02abc4b2a76b9719d911017c592")
assert md5sum(fake_img) == "aaaaa02abc4b2a76b9719d911017c592"
def test_md5sum_existing_digest_but_missing_image(tmpdir):
fake_img = str(tmpdir / "hello")
with open(str(tmpdir / "hello.md5sum"), "w+") as f:
f.write("aaaaa02abc4b2a76b9719d911017c592")
assert md5sum(fake_img) is None
def test_md5sum_none(tmpdir):
assert md5sum(None) is None
def test_remove_checksum(tmpdir):
with open(str(tmpdir / "hello.md5sum"), "w+") as f:
f.write("aaaaa02abc4b2a76b9719d911017c592")
remove_checksum(str(tmpdir / "hello"))
assert not os.path.exists(str(tmpdir / "hello.md5sum"))
remove_checksum(str(tmpdir / "not_exists"))
@pytest.mark.parametrize(
"reference, expected",
(
("alpine", "library/alpine:latest"),
("alpine:3", "library/alpine:3"),
("library/alpine:3", "library/alpine:3"),
("docker.io/library/alpine:3", "library/alpine:3"),
("index.docker.io/library/alpine:3", "library/alpine:3"),
("localhost/alpine:3", "library/alpine:3"),
("gns3/frr", "gns3/frr:latest"),
("gns3/frr:latest", "gns3/frr:latest"),
("quay.io/some/namespace/image:2.0", "some/namespace/image:2.0"),
("alpine@sha256:" + "a" * 64, "library/alpine@sha256:" + "a" * 64),
("alpine:3@sha256:" + "a" * 64, "library/alpine@sha256:" + "a" * 64),
),
)
def test_canonical_docker_image_name(reference, expected):
assert canonical_docker_image_name(reference) == expected
# the canonical form is stable: canonicalizing twice does not change it
assert canonical_docker_image_name(expected) == expected
@pytest.mark.asyncio
async def test_list_images(tmpdir, config):
# IOS image in the images directory
ios_image_1 = tmpdir / "images1" / "IOS" / "ios_image_1.image"
ios_image_1.write(b"\x7fELF\x01\x02\x01", ensure=True)
ios_image_1 = force_unix_path(str(ios_image_1))
# IOS image in an additional images path
ios_image_2 = tmpdir / "images2" / "ios_image_2.image"
ios_image_2.write(b"\x7fELF\x01\x02\x01", ensure=True)
ios_image_2 = force_unix_path(str(ios_image_2))
# Not a valid elf file
not_elf_file = tmpdir / "images1" / "IOS" / "not_elf.image"
not_elf_file.write(b"NOTANELF", ensure=True)
not_elf_file = force_unix_path(str(not_elf_file))
# Invalid image because it is very small
small_file = tmpdir / "images1" / "too_small.image"
small_file.write(b"1", ensure=True)
# 64-bit IOU image
iou_image_1 = tmpdir / "images1" / "IOU" / "iou64.bin"
iou_image_1.write(b"\x7fELF\x02\x01\x01", ensure=True)
iou_image_1 = force_unix_path(str(iou_image_1))
# 32-bit IOU image
iou_image_2 = tmpdir / "images1" / "IOU" / "iou32.bin"
iou_image_2.write(b"\x7fELF\x01\x01\x01", ensure=True) # 32-bit IOU image
iou_image_2 = force_unix_path(str(iou_image_2))
# Qemu image
qemu_image_1 = tmpdir / "images1" / "QEMU" / "qemu_image.qcow2"
qemu_image_1.write("1234567", ensure=True)
qemu_image_1 = force_unix_path(str(qemu_image_1))
# ELF file inside the Qemu
elf_file = tmpdir / "images1" / "QEMU" / "elf_file.bin"
elf_file.write(b"\x7fELF\x02\x01\x01", ensure=True) # ELF file
elf_file = force_unix_path(str(elf_file))
md5sum_file = tmpdir / "images1" / "QEMU" / "image.qcow2.md5sum"
md5sum_file.write("1", ensure=True)
md5sum_file = force_unix_path(str(md5sum_file))
config.settings.Server.images_path = str(tmpdir / "images1")
config.settings.Server.additional_images_paths = "/tmp/null24564;" + str(tmpdir / "images2")
assert sorted(await list_images("dynamips"), key=lambda k: k["filename"]) == [
{
"filename": "ios_image_1.image",
"filesize": 7,
"md5sum": "b0d5aa897d937aced5a6b1046e8f7e2e",
"path": "ios_image_1.image",
},
{
"filename": "ios_image_2.image",
"filesize": 7,
"md5sum": "b0d5aa897d937aced5a6b1046e8f7e2e",
"path": str(ios_image_2),
},
]
assert sorted(await list_images("iou"), key=lambda k: k["filename"]) == [
{"filename": "iou32.bin", "filesize": 7, "md5sum": "e573e8f5c93c6c00783f20c7a170aa6c", "path": "iou32.bin"},
{"filename": "iou64.bin", "filesize": 7, "md5sum": "c73626d23469519894d58bc98bee9655", "path": "iou64.bin"},
]
assert await list_images("qemu") == [
{
"filename": "qemu_image.qcow2",
"filesize": 7,
"md5sum": "fcea920f7412b5da7be0cf42b8c93759",
"path": "qemu_image.qcow2",
}
]
@pytest.mark.asyncio
@pytest.mark.parametrize("subdirectory", [None, "installers/linux"])
async def test_iso_upload_and_discovery(tmp_path, config, subdirectory):
from unittest.mock import AsyncMock
from gns3server.utils.images import discover_images, inspect_image_file, write_image
config.settings.Server.images_path = str(tmp_path)
config.settings.Server.additional_images_paths = []
# ISO 9660 primary volume descriptor; no raw-image fallback is needed.
content = b"\0" * (16 * 2048) + b"\x01CD001\x01" + b"\0" * 2041
async def stream():
# Exercise a descriptor split across upload chunks.
for offset in range(0, len(content), 13):
yield content[offset : offset + 13]
repo = AsyncMock()
repo.get_image_by_checksum.return_value = None
repo.save_verified_image.side_effect = lambda image: image
result = await write_image(
"installer.ISO", str(tmp_path / "installer.ISO"), stream(), repo, subdirectory=subdirectory
)
expected = tmp_path / "QEMU" / (subdirectory or "") / "installer.ISO"
assert result["path"] == str(expected)
assert result["image_type"] == "qemu"
assert expected.read_bytes() == content
assert inspect_image_file(expected)["checksum"] == result["checksum"]
assert [image["path"] for image in await discover_images("qemu")] == [str(expected)]
def test_iso_extension_alone_is_not_a_valid_image():
from gns3server.utils.images import InvalidImageError, check_valid_image_header
with pytest.raises(InvalidImageError):
check_valid_image_header("fake.iso", b"not an ISO image")
@pytest.mark.parametrize("images_root", ["images", "QEMU/images"])
def test_image_reference_uses_configured_root(tmp_path, config, images_root):
from gns3server.db.models.images import Image
root = tmp_path / images_root
config.settings.Server.images_path = str(root)
image = Image(image_type="qemu", path=str(root / "QEMU/installers/linux.iso"))
assert image.reference == "installers/linux.iso"
image.path = str(tmp_path / "extra/QEMU/linux.iso")
assert image.reference == image.path