mount a www and a downloads directory into both client and server

So far, the server had only /www and the client had only /downloads.

Author: marten-seemann

docker-compose.yml

@@ -32,7 +32,8 @@ services:
     stdin_open: true
     tty: true
     volumes:
-      - $WWW:/www:ro
+      - $SERVER_WWW:/www:ro
+      - $SERVER_DOWNLOADS:/downloads:delegated
       - $CERTS:/certs:ro
     environment:
       - CRON=$CRON
@@ -63,7 +64,8 @@ services:
     stdin_open: true
     tty: true
     volumes:
-      - $DOWNLOADS:/downloads:delegated
+      - $CLIENT_WWW:/www:ro
+      - $CLIENT_DOWNLOADS:/downloads:delegated
       - $CERTS:/certs:ro
     environment:
       - CRON=$CRON

interop.py

@@ -110,10 +110,19 @@ def _check_impl_is_compliant(self, name: str, role: Perspective) -> bool:
         self.compliant.setdefault(name, {})
 
         client_log_dir = tempfile.TemporaryDirectory(dir="/tmp", prefix="logs_client_")
-        www_dir = tempfile.TemporaryDirectory(dir="/tmp", prefix="compliance_www_")
         certs_dir = tempfile.TemporaryDirectory(dir="/tmp", prefix="compliance_certs_")
-        downloads_dir = tempfile.TemporaryDirectory(
-            dir="/tmp", prefix="compliance_downloads_"
+
+        client_www_dir = tempfile.TemporaryDirectory(
+            dir="/tmp", prefix="compliance_client_www_"
+        )
+        client_downloads_dir = tempfile.TemporaryDirectory(
+            dir="/tmp", prefix="compliance_client_downloads_"
+        )
+        server_www_dir = tempfile.TemporaryDirectory(
+            dir="/tmp", prefix="compliance_server_www_"
+        )
+        server_downloads_dir = tempfile.TemporaryDirectory(
+            dir="/tmp", prefix="compliance_server_downloads_"
         )
 
         testcases_quic.generate_cert_chain(certs_dir.name)
@@ -126,8 +135,10 @@ def _check_impl_is_compliant(self, name: str, role: Perspective) -> bool:
                 "TESTCASE_CLIENT=" + generate_slug() + " "
                 "SERVER_LOGS=/dev/null "
                 "CLIENT_LOGS=" + client_log_dir.name + " "
-                "WWW=" + www_dir.name + " "
-                "DOWNLOADS=" + downloads_dir.name + " "
+                "CLIENT_WWW=" + client_www_dir.name + " "
+                "CLIENT_DOWNLOADS=" + client_downloads_dir.name + " "
+                "SERVER_WWW=" + server_www_dir.name + " "
+                "SERVER_DOWNLOADS=" + server_downloads_dir.name + " "
                 'SCENARIO="simple-p2p --delay=15ms --bandwidth=10Mbps --queue=25" '
                 "CLIENT=" + self._implementations[name]["image"] + " "
                 "SERVER="
@@ -155,8 +166,10 @@ def _check_impl_is_compliant(self, name: str, role: Perspective) -> bool:
                 "TESTCASE_SERVER=" + generate_slug() + " "
                 "SERVER_LOGS=" + server_log_dir.name + " "
                 "CLIENT_LOGS=/dev/null "
-                "WWW=" + www_dir.name + " "
-                "DOWNLOADS=" + downloads_dir.name + " "
+                "CLIENT_WWW=" + client_www_dir.name + " "
+                "CLIENT_DOWNLOADS=" + client_downloads_dir.name + " "
+                "SERVER_WWW=" + server_www_dir.name + " "
+                "SERVER_DOWNLOADS=" + server_downloads_dir.name + " "
                 "CLIENT="
                 + self._implementations[name]["image"]
                 + " "  # only needed so docker compose doesn't complain
@@ -172,8 +185,6 @@ def _check_impl_is_compliant(self, name: str, role: Perspective) -> bool:
                 self.compliant[name][role] = False
                 return False
             logging.debug("%s server compliant.", name)
-        else:
-            raise ValueError(f"Unknown perspective for compliance check: {role}")
 
         # remember compliance test outcome for this role
         self.compliant[name][role] = True
@@ -410,8 +421,10 @@ def _run_test(
             "CERTS=" + test.certs_dir() + " "
             "TESTCASE_SERVER=" + test.testname(Perspective.SERVER) + " "
             "TESTCASE_CLIENT=" + test.testname(Perspective.CLIENT) + " "
-            "WWW=" + test.www_dir() + " "
-            "DOWNLOADS=" + test.download_dir() + " "
+            "CLIENT_WWW=" + test.client_www_dir() + " "
+            "CLIENT_DOWNLOADS=" + test.client_download_dir() + " "
+            "SERVER_WWW=" + test.server_www_dir() + " "
+            "SERVER_DOWNLOADS=" + test.server_download_dir() + " "
             "SERVER_LOGS=" + server_log_dir.name + " "
             "CLIENT_LOGS=" + client_log_dir.name + " "
             'SCENARIO="{}" '
@@ -423,7 +436,7 @@ def _run_test(
         containers = "sim client server " + " ".join(test.additional_containers())
         cmd = (
             params
-            + " docker compose --env-file empty.env up --abort-on-container-exit --timeout 1 "
+            + " docker compose --env-file empty.env up --abort-on-container-exit --timeout 10 "
             + containers
         )
         logging.debug("Command: %s", cmd)
@@ -485,11 +498,30 @@ def _run_test(
             shutil.copytree(sim_log_dir.name, log_dir + "/sim")
             shutil.copyfile(log_file.name, log_dir + "/output.txt")
             if self._save_files and status == TestResult.FAILED:
-                shutil.copytree(test.www_dir(), log_dir + "/www")
                 try:
-                    shutil.copytree(test.download_dir(), log_dir + "/downloads")
+                    shutil.copytree(test.server_www_dir(), log_dir + "/server_www")
+                except Exception as exception:
+                    logging.info("Could not copy server www files: %s", exception)
+                try:
+                    shutil.copytree(
+                        test.client_download_dir(), log_dir + "/client_downloads"
+                    )
                 except Exception as exception:
-                    logging.info("Could not copy downloaded files: %s", exception)
+                    logging.info(
+                        "Could not copy client downloaded files: %s", exception
+                    )
+                try:
+                    shutil.copytree(test.client_www_dir(), log_dir + "/client_www")
+                except Exception as exception:
+                    logging.info("Could not copy client www files: %s", exception)
+                try:
+                    shutil.copytree(
+                        test.server_download_dir(), log_dir + "/server_downloads"
+                    )
+                except Exception as exception:
+                    logging.info(
+                        "Could not copy server downloaded files: %s", exception
+                    )
 
         test.cleanup()
         server_log_dir.cleanup()

testcase.py

@@ -41,14 +41,16 @@ def generate_cert_chain(directory: str, length: int = 1):
 
 class TestCase(abc.ABC):
     _files = []
-    _www_dir = None
     _client_keylog_file = None
     _server_keylog_file = None
-    _download_dir = None
     _sim_log_dir = None
     _cert_dir = None
     _cached_server_trace = None
     _cached_client_trace = None
+    _client_www_dir = None
+    _client_download_dir = None
+    _server_www_dir = None
+    _server_download_dir = None
 
     def __init__(
         self,
@@ -99,17 +101,33 @@ def additional_envs() -> List[str]:
     def additional_containers() -> List[str]:
         return [""]
 
-    def www_dir(self):
-        if not self._www_dir:
-            self._www_dir = tempfile.TemporaryDirectory(dir="/tmp", prefix="www_")
-        return self._www_dir.name + "/"
+    def client_www_dir(self):
+        if not self._client_www_dir:
+            self._client_www_dir = tempfile.TemporaryDirectory(
+                dir="/tmp", prefix="client_www_"
+            )
+        return self._client_www_dir.name + "/"
+
+    def client_download_dir(self):
+        if not self._client_download_dir:
+            self._client_download_dir = tempfile.TemporaryDirectory(
+                dir="/tmp", prefix="client_download_"
+            )
+        return self._client_download_dir.name + "/"
+
+    def server_www_dir(self):
+        if not self._server_www_dir:
+            self._server_www_dir = tempfile.TemporaryDirectory(
+                dir="/tmp", prefix="server_www_"
+            )
+        return self._server_www_dir.name + "/"
 
-    def download_dir(self):
-        if not self._download_dir:
-            self._download_dir = tempfile.TemporaryDirectory(
-                dir="/tmp", prefix="download_"
+    def server_download_dir(self):
+        if not self._server_download_dir:
+            self._server_download_dir = tempfile.TemporaryDirectory(
+                dir="/tmp", prefix="server_download_"
             )
-        return self._download_dir.name + "/"
+        return self._server_download_dir.name + "/"
 
     def certs_dir(self):
         if not self._cert_dir:
@@ -176,7 +194,7 @@ def _generate_random_file(self, size: int, filename: str = None) -> str:
             filename = generate_slug()
         # see https://www.stefanocappellini.it/generate-pseudorandom-bytes-with-python/ for benchmarks
         enc = AES.new(os.urandom(32), AES.MODE_OFB, b"a" * 16)
-        f = open(self.www_dir() + filename, "wb")
+        f = open(self.server_www_dir() + filename, "wb")
         f.write(enc.encrypt(b" " * size))
         f.close()
         logging.debug("Generated random file: %s of size: %d", filename, size)
@@ -200,8 +218,8 @@ def _check_files(self) -> bool:
             raise Exception("No test files generated.")
         files = [
             n
-            for n in os.listdir(self.download_dir())
-            if os.path.isfile(os.path.join(self.download_dir(), n))
+            for n in os.listdir(self.client_download_dir())
+            if os.path.isfile(os.path.join(self.client_download_dir(), n))
         ]
         too_many = [f for f in files if f not in self._files]
         if len(too_many) != 0:
@@ -212,12 +230,12 @@ def _check_files(self) -> bool:
         if len(too_many) != 0 or len(too_few) != 0:
             return False
         for f in self._files:
-            fp = self.download_dir() + f
+            fp = self.client_download_dir() + f
             if not os.path.isfile(fp):
                 logging.info("File %s does not exist.", fp)
                 return False
             try:
-                size = os.path.getsize(self.www_dir() + f)
+                size = os.path.getsize(self.server_www_dir() + f)
                 downloaded_size = os.path.getsize(fp)
                 if size != downloaded_size:
                     logging.info(
@@ -227,13 +245,13 @@ def _check_files(self) -> bool:
                         downloaded_size,
                     )
                     return False
-                if not filecmp.cmp(self.www_dir() + f, fp, shallow=False):
+                if not filecmp.cmp(self.server_www_dir() + f, fp, shallow=False):
                     logging.info("File contents of %s do not match.", fp)
                     return False
             except Exception as exception:
                 logging.info(
                     "Could not compare files %s and %s: %s",
-                    self.www_dir() + f,
+                    self.server_www_dir() + f,
                     fp,
                     exception,
                 )
@@ -268,12 +286,18 @@ def _payload_size(self, packets: List) -> int:
         return size
 
     def cleanup(self):
-        if self._www_dir:
-            self._www_dir.cleanup()
-            self._www_dir = None
-        if self._download_dir:
-            self._download_dir.cleanup()
-            self._download_dir = None
+        if self._client_www_dir:
+            self._client_www_dir.cleanup()
+            self._client_www_dir = None
+        if self._client_download_dir:
+            self._client_download_dir.cleanup()
+            self._client_download_dir = None
+        if self._server_www_dir:
+            self._server_www_dir.cleanup()
+            self._server_www_dir = None
+        if self._server_download_dir:
+            self._server_download_dir.cleanup()
+            self._server_download_dir = None
 
     @abc.abstractmethod
     def get_paths(self):