Backport from v3: install Docker resources in a writable location at runtime.

gns3server/compute/docker/__init__.py

@@ -19,11 +19,15 @@
 Docker server module.
 """
 
+import os
 import sys
 import json
 import asyncio
 import logging
 import aiohttp
+import shutil
+import platformdirs
+
 from gns3server.utils import parse_version
 from gns3server.utils.asyncio import locking
 from gns3server.compute.base_manager import BaseManager
@@ -55,6 +59,62 @@ class Docker(BaseManager):
         self._session = None
         self._api_version = DOCKER_MINIMUM_API_VERSION
 
+    @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:
+                        # ldd returns 1 if the file is not a dynamic executable
+                        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")
+
+    @staticmethod
+    def resources_path():
+        """
+        Get the Docker resources storage directory
+        """
+
+        appname = vendor = "GNS3"
+        docker_resources_dir = os.path.join(platformdirs.user_data_dir(appname, vendor, roaming=True), "docker", "resources")
+        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
+            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:

gns3server/compute/docker/docker_vm.py

@@ -242,10 +242,13 @@ class DockerVM(BaseNode):
         :returns: Return the path that we need to map to local folders
         """
 
-        resources = get_resource("compute/docker/resources")
-        if not os.path.exists(resources):
-            raise DockerError("{} is missing can't start Docker containers".format(resources))
-        binds = ["{}:/gns3:ro".format(resources)]
+        try:
+            resources_path = self.manager.resources_path()
+        except OSError as e:
+            raise DockerError(f"Cannot access resources: {e}")
+
+        log.info(f'Mount resources from "{resources_path}"')
+        binds = ["{}:/gns3:ro".format(resources_path)]
 
         # We mount our own etc/network
         try:
@@ -460,6 +463,8 @@ class DockerVM(BaseNode):
         Starts this Docker container.
         """
 
+        await self.manager.install_resources()
+
         try:
             state = await self._get_container_state()
         except DockerHttp404Error: