truss 0.10.13__py3-none-any.whl → 0.11.1rc1__py3-none-any.whl

truss/templates/server.Dockerfile.jinja

@@ -11,7 +11,6 @@
 {% if config.base_image %}
     {%- if not config.docker_server %}
 ENV PYTHONUNBUFFERED="True"
-ENV DEBIAN_FRONTEND="noninteractive"
 
 {# Install common dependencies #}
 RUN apt update && \
@@ -20,7 +19,7 @@ RUN apt update && \
     && apt-get clean -y \
     && rm -rf /var/lib/apt/lists/*
 
-COPY ./{{ base_server_requirements_filename }} {{ base_server_requirements_filename }}
+COPY --chown={{ default_owner }} ./{{ base_server_requirements_filename }} {{ base_server_requirements_filename }}
 RUN {{ sys_pip_install_command }} -r {{ base_server_requirements_filename }} --no-cache-dir
     {%- endif %} {#- endif not config.docker_server #}
 
@@ -38,7 +37,7 @@ RUN ln -sf {{ config.base_image.python_executable_path }} /usr/local/bin/python
 
 {% block install_requirements %}
     {%- if should_install_server_requirements %}
-COPY ./{{ server_requirements_filename }} {{ server_requirements_filename }}
+COPY --chown={{ default_owner }} ./{{ server_requirements_filename }} {{ server_requirements_filename }}
 RUN {{ sys_pip_install_command }} -r {{ server_requirements_filename }} --no-cache-dir
     {%- endif %} {#- endif should_install_server_requirements #}
 {{ super() }}
@@ -47,7 +46,7 @@ RUN {{ sys_pip_install_command }} -r {{ server_requirements_filename }} --no-cac
 
 {% block app_copy %}
 {%- if model_cache_v1 %}
-# Copy data before code for better caching
+{# Copy data before code for better caching #}
 {%- include "copy_cache_files.Dockerfile.jinja" -%}
 {%- endif %} {#- endif model_cache_v1 #}
 
@@ -65,47 +64,55 @@ RUN {% for secret,path in config.build.secret_to_path_mapping.items() %} --mount
 
 {# Copy data before code for better caching #}
 {%- if data_dir_exists %}
-COPY ./{{ config.data_dir }} /app/data
+COPY --chown={{ default_owner }} ./{{ config.data_dir }} ${APP_HOME}/data
 {%- endif %} {#- endif data_dir_exists #}
 
 {%- if model_cache_v2 %}
-# v0.0.9, keep synced with server_requirements.txt
+{# v0.0.9, keep synced with server_requirements.txt #}
 RUN curl -sSL --fail --retry 5 --retry-delay 2 -o /usr/local/bin/truss-transfer-cli https://github.com/basetenlabs/truss/releases/download/v0.10.11rc1/truss-transfer-cli-v0.10.11rc1-linux-x86_64-unknown-linux-musl
 RUN chmod +x /usr/local/bin/truss-transfer-cli
 RUN mkdir /static-bptr
 RUN echo "hash {{model_cache_hash}}"
-COPY ./bptr-manifest /static-bptr/static-bptr-manifest.json
+COPY --chown={{ default_owner }} ./bptr-manifest /static-bptr/static-bptr-manifest.json
 {%- endif %} {#- endif model_cache_v2 #}
 
 {%- if not config.docker_server %}
-COPY ./server /app
+COPY --chown={{ default_owner }} ./server ${APP_HOME}
 {%- endif %} {#- endif not config.docker_server #}
 
 {%- if use_local_src %}
 {# This path takes precedence over site-packages. #}
-COPY ./truss_chains /app/truss_chains
-COPY ./truss /app/truss
+COPY --chown={{ default_owner }} ./truss_chains ${APP_HOME}/truss_chains
+COPY --chown={{ default_owner }} ./truss ${APP_HOME}/truss
 {%- endif %} {#- endif use_local_src #}
 
-COPY ./config.yaml /app/config.yaml
+COPY --chown={{ default_owner }} ./config.yaml ${APP_HOME}/config.yaml
 {%- if requires_live_reload %}
 RUN uv python install {{ control_python_version }}
 RUN uv venv /control/.env --python {{ control_python_version }}
 
-COPY ./control /control
+COPY --chown={{ default_owner }} ./control /control
 RUN uv pip install -r /control/requirements.txt --python /control/.env/bin/python --no-cache-dir
 {%- endif %} {#- endif requires_live_reload #}
 
 {%- if model_dir_exists %}
-COPY ./{{ config.model_module_dir }} /app/model
+COPY --chown={{ default_owner }} ./{{ config.model_module_dir }} ${APP_HOME}/model
 {%- endif %} {#- endif model_dir_exists #}
 {% endblock %} {#- endblock app_copy #}
 
 {% block run %}
+{# Macro to change ownership of directories and switch to regular user #}
+{%- macro chown_and_switch_to_regular_user_if_enabled(additional_chown_dirs=[]) -%}
+{%- if non_root_user %}
+RUN chown -R {{ app_username }}:{{ app_username }} {% for dir in additional_chown_dirs %}{{ dir }} {% endfor %}${HOME} ${APP_HOME}
+USER {{ app_username }}
+{%- endif %} {#- endif non_root_user #}
+{%- endmacro -%}
+
     {%- if config.docker_server %}
-RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
+RUN apt-get update -y && apt-get install -y --no-install-recommends \
         curl nginx && rm -rf /var/lib/apt/lists/*
-COPY ./docker_server_requirements.txt /app/docker_server_requirements.txt
+COPY --chown={{ default_owner }} ./docker_server_requirements.txt ${APP_HOME}/docker_server_requirements.txt
 
 {# NB(nikhil): Use the same python version for custom server proxy as the control server, for consistency. #}
 RUN uv python install {{ control_python_version }}
@@ -113,23 +120,30 @@ RUN uv venv /docker_server/.venv --python {{ control_python_version }}
 RUN uv pip install --python /docker_server/.venv/bin/python -r /app/docker_server_requirements.txt --no-cache-dir
 {% set proxy_config_path = "/etc/nginx/conf.d/proxy.conf" %}
 {% set supervisor_config_path = "/etc/supervisor/supervisord.conf" %}
-{% set supervisor_log_dir = "/var/log/supervisor" %}
 {% set supervisor_server_url = "http://localhost:8080" %}
-COPY ./proxy.conf {{ proxy_config_path }}
-RUN mkdir -p {{ supervisor_log_dir }}
-COPY supervisord.conf {{ supervisor_config_path }}
+COPY --chown={{ default_owner }} ./proxy.conf {{ proxy_config_path }}
+COPY --chown={{ default_owner }} ./supervisord.conf {{ supervisor_config_path }}
 ENV SUPERVISOR_SERVER_URL="{{ supervisor_server_url }}"
 ENV SERVER_START_CMD="/docker_server/.venv/bin/supervisord -c {{ supervisor_config_path }}"
+{#- default configuration uses port 80, which requires root privileges, so we remove it #}
+RUN rm -f /etc/nginx/sites-enabled/default
+{#- nginx writes to /var/lib/nginx, /var/log/nginx, and /run directories #}
+{{ chown_and_switch_to_regular_user_if_enabled(["/var/lib/nginx", "/var/log/nginx", "/run"]) }}
 ENTRYPOINT ["/docker_server/.venv/bin/supervisord", "-c", "{{ supervisor_config_path }}"]
+
     {%- elif requires_live_reload %} {#- elif requires_live_reload #}
 ENV HASH_TRUSS="{{ truss_hash }}"
 ENV CONTROL_SERVER_PORT="8080"
 ENV INFERENCE_SERVER_PORT="8090"
 ENV SERVER_START_CMD="/control/.env/bin/python /control/control/server.py"
+{{ chown_and_switch_to_regular_user_if_enabled() }}
 ENTRYPOINT ["/control/.env/bin/python", "/control/control/server.py"]
+
     {%- else %} {#- else (default inference server) #}
 ENV INFERENCE_SERVER_PORT="8080"
 ENV SERVER_START_CMD="{{ python_executable }} /app/main.py"
+{{ chown_and_switch_to_regular_user_if_enabled() }}
 ENTRYPOINT ["{{ python_executable }}", "/app/main.py"]
     {%- endif %} {#- endif config.docker_server / live_reload #}
+
 {% endblock %} {#- endblock run #}

truss/tests/cli/train/test_train_cli_core.py

@@ -1,6 +1,11 @@
 from unittest.mock import Mock, patch
 
-from truss.cli.train.core import view_training_job_metrics
+from truss.cli.train.core import (
+    calculate_directory_sizes,
+    create_file_summary_with_directory_sizes,
+    view_training_job_metrics,
+)
+from truss.remote.baseten.custom_types import FileSummary
 
 
 @patch("truss.cli.train.metrics_watcher.time.sleep")
@@ -189,3 +194,251 @@ def test_view_training_job_metrics(time_sleep, capfd):
     out, err = capfd.readouterr()
     assert "Training job completed successfully" in out
     assert "Error fetching metrics" not in out
+
+
+def test_calculate_directory_sizes():
+    """Test calculate_directory_sizes function with various file structures."""
+    # Create test files with a nested directory structure
+    files = [
+        FileSummary(
+            path="/root",
+            size_bytes=0,
+            modified="2023-01-01T00:00:00Z",
+            file_type="directory",
+            permissions="drwxr-xr-x",
+        ),
+        FileSummary(
+            path="/root/file1.txt",
+            size_bytes=100,
+            modified="2023-01-01T00:00:00Z",
+            file_type="file",
+            permissions="-rw-r--r--",
+        ),
+        FileSummary(
+            path="/root/subdir",
+            size_bytes=0,
+            modified="2023-01-01T00:00:00Z",
+            file_type="directory",
+            permissions="drwxr-xr-x",
+        ),
+        FileSummary(
+            path="/root/subdir/file2.txt",
+            size_bytes=200,
+            modified="2023-01-01T00:00:00Z",
+            file_type="file",
+            permissions="-rw-r--r--",
+        ),
+        FileSummary(
+            path="/root/subdir/file3.txt",
+            size_bytes=300,
+            modified="2023-01-01T00:00:00Z",
+            file_type="file",
+            permissions="-rw-r--r--",
+        ),
+        FileSummary(
+            path="/root/other_file.txt",
+            size_bytes=50,
+            modified="2023-01-01T00:00:00Z",
+            file_type="file",
+            permissions="-rw-r--r--",
+        ),
+    ]
+
+    result = calculate_directory_sizes(files)
+
+    # Check that directory sizes are calculated correctly
+    assert result["/root/subdir"] == 500  # 200 + 300
+    assert result["/root"] == 650  # 100 + 200 + 300 + 50
+
+    # Check that files are not included in the result (only directories)
+    assert "/root/file1.txt" not in result
+    assert "/root/subdir/file2.txt" not in result
+    assert "/root/subdir/file3.txt" not in result
+    assert "/root/other_file.txt" not in result
+
+
+def test_calculate_directory_sizes_empty_list():
+    """Test calculate_directory_sizes with empty file list."""
+    result = calculate_directory_sizes([])
+    assert result == {}
+
+
+def test_calculate_directory_sizes_no_directories():
+    """Test calculate_directory_sizes with only files (no directories)."""
+    files = [
+        FileSummary(
+            path="/file1.txt",
+            size_bytes=100,
+            modified="2023-01-01T00:00:00Z",
+            file_type="file",
+            permissions="-rw-r--r--",
+        ),
+        FileSummary(
+            path="/file2.txt",
+            size_bytes=200,
+            modified="2023-01-01T00:00:00Z",
+            file_type="file",
+            permissions="-rw-r--r--",
+        ),
+    ]
+
+    result = calculate_directory_sizes(files)
+    assert result == {}
+
+
+def test_create_file_summary_with_directory_sizes():
+    """Test create_file_summary_with_directory_sizes function."""
+    files = [
+        FileSummary(
+            path="/root",
+            size_bytes=0,
+            modified="2023-01-01T00:00:00Z",
+            file_type="directory",
+            permissions="drwxr-xr-x",
+        ),
+        FileSummary(
+            path="/root/file1.txt",
+            size_bytes=100,
+            modified="2023-01-01T00:00:00Z",
+            file_type="file",
+            permissions="-rw-r--r--",
+        ),
+        FileSummary(
+            path="/root/subdir",
+            size_bytes=0,
+            modified="2023-01-01T00:00:00Z",
+            file_type="directory",
+            permissions="drwxr-xr-x",
+        ),
+        FileSummary(
+            path="/root/subdir/file2.txt",
+            size_bytes=200,
+            modified="2023-01-01T00:00:00Z",
+            file_type="file",
+            permissions="-rw-r--r--",
+        ),
+    ]
+
+    result = create_file_summary_with_directory_sizes(files)
+
+    # Check that we get the correct number of FileSummaryWithTotalSize objects
+    assert len(result) == 4
+
+    # Check that files have their original size as total_size
+    file1_summary = next(f for f in result if f.file_summary.path == "/root/file1.txt")
+    assert file1_summary.total_size == 100
+
+    file2_summary = next(
+        f for f in result if f.file_summary.path == "/root/subdir/file2.txt"
+    )
+    assert file2_summary.total_size == 200
+
+    # Check that directories have calculated total sizes
+    subdir_summary = next(f for f in result if f.file_summary.path == "/root/subdir")
+    assert subdir_summary.total_size == 200  # Only file2.txt
+
+    root_summary = next(f for f in result if f.file_summary.path == "/root")
+    assert root_summary.total_size == 300  # file1.txt + file2.txt
+
+
+def test_create_file_summary_with_directory_sizes_empty_list():
+    """Test create_file_summary_with_directory_sizes with empty file list."""
+    result = create_file_summary_with_directory_sizes([])
+    assert result == []
+
+
+def test_calculate_directory_sizes_max_depth():
+    """Test that calculate_directory_sizes respects the max_depth parameter.
+
+    The max_depth parameter controls how many parent directories up from each file
+    the algorithm will traverse to add the file's size to parent directories.
+    """
+    # Create a deep directory structure: /root/level1/level2/level3/level4/level5/file.txt
+    files = [
+        # Root directory
+        FileSummary(
+            path="/root",
+            size_bytes=0,
+            modified="2023-01-01T00:00:00Z",
+            file_type="directory",
+            permissions="drwxr-xr-x",
+        ),
+        # Level 1 directory
+        FileSummary(
+            path="/root/level1",
+            size_bytes=0,
+            modified="2023-01-01T00:00:00Z",
+            file_type="directory",
+            permissions="drwxr-xr-x",
+        ),
+        # Level 2 directory
+        FileSummary(
+            path="/root/level1/level2",
+            size_bytes=0,
+            modified="2023-01-01T00:00:00Z",
+            file_type="directory",
+            permissions="drwxr-xr-x",
+        ),
+        # Level 3 directory
+        FileSummary(
+            path="/root/level1/level2/level3",
+            size_bytes=0,
+            modified="2023-01-01T00:00:00Z",
+            file_type="directory",
+            permissions="drwxr-xr-x",
+        ),
+        # Level 4 directory
+        FileSummary(
+            path="/root/level1/level2/level3/level4",
+            size_bytes=0,
+            modified="2023-01-01T00:00:00Z",
+            file_type="directory",
+            permissions="drwxr-xr-x",
+        ),
+        # Level 5 directory
+        FileSummary(
+            path="/root/level1/level2/level3/level4/level5",
+            size_bytes=0,
+            modified="2023-01-01T00:00:00Z",
+            file_type="directory",
+            permissions="drwxr-xr-x",
+        ),
+        # File at level 1
+        FileSummary(
+            path="/root/level1/file1.txt",
+            size_bytes=100,
+            modified="2023-01-01T00:00:00Z",
+            file_type="file",
+            permissions="-rw-r--r--",
+        ),
+        # File at level 2
+        FileSummary(
+            path="/root/level1/level2/file2.txt",
+            size_bytes=200,
+            modified="2023-01-01T00:00:00Z",
+            file_type="file",
+            permissions="-rw-r--r--",
+        ),
+        # File at level 3
+        FileSummary(
+            path="/root/level1/level2/level3/file3.txt",
+            size_bytes=300,
+            modified="2023-01-01T00:00:00Z",
+            file_type="file",
+            permissions="-rw-r--r--",
+        ),
+    ]
+
+    result_depth_0 = calculate_directory_sizes(files, max_depth=0)
+    assert result_depth_0["/root"] == 0
+    assert result_depth_0["/root/level1"] == 0
+    assert result_depth_0["/root/level1/level2"] == 0
+    assert result_depth_0["/root/level1/level2/level3"] == 0
+
+    # ensure that we stop early if the max depth is reached
+    result_depth_2 = calculate_directory_sizes(files, max_depth=2)
+
+    assert result_depth_2["/root"] == 0
+    assert result_depth_2["/root/level1"] == 100  # file1.txt only
+    assert result_depth_2["/root/level1/level2"] == 200  # file2.txt only
+    assert result_depth_2["/root/level1/level2/level3"] == 300  # file3.txt only

truss/tests/contexts/image_builder/test_serving_image_builder.py

@@ -466,7 +466,7 @@ def test_model_cache_dockerfile_v2(test_data_path):
             print(gen_docker_file)
             assert "truss-transfer" in gen_docker_file
             assert (
-                "COPY ./bptr-manifest /static-bptr/static-bptr-manifest.json"
+                "COPY --chown= ./bptr-manifest /static-bptr/static-bptr-manifest.json"
                 in gen_docker_file
             ), "bptr-manifest copy not found in Dockerfile"
             assert "cache_warmer.py" not in gen_docker_file

truss/tests/templates/control/control/test_endpoints.py

@@ -1,4 +1,5 @@
-from unittest.mock import AsyncMock, MagicMock, patch
+import asyncio
+from unittest.mock import AsyncMock, MagicMock, call, patch
 
 import pytest
 from fastapi import FastAPI, WebSocket
@@ -31,33 +32,40 @@ def client_ws(app):
 
 @pytest.mark.asyncio
 async def test_proxy_ws_bidirectional_messaging(client_ws):
-    """Test that both directions of communication work and clean up properly"""
-    client_ws.receive.side_effect = [
-        {"type": "websocket.receive", "text": "msg1"},
-        {"type": "websocket.receive", "text": "msg2"},
-        {"type": "websocket.disconnect"},
-    ]
+    client_queue = asyncio.Queue()
+    client_ws.receive = client_queue.get
 
+    server_queue = asyncio.Queue()
     mock_server_ws = AsyncMock(spec=AsyncWebSocketSession)
-    mock_server_ws.receive.side_effect = [
-        TextMessage(data="response1"),
-        TextMessage(data="response2"),
-        None,  # server closing connection
-    ]
+    mock_server_ws.receive = server_queue.get
     mock_server_ws.__aenter__.return_value = mock_server_ws
     mock_server_ws.__aexit__.return_value = None
 
+    client_queue.put_nowait({"type": "websocket.receive", "text": "msg1"})
+    client_queue.put_nowait({"type": "websocket.receive", "text": "msg2"})
+    server_queue.put_nowait(TextMessage(data="response1"))
+    server_queue.put_nowait(TextMessage(data="response2"))
+
     with patch(
         "truss.templates.control.control.endpoints.aconnect_ws",
         return_value=mock_server_ws,
     ):
-        await proxy_ws(client_ws)
+        proxy_task = asyncio.create_task(proxy_ws(client_ws))
+        await asyncio.sleep(0.5)
+
+        client_queue.put_nowait(
+            {"type": "websocket.disconnect", "code": 1002, "reason": "test-closure"}
+        )
+
+        await proxy_task
 
     assert mock_server_ws.send_text.call_count == 2
     assert mock_server_ws.send_text.call_args_list == [(("msg1",),), (("msg2",),)]
     assert client_ws.send_text.call_count == 2
     assert client_ws.send_text.call_args_list == [(("response1",),), (("response2",),)]
-    client_ws.close.assert_called_once()
+
+    assert mock_server_ws.close.call_args_list[0] == call(1002, "test-closure")
+    client_ws.close.assert_called()
 
 
 @pytest.mark.asyncio

truss/tests/templates/control/control/test_server_integration.py

@@ -21,6 +21,54 @@ from prometheus_client.parser import text_string_to_metric_families
 PATCH_PING_MAX_DELAY_SECS = 3
 
 
+def _start_truss_server(
+    stdout_capture_file_path: str,
+    truss_control_container_fs: Path,
+    with_patch_ping_flow: bool,
+    patch_ping_server_port: int,
+    ctrl_port: int,
+    inf_port: int,
+):
+    """Module-level function to avoid pickling issues with multiprocessing."""
+    if with_patch_ping_flow:
+        os.environ["PATCH_PING_URL_TRUSS"] = (
+            f"http://localhost:{patch_ping_server_port}"
+        )
+    sys.stdout = open(stdout_capture_file_path, "w")
+    app_path = truss_control_container_fs / "app"
+    sys.path.append(str(app_path))
+    control_path = truss_control_container_fs / "control" / "control"
+    sys.path.append(str(control_path))
+
+    from server import ControlServer
+
+    control_server = ControlServer(
+        python_executable_path=sys.executable,
+        inf_serv_home=str(app_path),
+        control_server_port=ctrl_port,
+        inference_server_port=inf_port,
+    )
+    control_server.run()
+
+
+def _start_patch_ping_server(patch_ping_server_port: int):
+    """Module-level function to avoid pickling issues with multiprocessing."""
+    import json
+    import random
+    import time
+    from http.server import BaseHTTPRequestHandler, HTTPServer
+
+    class Handler(BaseHTTPRequestHandler):
+        def do_POST(self):
+            time.sleep(random.uniform(0, PATCH_PING_MAX_DELAY_SECS))
+            self.send_response(200)
+            self.end_headers()
+            self.wfile.write(bytes(json.dumps({"is_current": True}), encoding="utf-8"))
+
+    httpd = HTTPServer(("localhost", patch_ping_server_port), Handler)
+    httpd.serve_forever()
+
+
 @dataclass
 class ControlServerDetails:
     control_server_process: Process
@@ -270,51 +318,24 @@ def _configured_control_server(
     inf_port = ctrl_port + 1
     patch_ping_server_port = ctrl_port + 2
 
-    def start_truss_server(stdout_capture_file_path):
-        if with_patch_ping_flow:
-            os.environ["PATCH_PING_URL_TRUSS"] = (
-                f"http://localhost:{patch_ping_server_port}"
-            )
-        sys.stdout = open(stdout_capture_file_path, "w")
-        app_path = truss_control_container_fs / "app"
-        sys.path.append(str(app_path))
-        control_path = truss_control_container_fs / "control" / "control"
-        sys.path.append(str(control_path))
-
-        from server import ControlServer
-
-        control_server = ControlServer(
-            python_executable_path=sys.executable,
-            inf_serv_home=str(app_path),
-            control_server_port=ctrl_port,
-            inference_server_port=inf_port,
-        )
-        control_server.run()
-
-    def start_patch_ping_server():
-        import json
-        import random
-        import time
-        from http.server import BaseHTTPRequestHandler, HTTPServer
-
-        class Handler(BaseHTTPRequestHandler):
-            def do_POST(self):
-                time.sleep(random.uniform(0, PATCH_PING_MAX_DELAY_SECS))
-                self.send_response(200)
-                self.end_headers()
-                self.wfile.write(
-                    bytes(json.dumps({"is_current": True}), encoding="utf-8")
-                )
-
-        httpd = HTTPServer(("localhost", patch_ping_server_port), Handler)
-        httpd.serve_forever()
-
     stdout_capture_file = tempfile.NamedTemporaryFile()
-    subproc = Process(target=start_truss_server, args=(stdout_capture_file.name,))
+    subproc = Process(
+        target=_start_truss_server,
+        args=(
+            stdout_capture_file.name,
+            truss_control_container_fs,
+            with_patch_ping_flow,
+            patch_ping_server_port,
+            ctrl_port,
+            inf_port,
+        ),
+    )
     subproc.start()
     proc_id = subproc.pid
     if with_patch_ping_flow:
-        patch_ping_server_proc = Process(target=start_patch_ping_server)
+        patch_ping_server_proc = Process(
+            target=_start_patch_ping_server, args=(patch_ping_server_port,)
+        )
         patch_ping_server_proc.start()
     try:
         time.sleep(2.0)

truss/tests/templates/server/test_truss_server.py

@@ -10,23 +10,30 @@ from pathlib import Path
 import pytest
 
 
-@pytest.mark.integration
-def test_truss_server_termination(truss_container_fs):
-    port = 10123
+def _start_truss_server(
+    stdout_capture_file_path: str, truss_container_fs: Path, port: int
+):
+    """Module-level function to avoid pickling issues with multiprocessing."""
+    sys.stdout = open(stdout_capture_file_path, "w")
+    app_path = truss_container_fs / "app"
+    sys.path.append(str(app_path))
+    os.chdir(app_path)
+
+    from truss_server import TrussServer
 
-    def start_truss_server(stdout_capture_file_path):
-        sys.stdout = open(stdout_capture_file_path, "w")
-        app_path = truss_container_fs / "app"
-        sys.path.append(str(app_path))
-        os.chdir(app_path)
+    server = TrussServer(http_port=port, config_or_path=app_path / "config.yaml")
+    server.start()
 
-        from truss_server import TrussServer
 
-        server = TrussServer(http_port=port, config_or_path=app_path / "config.yaml")
-        server.start()
+@pytest.mark.integration
+def test_truss_server_termination(truss_container_fs):
+    port = 10123
 
     stdout_capture_file = tempfile.NamedTemporaryFile()
-    subproc = Process(target=start_truss_server, args=(stdout_capture_file.name,))
+    subproc = Process(
+        target=_start_truss_server,
+        args=(stdout_capture_file.name, truss_container_fs, port),
+    )
     subproc.start()
     proc_id = subproc.pid
     time.sleep(2.0)

truss/tests/test_data/server.Dockerfile

@@ -1,6 +1,11 @@
 ARG PYVERSION=py39
 FROM baseten/truss-server-base:3.9-v0.4.3 AS truss_server
 ENV PYTHON_EXECUTABLE="/usr/local/bin/python3"
+ENV HOME=/home/app
+ENV APP_HOME=/app
+RUN mkdir -p ${APP_HOME} /control
+RUN useradd -u 60000 -ms /bin/bash app
+ENV DEBIAN_FRONTEND=noninteractive
 RUN grep -w 'ID=debian\|ID_LIKE=debian' /etc/os-release || { echo "ERROR: Supplied base image is not a debian image"; exit 1; }
 RUN /usr/local/bin/python3 -c "import sys; \
     sys.exit(0) \
@@ -13,25 +18,23 @@ RUN if ! command -v uv >/dev/null 2>&1; then \
     command -v curl >/dev/null 2>&1 || (apt update && apt install -y curl) && \
     curl -LsSf --retry 5 --retry-delay 5 https://astral.sh/uv/0.7.19/install.sh | sh; \
 fi
-ENV PATH="/root/.local/bin:$PATH"
+ENV PATH=${PATH}:${HOME}/.local/bin
 ENV PYTHONUNBUFFERED="True"
-ENV DEBIAN_FRONTEND="noninteractive"
 RUN apt update && \
     apt install -y bash build-essential git curl ca-certificates \
     && apt-get autoremove -y \
     && apt-get clean -y \
     && rm -rf /var/lib/apt/lists/*
-COPY ./base_server_requirements.txt base_server_requirements.txt
+COPY --chown= ./base_server_requirements.txt base_server_requirements.txt
 RUN UV_HTTP_TIMEOUT=${UV_HTTP_TIMEOUT:-300} uv pip install --index-strategy unsafe-best-match --python /usr/local/bin/python3 -r base_server_requirements.txt --no-cache-dir
-COPY ./requirements.txt requirements.txt
+COPY --chown= ./requirements.txt requirements.txt
 RUN UV_HTTP_TIMEOUT=${UV_HTTP_TIMEOUT:-300} uv pip install --index-strategy unsafe-best-match --python /usr/local/bin/python3 -r requirements.txt --no-cache-dir
-ENV APP_HOME="/app"
 WORKDIR $APP_HOME
-COPY ./data /app/data
-COPY ./server /app
-COPY ./config.yaml /app/config.yaml
-COPY ./model /app/model
-COPY ./packages /packages
+COPY --chown= ./data ${APP_HOME}/data
+COPY --chown= ./server ${APP_HOME}
+COPY --chown= ./config.yaml ${APP_HOME}/config.yaml
+COPY --chown= ./model ${APP_HOME}/model
+COPY --chown= ./packages /packages
 ENV INFERENCE_SERVER_PORT="8080"
 ENV SERVER_START_CMD="/usr/local/bin/python3 /app/main.py"
 ENTRYPOINT ["/usr/local/bin/python3", "/app/main.py"]