Merge pull request #3062 from yueguobin/feat/docker-image-upload

Allow uploading, deleting and pulling Docker images on computes
This commit is contained in:
Jeremy Grossmann authored and GitHub committed 2026-11-07 16:49:26 +01:00
commit ce8d5591a1
16 files changed
+1312 -206

No files matched your search

+96 -5
View File
@@ -18,6 +18,7 @@ import pytest
from fastapi import FastAPI, status
from httpx import AsyncClient
from gns3server.compute.docker.docker_error import DockerError
from tests.utils import asyncio_patch
pytestmark = pytest.mark.asyncio
@@ -26,12 +27,75 @@ pytestmark = pytest.mark.asyncio
class TestImagesRoutes:
async def test_pull_docker_image(self, app: FastAPI, compute_client: AsyncClient) -> None:
with asyncio_patch("gns3server.compute.docker.Docker.pull_image") as mock:
response = await compute_client.post(
app.url_path_for("compute:pull_docker_image"), json={"image": "nginx:latest"}
async def fake_pull(image, progress_callback=None, force=False):
progress_callback(
{"layers_total": 0, "layers_done": 0, "message": "Pulling 'nginx:latest'", "state": "started"}
)
mock.assert_called_once_with("nginx:latest", force=True)
assert response.status_code == status.HTTP_204_NO_CONTENT
with asyncio_patch("gns3server.compute.docker.Docker.pull_image", side_effect=fake_pull) as mock:
with asyncio_patch("gns3server.compute.notification_manager.NotificationManager.emit") as emit_mock:
response = await compute_client.post(
app.url_path_for("compute:pull_docker_image"), json={"image": "nginx:latest"}
)
assert mock.call_args[0] == ("nginx:latest",)
assert mock.call_args[1]["force"] is True
assert callable(mock.call_args[1]["progress_callback"])
# started and completed events are emitted to the notification stream
assert [(c.args[0], c.args[1]["state"]) for c in emit_mock.call_args_list] == [
("docker.image.pull", "started"),
("docker.image.pull", "completed"),
]
assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_pull_docker_image_progress_id(self, app: FastAPI, compute_client: AsyncClient) -> None:
async def fake_pull(image, progress_callback=None, force=False):
progress_callback({"layers_total": 1, "layers_done": 0, "message": "Pulling", "state": "started"})
progress_callback({"layers_total": 1, "layers_done": 0, "message": "[==> ] 10/100"})
with asyncio_patch("gns3server.compute.docker.Docker.pull_image", side_effect=fake_pull):
with asyncio_patch("gns3server.compute.notification_manager.NotificationManager.emit") as emit_mock:
response = await compute_client.post(
app.url_path_for("compute:pull_docker_image"),
json={"image": "nginx:latest"},
params={"progress_id": "abc123"},
)
assert response.status_code == status.HTTP_204_NO_CONTENT
assert all(c.args[1]["progress_id"] == "abc123" for c in emit_mock.call_args_list)
async def test_pull_docker_image_reports_downloading(self, app: FastAPI, compute_client: AsyncClient) -> None:
async def fake_pull(image, progress_callback=None, force=False):
progress_callback({"layers_total": 2, "layers_done": 0, "message": "Pulling", "state": "started"})
progress_callback({"layers_total": 2, "layers_done": 1, "message": "[==> ] 40/100"})
with asyncio_patch("gns3server.compute.docker.Docker.pull_image", side_effect=fake_pull):
with asyncio_patch("gns3server.compute.notification_manager.NotificationManager.emit") as emit_mock:
response = await compute_client.post(
app.url_path_for("compute:pull_docker_image"), json={"image": "nginx:latest"}
)
assert response.status_code == status.HTTP_204_NO_CONTENT
states = [c.args[1]["state"] for c in emit_mock.call_args_list]
assert states == ["started", "downloading", "completed"]
downloading = emit_mock.call_args_list[1].args[1]
assert downloading["layers_total"] == 2
assert downloading["layers_done"] == 1
assert downloading["message"] == "[==> ] 40/100"
async def test_pull_docker_image_emits_failed(self, app: FastAPI, compute_client: AsyncClient) -> None:
async def fake_pull(image, progress_callback=None, force=False):
raise DockerError("no data received for 60 seconds")
with asyncio_patch("gns3server.compute.docker.Docker.pull_image", side_effect=fake_pull):
with asyncio_patch("gns3server.compute.notification_manager.NotificationManager.emit") as emit_mock:
response = await compute_client.post(
app.url_path_for("compute:pull_docker_image"), json={"image": "nginx:latest"}
)
assert response.status_code == status.HTTP_409_CONFLICT
failed = emit_mock.call_args_list[-1].args[1]
assert failed["state"] == "failed"
assert "no data received" in failed["message"]
@pytest.mark.parametrize("image", ["", " ", "nginx latest"])
async def test_pull_docker_image_rejects_invalid_name(
@@ -55,6 +119,33 @@ class TestImagesRoutes:
assert hasattr(stream, "__aiter__")
assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_delete_docker_image(self, app: FastAPI, compute_client: AsyncClient) -> None:
with asyncio_patch("gns3server.compute.docker.Docker.delete_image") as mock:
response = await compute_client.delete(
app.url_path_for("compute:delete_docker_image", image="ios-xr/xrd-control-plane:24.4.1")
)
mock.assert_called_once_with("ios-xr/xrd-control-plane:24.4.1", force=False)
assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_delete_docker_image_rejects_path_traversal(self, app: FastAPI, compute_client: AsyncClient) -> None:
# percent encoded so the client does not normalize the ".." segments
# away before the request reaches the server
with asyncio_patch("gns3server.compute.docker.Docker.delete_image") as mock:
response = await compute_client.delete("/v3/compute/docker/images/a%2F..%2F..%2Fversion")
mock.assert_not_called()
assert response.status_code == status.HTTP_422_UNPROCESSABLE_CONTENT
async def test_delete_docker_image_force(self, app: FastAPI, compute_client: AsyncClient) -> None:
with asyncio_patch("gns3server.compute.docker.Docker.delete_image") as mock:
response = await compute_client.delete(
app.url_path_for("compute:delete_docker_image", image="ubuntu:latest"),
params={"force": "true"},
)
mock.assert_called_once_with("ubuntu:latest", force=True)
assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_load_docker_image_with_image_and_digest(self, app: FastAPI, compute_client: AsyncClient) -> None:
digest = "sha256:" + "a" * 64
+186 -2
View File
@@ -182,7 +182,10 @@ class TestComputeFeatures:
) as mock:
response = await client.get(app.url_path_for("docker_get_images", compute_id=compute_id))
mock.assert_called_with("GET", "docker", "images")
assert response.json() == [{"image": "docker1"}, {"image": "docker2"}]
assert response.json() == [
{"image": "docker1", "id": None, "size": None, "created": None},
{"image": "docker2", "id": None, "size": None, "created": None},
]
async def test_compute_pull_docker_image(self, app: FastAPI, client: AsyncClient, test_compute: Compute) -> None:
@@ -194,7 +197,188 @@ class TestComputeFeatures:
app.url_path_for("docker_pull_image", compute_id=test_compute.compute_id),
json={"image": "nginx:latest"},
)
compute.forward.assert_called_with("POST", "docker", "images/pull", data={"image": "nginx:latest"})
compute.forward.assert_called_with(
"POST", "docker", "images/pull", data={"image": "nginx:latest"}, params=None
)
assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_compute_pull_docker_image_progress_id(
self, app: FastAPI, client: AsyncClient, test_compute: Compute
) -> None:
compute = MagicMock()
compute.forward = AsyncioMagicMock(return_value={})
with patch("gns3server.api.routes.controller.computes.Controller.instance") as controller:
controller.return_value.get_compute.return_value = compute
response = await client.post(
app.url_path_for("docker_pull_image", compute_id=test_compute.compute_id),
json={"image": "nginx:latest"},
params={"progress_id": "abc123"},
)
compute.forward.assert_called_with(
"POST",
"docker",
"images/pull",
data={"image": "nginx:latest"},
params={"progress_id": "abc123"},
)
assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_compute_delete_docker_image(self, app: FastAPI, client: AsyncClient, test_compute: Compute) -> None:
compute = MagicMock()
compute.http_query = AsyncioMagicMock(return_value={})
with patch("gns3server.api.routes.controller.computes.Controller.instance") as controller:
controller.return_value.get_compute.return_value = compute
response = await client.delete(
app.url_path_for(
"docker_delete_image",
compute_id=test_compute.compute_id,
image="ios-xr/xrd-control-plane:24.4.1",
),
params={"force": True},
)
compute.http_query.assert_called_once_with(
"DELETE",
"/docker/images/ios-xr/xrd-control-plane:24.4.1",
params={"force": "true"},
)
assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_compute_delete_docker_image_rejects_path_traversal(
self, app: FastAPI, client: AsyncClient, test_compute: Compute
) -> None:
# percent encoded so the client does not normalize the ".." segments
# away before the request reaches the server
compute = MagicMock()
compute.http_query = AsyncioMagicMock(return_value={})
with patch("gns3server.api.routes.controller.computes.Controller.instance") as controller:
controller.return_value.get_compute.return_value = compute
response = await client.delete(
f"/v3/computes/{test_compute.compute_id}/docker/images/a%2F..%2F..%2Fversion"
)
compute.http_query.assert_not_called()
assert response.status_code == status.HTTP_422_UNPROCESSABLE_CONTENT
async def test_compute_delete_docker_image_refused_while_referenced_by_templates(
self, app: FastAPI, client: AsyncClient, test_compute: Compute
) -> None:
"""
A deletion is refused while a template references the image, matched
through the image reference spelling, and the compute is not touched.
"""
new_template = {
"name": "Alpine conflict test",
"compute_id": "local",
# a different spelling of the deleted 'alpine:3'
"image": "docker.io/library/alpine:3",
"template_type": "docker",
}
response = await client.post(app.url_path_for("create_template"), json=new_template)
assert response.status_code == status.HTTP_201_CREATED
compute = MagicMock()
compute.http_query = AsyncioMagicMock(return_value={})
with patch("gns3server.api.routes.controller.computes.Controller.instance") as controller:
controller.return_value.get_compute.return_value = compute
response = await client.delete(
app.url_path_for("docker_delete_image", compute_id=test_compute.compute_id, image="alpine:3")
)
assert response.status_code == status.HTTP_409_CONFLICT
body = response.json()
assert body["code"] == "image_referenced_by_templates"
assert body["details"]["referenced_by_templates"] == ["Alpine conflict test"]
assert "referenced by template(s): Alpine conflict test" in body["message"]
compute.http_query.assert_not_called()
async def test_compute_delete_docker_image_force_overrides_template_reference(
self, app: FastAPI, client: AsyncClient, test_compute: Compute
) -> None:
"""
force=true deletes an image referenced by templates and the deletion
notification reports them.
"""
new_template = {
"name": "Alpine force test",
"compute_id": "local",
# an image no other test in this class references: the assertions
# below are exact and the class shares one database
"image": "gns3/force-delete-test:2",
"template_type": "docker",
}
response = await client.post(app.url_path_for("create_template"), json=new_template)
assert response.status_code == status.HTTP_201_CREATED
compute = MagicMock()
compute.http_query = AsyncioMagicMock(return_value={})
with patch("gns3server.api.routes.controller.computes.Controller.instance") as controller:
controller.return_value.get_compute.return_value = compute
response = await client.delete(
app.url_path_for(
"docker_delete_image", compute_id=test_compute.compute_id, image="gns3/force-delete-test:2"
),
params={"force": True},
)
assert response.status_code == status.HTTP_204_NO_CONTENT
compute.http_query.assert_called_once_with(
"DELETE", "/docker/images/gns3/force-delete-test:2", params={"force": "true"}
)
controller.return_value.notification.controller_emit.assert_called_once_with(
"docker.image.deleted",
{
"compute_id": str(test_compute.compute_id),
"image": "gns3/force-delete-test:2",
"referenced_by_templates": ["Alpine force test"],
},
)
async def test_compute_delete_docker_image_notifies_without_templates(
self, app: FastAPI, client: AsyncClient, test_compute: Compute
) -> None:
"""
A deletion nothing references still emits a docker.image.deleted
notification, so clients can refresh their image lists.
"""
compute = MagicMock()
compute.http_query = AsyncioMagicMock(return_value={})
with patch("gns3server.api.routes.controller.computes.Controller.instance") as controller:
controller.return_value.get_compute.return_value = compute
response = await client.delete(
app.url_path_for(
"docker_delete_image", compute_id=test_compute.compute_id, image="gns3/delete-event-test:1"
)
)
assert response.status_code == status.HTTP_204_NO_CONTENT
controller.return_value.notification.controller_emit.assert_called_once_with(
"docker.image.deleted",
{
"compute_id": str(test_compute.compute_id),
"image": "gns3/delete-event-test:1",
"referenced_by_templates": [],
},
)
async def test_compute_load_docker_image(self, app: FastAPI, client: AsyncClient, test_compute: Compute) -> None:
compute = MagicMock()
compute.http_query = AsyncioMagicMock(return_value={})
with patch("gns3server.api.routes.controller.computes.Controller.instance") as controller:
controller.return_value.get_compute.return_value = compute
response = await client.post(
app.url_path_for("docker_load_image", compute_id=test_compute.compute_id),
content=b"docker save tar data",
headers={"Content-Type": "application/octet-stream"},
)
compute.http_query.assert_called_once()
args, kwargs = compute.http_query.call_args
assert args[0] == "POST"
assert args[1] == "/docker/images/load"
assert kwargs["timeout"] is None
# the request body must be streamed, not buffered
assert hasattr(kwargs["data"], "__aiter__")
assert response.status_code == status.HTTP_204_NO_CONTENT
async def test_compute_list_virtualbox_vms(self, app: FastAPI, client: AsyncClient) -> None: