mirror of
https://github.com/GNS3/gns3-server.git
synced 2026-11-20 05:05:14 +02:00
Images built for reproducibility, such as the Ubuntu images assembled with rockcraft, carry no created timestamp in their config and Docker reports 0, shown as 1970-01-01. Fall back to the org.opencontainers.image.created label in list_images so the image list shows the real build time.
697 lines
29 KiB
Python
697 lines
29 KiB
Python
#
|
|
# Copyright (C) 2015 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/>.
|
|
|
|
"""
|
|
Docker server module.
|
|
"""
|
|
|
|
import asyncio
|
|
import json
|
|
import logging
|
|
import os
|
|
import re
|
|
import shutil
|
|
import sys
|
|
from datetime import UTC, datetime
|
|
|
|
import aiohttp
|
|
import platformdirs
|
|
|
|
from gns3server.compute.base_manager import BaseManager
|
|
from gns3server.compute.compute_error import ComputeError
|
|
from gns3server.compute.docker.docker_error import (
|
|
DockerError,
|
|
DockerHttp304Error,
|
|
DockerHttp404Error,
|
|
DockerHttp409Error,
|
|
)
|
|
from gns3server.compute.docker.docker_vm import DockerVM
|
|
from gns3server.compute.docker.iol_docker_vm import IOLDockerVM
|
|
from gns3server.compute.docker.vendor_docker_vm import VendorDockerVM
|
|
from gns3server.compute.project_manager import ProjectManager
|
|
from gns3server.config import Config
|
|
from gns3server.utils import parse_version
|
|
from gns3server.utils.asyncio import locking
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
|
|
# Be careful to keep it consistent
|
|
DOCKER_MINIMUM_API_VERSION = "1.40"
|
|
DOCKER_MINIMUM_VERSION = "19.03.8"
|
|
DOCKER_PREFERRED_API_VERSION = "1.44"
|
|
CHUNK_SIZE = 1024 * 8 # 8KB
|
|
|
|
# A pull streams progress from the daemon for its whole duration: when no data
|
|
# arrives for this many seconds the registry is unreachable and the pull would
|
|
# otherwise hang forever. This is an idle timeout, not a total time limit.
|
|
PULL_IDLE_TIMEOUT = 60
|
|
|
|
# Docker names GNS3 node containers "GNS3.{node name}.{project_id}", so a
|
|
# container name can be translated back into the node and project that block
|
|
# an image deletion. The node name may itself contain dots.
|
|
GNS3_CONTAINER_NAME_RE = re.compile(
|
|
r"^GNS3\.(?P<node>.+)\.(?P<project_id>[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12})$"
|
|
)
|
|
# The containers blocking an image deletion, as named by the daemon, e.g.
|
|
# 'container 6d59f00236ff is using its referenced image d529dd0c6e55'
|
|
CONFLICTING_CONTAINER_RE = re.compile(r"container ([0-9a-f]{12,64})\b")
|
|
|
|
# Images built for reproducibility, such as the Ubuntu images assembled with
|
|
# rockcraft, carry no created timestamp in their config and Docker reports 0
|
|
# (displayed as 1970-01-01). Their build tool writes the real time in this
|
|
# OCI label instead.
|
|
OCI_CREATED_LABEL = "org.opencontainers.image.created"
|
|
|
|
|
|
def image_created_timestamp(image: dict) -> int:
|
|
"""
|
|
Build time of an image as a Unix timestamp.
|
|
|
|
The daemon timestamp wins when it is set. When it is zero, fall back to
|
|
the OCI created label, if present.
|
|
|
|
:param image: an image summary as returned by the daemon images API
|
|
"""
|
|
|
|
created = image.get("Created") or 0
|
|
if created > 0:
|
|
return created
|
|
label = (image.get("Labels") or {}).get(OCI_CREATED_LABEL, "")
|
|
if not label:
|
|
return created
|
|
try:
|
|
built = datetime.fromisoformat(label)
|
|
except ValueError:
|
|
log.warning(f"Ignoring invalid {OCI_CREATED_LABEL} label: {label!r}")
|
|
return created
|
|
if built.tzinfo is None:
|
|
built = built.replace(tzinfo=UTC)
|
|
return int(built.timestamp())
|
|
|
|
|
|
class Docker(BaseManager):
|
|
_NODE_CLASS = DockerVM
|
|
|
|
def __init__(self):
|
|
|
|
super().__init__()
|
|
self._server_url = "/var/run/docker.sock"
|
|
self._connected = False
|
|
# Allow locking during ubridge operations
|
|
self.ubridge_lock = asyncio.Lock()
|
|
self._connector = None
|
|
self._session = None
|
|
self._api_version = DOCKER_MINIMUM_API_VERSION
|
|
self._host_checked = False
|
|
# Image name -> (controller digest, local id) for the images synced from
|
|
# the controller. The controller pins the id its own daemon reports,
|
|
# which is not comparable with the id this daemon reports for the same
|
|
# content (see load_image()).
|
|
self._image_id_translations = {}
|
|
|
|
def _select_node_class(self, **kwargs):
|
|
"""
|
|
Select the node class based on console_type and GNS3_* environment
|
|
markers. Like console_type, the environment is fixed at node creation
|
|
time: toggling a marker via PUT takes effect after a project reload.
|
|
"""
|
|
if kwargs.get("console_type") == "docker_exec":
|
|
return VendorDockerVM
|
|
environment = kwargs.get("environment") or ""
|
|
for line in environment.splitlines():
|
|
line = line.strip().rstrip(",")
|
|
if line.startswith("GNS3_IOL_RUNNER="):
|
|
return IOLDockerVM
|
|
if line.startswith("GNS3_UNIX_SOCKET_NIO="):
|
|
# Generic capability, usable without the IOL specifics.
|
|
return VendorDockerVM
|
|
return DockerVM
|
|
|
|
async def create_node(self, name, project_id, node_id, *args, **kwargs):
|
|
self._NODE_CLASS = self._select_node_class(**kwargs)
|
|
return await super().create_node(name, project_id, node_id, *args, **kwargs)
|
|
|
|
@staticmethod
|
|
async def install_busybox(dst_dir):
|
|
|
|
dst_busybox = os.path.join(dst_dir, "bin", "busybox")
|
|
if os.path.isfile(dst_busybox):
|
|
return
|
|
for busybox_exec in ("busybox-static", "busybox.static", "busybox"):
|
|
busybox_path = shutil.which(busybox_exec)
|
|
if busybox_path:
|
|
try:
|
|
# check that busybox is statically linked
|
|
# (dynamically linked busybox will fail to run in a container)
|
|
proc = await asyncio.create_subprocess_exec(
|
|
"ldd", busybox_path, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.DEVNULL
|
|
)
|
|
stdout, _ = await proc.communicate()
|
|
if proc.returncode == 1 or "static" in busybox_exec:
|
|
# ldd returns 1 if the file is not a dynamic executable
|
|
# on Alpine/musl, ldd returns 0 even for static binaries,
|
|
# so also trust binaries named busybox-static or busybox.static
|
|
log.info(f"Installing busybox from '{busybox_path}' to '{dst_busybox}'")
|
|
shutil.copy2(busybox_path, dst_busybox, follow_symlinks=True)
|
|
return
|
|
else:
|
|
log.warning(
|
|
f"Busybox '{busybox_path}' is dynamically linked\n"
|
|
f"{stdout.decode('utf-8', errors='ignore').strip()}"
|
|
)
|
|
except OSError as e:
|
|
raise DockerError(f"Could not install busybox: {e}")
|
|
raise DockerError(
|
|
"No busybox executable could be found, please install busybox (apt install busybox-static on Debian/Ubuntu) and make sure it is in your PATH"
|
|
)
|
|
|
|
@staticmethod
|
|
def resources_path():
|
|
"""
|
|
Get the Docker resources storage directory
|
|
"""
|
|
|
|
resources_path = Config.instance().settings.Server.resources_path
|
|
if not resources_path:
|
|
appname = vendor = "GNS3"
|
|
resources_path = platformdirs.user_data_dir(appname, vendor, roaming=True)
|
|
else:
|
|
resources_path = os.path.expanduser(resources_path)
|
|
docker_resources_dir = os.path.join(resources_path, "docker")
|
|
os.makedirs(docker_resources_dir, exist_ok=True)
|
|
return docker_resources_dir
|
|
|
|
async def install_resources(self):
|
|
"""
|
|
Copy the necessary resources to a writable location and install busybox
|
|
"""
|
|
|
|
try:
|
|
dst_path = self.resources_path()
|
|
log.info(f"Installing Docker resources in '{dst_path}'")
|
|
from gns3server.controller import Controller
|
|
|
|
await Controller.instance().install_resource_files(dst_path, "compute/docker/resources")
|
|
await self.install_busybox(dst_path)
|
|
except OSError as e:
|
|
raise DockerError(f"Could not install Docker resources to {dst_path}: {e}")
|
|
|
|
async def _check_connection(self):
|
|
|
|
if not self._connected:
|
|
try:
|
|
self._connected = True
|
|
docker_info = await self.query("GET", "version")
|
|
except (aiohttp.ClientError, FileNotFoundError):
|
|
self._connected = False
|
|
raise DockerError("Can't connect to Docker daemon")
|
|
|
|
api_version = parse_version(docker_info["ApiVersion"])
|
|
version = docker_info["Version"]
|
|
|
|
if api_version < parse_version(DOCKER_MINIMUM_API_VERSION):
|
|
raise DockerError(
|
|
f"Docker version is {version}. GNS3 requires a minimum version of {DOCKER_MINIMUM_VERSION}"
|
|
)
|
|
|
|
preferred_api_version = parse_version(DOCKER_PREFERRED_API_VERSION)
|
|
if api_version >= preferred_api_version:
|
|
self._api_version = DOCKER_PREFERRED_API_VERSION
|
|
else:
|
|
# use the Min API version supported by the daemon
|
|
self._api_version = docker_info["MinAPIVersion"]
|
|
log.warning(f"Using Docker client with the minimum API version {self._api_version}")
|
|
|
|
log.info(f"Connected to Docker daemon version {version} using API version {self._api_version}")
|
|
self._check_host_readiness()
|
|
|
|
def _check_host_readiness(self):
|
|
"""
|
|
Best-effort, read-only check of kernel settings that heavy NOS containers
|
|
(e.g. Cisco XRd) need. The server runs unprivileged (only the setuid
|
|
ubridge helper gets root), so we cannot raise these limits ourselves --
|
|
we only warn, with the exact commands to fix, when they are too low or
|
|
when FUSE support is missing. Runs at most once per process.
|
|
"""
|
|
|
|
if self._host_checked:
|
|
return
|
|
self._host_checked = True
|
|
|
|
# Thresholds recommended for running several heavy containers (sized for
|
|
# ~15 XRd-style nodes). Raising them is harmless; the stock Linux defaults
|
|
# (e.g. max_user_instances=128) are far too low and break such images.
|
|
thresholds = {
|
|
"fs.inotify.max_user_instances": 64000,
|
|
"fs.inotify.max_user_watches": 524288,
|
|
"fs.file-max": 1000000,
|
|
}
|
|
low = []
|
|
for key, minimum in thresholds.items():
|
|
try:
|
|
with open(f"/proc/sys/{key.replace('.', '/')}") as f:
|
|
current = int(f.read().strip())
|
|
except (OSError, ValueError):
|
|
# One unreadable key must not discard the warnings already
|
|
# collected nor skip the FUSE check — skip just this key.
|
|
continue
|
|
if current < minimum:
|
|
low.append((key, current, minimum))
|
|
|
|
fuse_supported = False
|
|
try:
|
|
with open("/proc/filesystems") as f:
|
|
filesystems = {parts[-1] for parts in (line.split() for line in f) if parts}
|
|
fuse_supported = "fuse" in filesystems or "fuseblk" in filesystems
|
|
except OSError:
|
|
pass
|
|
|
|
if low:
|
|
details = ", ".join(f"{k}={c} (need >={m})" for k, c, m in low)
|
|
raise_cmd = " ".join(f"{k}={m}" for k, _, m in low)
|
|
log.warning(
|
|
f"Low kernel limits for heavy Docker containers ({details}). "
|
|
f"Some NOS images (e.g. Cisco XRd) may fail to start. Raise once: "
|
|
f"'sudo sysctl -w {raise_cmd}' and persist it under /etc/sysctl.d/."
|
|
)
|
|
if not fuse_supported:
|
|
log.warning(
|
|
"FUSE filesystem support is not available in the kernel. "
|
|
"Containers that need it (e.g. Cisco XRd) will fail. Load it: 'sudo modprobe fuse'."
|
|
)
|
|
|
|
def connector(self):
|
|
|
|
if self._connector is None or self._connector.closed:
|
|
if not sys.platform.startswith("linux"):
|
|
raise DockerError("Docker is supported only on Linux")
|
|
try:
|
|
self._connector = aiohttp.connector.UnixConnector(self._server_url, limit=None)
|
|
except (aiohttp.ClientError, FileNotFoundError):
|
|
raise DockerError("Can't connect to docker daemon")
|
|
return self._connector
|
|
|
|
async def unload(self):
|
|
|
|
await super().unload()
|
|
if self._connected:
|
|
if self._connector and not self._connector.closed:
|
|
await self._connector.close()
|
|
if self._session and not self._session.closed:
|
|
await self._session.close()
|
|
|
|
async def query(self, method, path, data={}, params={}):
|
|
"""
|
|
Makes a query to the Docker daemon and decode the request
|
|
|
|
:param method: HTTP method
|
|
:param path: Endpoint in API
|
|
:param data: Dictionary with the body. Will be transformed to a JSON
|
|
:param params: Parameters added as a query arg
|
|
"""
|
|
|
|
response = await self.http_query(method, path, data=data, params=params)
|
|
body = await response.read()
|
|
response.close()
|
|
if response.headers.get("CONTENT-TYPE") == "application/json":
|
|
body = json.loads(body.decode("utf-8", errors="ignore"))
|
|
else:
|
|
body = body.decode("utf-8", errors="ignore")
|
|
log.debug("Query Docker %s %s params=%s data=%s Response: %s", method, path, params, data, body)
|
|
return body
|
|
|
|
async def http_query(self, method, path, data={}, params={}, timeout=300): # noqa: ASYNC109 - operation-specific timeout is intentional
|
|
"""
|
|
Makes a query to the docker daemon
|
|
|
|
:param method: HTTP method
|
|
:param path: Endpoint in API
|
|
:param data: Dictionary with the body. Will be transformed to a JSON
|
|
:param params: Parameters added as a query arg
|
|
:param timeout: Total timeout in seconds, an aiohttp ClientTimeout object
|
|
for a finer policy (e.g. an idle socket read timeout), or None for no timeout
|
|
:returns: HTTP response
|
|
"""
|
|
|
|
if isinstance(data, dict):
|
|
data = json.dumps(data)
|
|
headers = {"content-type": "application/json"}
|
|
else:
|
|
# not a dict (e.g. a Docker image tar stream): let aiohttp stream the raw body
|
|
headers = {"content-type": "application/x-tar"}
|
|
if timeout is None:
|
|
timeout = aiohttp.ClientTimeout(total=None)
|
|
|
|
if path == "version":
|
|
url = "http://docker/" + path
|
|
else:
|
|
await self._check_connection() # version is use by check connection
|
|
url = "http://docker/v" + self._api_version + "/" + path
|
|
try:
|
|
if self._session is None or self._session.closed:
|
|
connector = self.connector()
|
|
self._session = aiohttp.ClientSession(connector=connector)
|
|
response = await self._session.request(
|
|
method,
|
|
url,
|
|
params=params,
|
|
data=data,
|
|
headers=headers,
|
|
timeout=timeout,
|
|
)
|
|
except aiohttp.ClientError as e:
|
|
raise DockerError(f"Docker has returned an error: {e}")
|
|
except TimeoutError:
|
|
raise DockerError("Docker timeout " + method + " " + path)
|
|
if response.status >= 300:
|
|
body = await response.read()
|
|
try:
|
|
body = json.loads(body.decode("utf-8"))["message"]
|
|
except ValueError:
|
|
pass
|
|
log.debug(f"Query Docker {method} {path} params={params} data={data} Response: {body}")
|
|
if response.status == 304:
|
|
raise DockerHttp304Error(f"Docker has returned an error: {response.status} {body}")
|
|
elif response.status == 404:
|
|
raise DockerHttp404Error(f"Docker has returned an error: {response.status} {body}")
|
|
elif response.status == 409:
|
|
raise DockerHttp409Error(f"Docker has returned an error: {response.status} {body}")
|
|
else:
|
|
raise DockerError(f"Docker has returned an error: {response.status} {body}")
|
|
return response
|
|
|
|
async def websocket_query(self, path, params={}):
|
|
"""
|
|
Opens a websocket connection
|
|
|
|
:param path: Endpoint in API
|
|
:param params: Parameters added as a query arg
|
|
:returns: Websocket
|
|
"""
|
|
|
|
url = "http://docker/v" + self._api_version + "/" + path
|
|
connection = await self._session.ws_connect(url, origin="http://docker", autoping=True)
|
|
return connection
|
|
|
|
@locking
|
|
async def pull_image(self, image, progress_callback=None, force=False):
|
|
"""
|
|
Pulls an image from the Docker repository
|
|
|
|
:params image: Image name
|
|
:params progress_callback: A function that receives a dict with the
|
|
overall progress of the pull: layer counts and the latest daemon
|
|
message. The first call carries state="started" and happens once
|
|
the pull owns the compute pull lock, so a caller queued behind
|
|
another pull only sees it when the pull really begins.
|
|
:params force: Pull the image even if it is already available locally
|
|
"""
|
|
|
|
layers_total = 0
|
|
layers_done = 0
|
|
|
|
def report(message, state=None):
|
|
if progress_callback:
|
|
progress = {"layers_total": layers_total, "layers_done": layers_done, "message": message}
|
|
if state is not None:
|
|
progress["state"] = state
|
|
progress_callback(progress)
|
|
|
|
report(f"Pulling '{image}' from Docker repository", state="started")
|
|
|
|
if not force:
|
|
try:
|
|
await self.query("GET", f"images/{image}/json")
|
|
return # We already have the image skip the download
|
|
except DockerHttp404Error:
|
|
pass
|
|
|
|
params = {"fromImage": image}
|
|
if "@" not in image:
|
|
# Without a tag or digest the daemon pulls every tag of the
|
|
# repository. Only a ':' after the last '/' is a tag separator:
|
|
# before it, it is a registry port (e.g. registry:5000/repo).
|
|
if ":" not in image.rpartition("/")[2]:
|
|
params["tag"] = "latest"
|
|
|
|
try:
|
|
# The daemon streams progress lines for the whole pull: an idle
|
|
# socket read for a minute means the registry is unreachable and
|
|
# the pull would otherwise hang forever.
|
|
response = await self.http_query(
|
|
"POST",
|
|
"images/create",
|
|
params=params,
|
|
timeout=aiohttp.ClientTimeout(total=None, sock_read=PULL_IDLE_TIMEOUT),
|
|
)
|
|
except DockerHttp404Error as e:
|
|
raise DockerError(
|
|
f"Could not pull the '{image}' image: it was not found in the registry. "
|
|
f"Check the image name or run 'docker login' on the compute host "
|
|
f"(original error: {e})"
|
|
)
|
|
except DockerError as e:
|
|
raise DockerError(
|
|
f"Could not pull the '{image}' image from Docker repository. "
|
|
f"Check the image name, the registry authentication and your Internet connection "
|
|
f"(original error: {e})"
|
|
)
|
|
# The pull api will stream status via an HTTP JSON stream
|
|
content = ""
|
|
try:
|
|
while True:
|
|
try:
|
|
chunk = await response.content.read(CHUNK_SIZE)
|
|
except aiohttp.ServerDisconnectedError as e:
|
|
raise DockerError(
|
|
f"Disconnected while pulling Docker image '{image}' from Docker repository"
|
|
) from e
|
|
except TimeoutError as e:
|
|
raise DockerError(
|
|
f"Timeout while pulling Docker image '{image}' from Docker repository: "
|
|
f"no data received for {PULL_IDLE_TIMEOUT} seconds, "
|
|
f"please check your Internet connection or Docker registry mirror"
|
|
) from e
|
|
if not chunk:
|
|
break
|
|
content += chunk.decode("utf-8")
|
|
|
|
try:
|
|
while True:
|
|
content = content.lstrip(" \r\n\t")
|
|
answer, index = json.JSONDecoder().raw_decode(content)
|
|
if not isinstance(answer, dict):
|
|
raise DockerError(f"Invalid response while pulling Docker image '{image}'")
|
|
error_detail = answer.get("errorDetail")
|
|
error = answer.get("error")
|
|
if not error and isinstance(error_detail, dict):
|
|
error = error_detail.get("message")
|
|
if error:
|
|
raise DockerError(error)
|
|
status = answer.get("status", "")
|
|
if status == "Pulling fs layer":
|
|
layers_total += 1
|
|
elif status in ("Pull complete", "Already exists"):
|
|
layers_done += 1
|
|
message = answer.get("progress") or status
|
|
if message:
|
|
report(message)
|
|
content = content[index:]
|
|
except ValueError: # Partial JSON
|
|
pass
|
|
|
|
if content.strip():
|
|
raise DockerError(f"Invalid response while pulling Docker image '{image}'")
|
|
finally:
|
|
response.close()
|
|
|
|
@locking
|
|
async def load_image(self, stream, image=None, digest=None, progress_callback=None):
|
|
"""
|
|
Load a Docker image into the Docker daemon from a docker save tar stream
|
|
|
|
:param stream: An async iterable of bytes (the tar produced by docker save)
|
|
:param image: Tag of the image in the archive. Together with digest, the
|
|
(controller digest, local id) pair is remembered so that node creation
|
|
can accept the digest the controller pinned for this image
|
|
:param digest: Image id as reported by the Docker daemon on the controller
|
|
host (the value the controller pins in the node create payload)
|
|
:param progress_callback: A function that receive a log message about image load progress
|
|
"""
|
|
|
|
if progress_callback:
|
|
progress_callback("Loading Docker image from stream")
|
|
response = await self.http_query("POST", "images/load", data=stream, timeout=None)
|
|
# The load api will stream status via an HTTP JSON stream
|
|
content = ""
|
|
try:
|
|
while True:
|
|
try:
|
|
chunk = await response.content.read(CHUNK_SIZE)
|
|
except aiohttp.ServerDisconnectedError as e:
|
|
raise DockerError("Disconnected while loading Docker image") from e
|
|
except TimeoutError as e:
|
|
raise DockerError("Timeout while loading Docker image") from e
|
|
if not chunk:
|
|
break
|
|
content += chunk.decode("utf-8", errors="ignore")
|
|
|
|
try:
|
|
while True:
|
|
content = content.lstrip(" \r\n\t")
|
|
answer, index = json.JSONDecoder().raw_decode(content)
|
|
if not isinstance(answer, dict):
|
|
raise DockerError("Invalid response while loading Docker image")
|
|
error_detail = answer.get("errorDetail")
|
|
error = answer.get("error")
|
|
if not error and isinstance(error_detail, dict):
|
|
error = error_detail.get("message")
|
|
if error:
|
|
raise DockerError(error)
|
|
if "stream" in answer and progress_callback:
|
|
progress_callback(answer["stream"].rstrip())
|
|
content = content[index:]
|
|
except ValueError: # Partial JSON
|
|
pass
|
|
|
|
if content.strip():
|
|
raise DockerError("Invalid response while loading Docker image")
|
|
finally:
|
|
response.close()
|
|
|
|
if progress_callback:
|
|
progress_callback("Docker image loaded")
|
|
|
|
if image and digest:
|
|
await self._remember_image_id_translation(image, digest)
|
|
|
|
async def _remember_image_id_translation(self, image, controller_digest):
|
|
"""
|
|
Remember how the local daemon identifies an image that was just loaded
|
|
from the controller.
|
|
|
|
Docker ids are not comparable across image stores: for the same content
|
|
a classic store reports the config digest, while a containerd store (or
|
|
an image loaded from an OCI archive) reports the manifest digest. The
|
|
controller pins the id of its own daemon, so recording the pair lets
|
|
DockerVM accept that pin for the image it actually received instead of
|
|
asking for another full sync on every node creation.
|
|
"""
|
|
|
|
try:
|
|
image_infos = await self.query("GET", f"images/{image}/json")
|
|
except DockerError as e:
|
|
log.warning(f"Image '{image}' has been loaded but cannot be inspected: {e}")
|
|
return
|
|
local_id = image_infos.get("Id")
|
|
if local_id:
|
|
self._image_id_translations[image] = (controller_digest, local_id)
|
|
|
|
def image_id_translation(self, image):
|
|
"""
|
|
:returns: the (controller digest, local id) pair recorded the last time
|
|
this image was loaded from the controller, None otherwise
|
|
"""
|
|
|
|
return self._image_id_translations.get(image)
|
|
|
|
async def list_images(self):
|
|
"""
|
|
Gets Docker image list.
|
|
|
|
:returns: list of dicts
|
|
:rtype: list
|
|
"""
|
|
|
|
images = []
|
|
for image in await self.query("GET", "images/json", params={"all": 0}):
|
|
if image["RepoTags"]:
|
|
for tag in image["RepoTags"]:
|
|
if tag != "<none>:<none>":
|
|
images.append(
|
|
{
|
|
"image": tag,
|
|
"id": image.get("Id"),
|
|
"size": image.get("Size"),
|
|
"created": image_created_timestamp(image),
|
|
}
|
|
)
|
|
return sorted(images, key=lambda i: i["image"])
|
|
|
|
async def delete_image(self, image, force=False):
|
|
"""
|
|
Delete a Docker image from the Docker daemon.
|
|
|
|
When the daemon refuses because containers use the image, the error
|
|
names the GNS3 nodes and projects behind them instead of raw
|
|
container ids.
|
|
|
|
:param image: Image name or id
|
|
:param force: Remove the image even if a container uses it
|
|
"""
|
|
|
|
try:
|
|
await self.query("DELETE", f"images/{image}", params={"force": str(force).lower()})
|
|
except DockerHttp409Error as e:
|
|
blockers = await self._describe_containers_using_image(str(e))
|
|
if blockers:
|
|
raise DockerHttp409Error(
|
|
f"Cannot delete image '{image}': it is still used by {blockers}. "
|
|
f"Delete the node or container first, or repeat with force=true."
|
|
) from e
|
|
raise
|
|
# the image id translation recorded when this image was synced from the
|
|
# controller no longer matches anything on this daemon
|
|
self._image_id_translations.pop(image, None)
|
|
|
|
async def _describe_containers_using_image(self, daemon_error: str) -> str:
|
|
"""
|
|
Translate the container ids named in a daemon image deletion conflict
|
|
into node, project or container descriptions.
|
|
|
|
:param daemon_error: the raw daemon conflict message
|
|
:returns: a comma separated description, empty when the message names
|
|
no container
|
|
"""
|
|
|
|
descriptions = []
|
|
for container_id in CONFLICTING_CONTAINER_RE.findall(daemon_error):
|
|
try:
|
|
info = await self.query("GET", f"containers/{container_id}/json")
|
|
except DockerError:
|
|
info = None
|
|
if not info:
|
|
# the container cannot be inspected (or already vanished)
|
|
descriptions.append(f"container '{container_id}'")
|
|
continue
|
|
name = info.get("Name", container_id).lstrip("/")
|
|
state = "running" if info.get("State", {}).get("Running") else "stopped"
|
|
match = GNS3_CONTAINER_NAME_RE.match(name)
|
|
if match:
|
|
node = match.group("node")
|
|
try:
|
|
project = ProjectManager.instance().get_project(match.group("project_id"))
|
|
except ComputeError:
|
|
# the project is closed on this compute: a leftover container
|
|
descriptions.append(f"leftover container of node '{node}' ({state}, its project is closed)")
|
|
else:
|
|
descriptions.append(f"node '{node}' in project '{project.name}' ({state})")
|
|
else:
|
|
# a container created outside GNS3
|
|
descriptions.append(f"container '{name}' ({state})")
|
|
return ", ".join(descriptions)
|