Refactor server package structure

Previously, the `server` was built only with the `repository` API
endpoints in mind. Since we now plan to also support `registry` and
`discovery`, we need to adapt the `./server` project structure.

For this reason, we did the following refactoring:

- This moves the `pyproject.toml` from the `app` directory into the
  server project's top-level directory (`./server/pyproject.toml`).
  This aligns the `server` project directory with the `sdk` and the
  `compliance-tool` project directories. See #466
- This also moves the files for Docker image definition into the
  `./server/docker` subdirectories, where `./server/docker/common` are
  shared files across different Docker images, and
  `./server/docker/repository` and others contain the `Dockerfile`, as
  well as the image specific configuration files. See #468
- This moves the Docker `compose.yaml` into the
  `./server/example_configurations` and its subdirectories. Each example
  configuration should have its own `README.md` specifying what the
  example contains and how to run it. See #468
- Lastly, this moves the repository specific `main.py` to
  `.server/app/services/run_repository.py`

And this adapts (hopefully) all relevant paths in all the different
files accordingly.

Fixes #466
Fixes #468

Author: s-heppner

.github/workflows/ci.yml

@@ -292,7 +292,7 @@ jobs:
 
     defaults:
       run:
-        working-directory: ./server/app
+        working-directory: ./server
     steps:
     - uses: actions/checkout@v4
     - name: Set up Python ${{ env.X_PYTHON_MIN_VERSION }}
@@ -302,11 +302,11 @@ jobs:
     - name: Install Python dependencies
       run: |
         python -m pip install --upgrade pip
-        python -m pip install ../../sdk
+        python -m pip install ../sdk
         python -m pip install .[dev]
     - name: Check typing with MyPy
       run: |
-        python -m mypy .
+        python -m mypy app test
     - name: Check code style with PyCodestyle
       run: |
         python -m pycodestyle --count --max-line-length 120 .
@@ -316,12 +316,12 @@ jobs:
     runs-on: ubuntu-latest
     defaults:
       run:
-        working-directory: ./server
+        working-directory: ./server/docker/repository
     steps:
       - uses: actions/checkout@v4
       - name: Build the Docker image
         run: |
-          docker build -t basyx-python-server -f Dockerfile ..
+          docker build -t basyx-python-server -f Dockerfile ../../..
       - name: Run container
         run: |
            docker run -d --name basyx-python-server basyx-python-server

server/README.md

@@ -19,7 +19,7 @@ The container image can be built via:
 $ docker build -t basyx-python-server -f Dockerfile ..
 ```
 
-Note that when cloning this repository on Windows, Git may convert the line separators to CRLF. This breaks [`entrypoint.sh`](entrypoint.sh) and [`stop-supervisor.sh`](stop-supervisor.sh). Ensure both files use LF line separators (`\n`) before building. 
+Note that when cloning this repository on Windows, Git may convert the line separators to CRLF. This breaks [`entrypoint.sh`](docker/repository/entrypoint.sh) and [`stop-supervisor.sh`](docker/common/stop-supervisor.sh). Ensure both files use LF line separators (`\n`) before building. 
 
 ## Running
 
@@ -60,51 +60,13 @@ This implies the following start-up behaviour:
   - Any AAS/Submodel *already present* is skipped, unless `STORAGE_OVERWRITE = True`, in which case it is replaced.
 - Supplementary files (e.g., `File` SubmodelElements) are never persisted by the LocalFileBackend.
 
-### Running Examples
-
-Putting it all together, the container can be started via the following command:
-```
-$ docker run -p 8080:80 -v ./input:/input -v ./storage:/storage basyx-python-server
-```
-
-Since Windows uses backslashes instead of forward slashes in paths, you'll have to adjust the path to the storage directory there:
-```
-> docker run -p 8080:80 -v .\input:/input -v .\storage:/storage basyx-python-server
-```
-
-By default, the server will use the standard settings described [above](#options). Those settings can be adapted in the following way:
-```
-$ docker run -p 8080:80 -v ./input:/input2 -v ./storage:/storage2 -e API_BASE_PATH=/api/v3.1/ -e INPUT=/input2 -e STORAGE=/storage2 -e STORAGE_PERSISTENCY=True -e STORAGE_OVERWRITE=True basyx-python-server
-```
-
 ## Building and Running the Image with Docker Compose
 
-The container image can also be built and run via:
-```
-$ docker compose up
-```
-
-An exemplary [`compose.yml`](compose.yml) file for the server is given [here](compose.yml):
-```yaml
-name: basyx-python-server
-services:
-  app:
-    build:
-      context: ..
-      dockerfile: server/Dockerfile
-    ports:
-    - "8080:80"
-    volumes:
-      - ./input:/input
-      - ./storage:/storage
-    environment:
-      STORAGE_PERSISTENCY: True
-```
+Example configurations can be found in the `./example_configurations` directory.
 
-Input files are read from `./input` and stored persistently under `./storage` on your host system. The server can be accessed at http://localhost:8080/api/v3.0/ from your host system. 
-To get a different setup, the [`compose.yml`](compose.yml) file can be adapted using the options described [above](#options), similar to the third [running example](#running-examples).
+Currently, we offer: 
 
-Note that the `Dockerfile` has to be specified explicitly via `dockerfile: server/Dockerfile`, as the build context must be set to the parent directory of `/server` to allow access to the local `/sdk`.
+- [repository_standalone](example_configurations/repository_standalone/README.md): Standalone repository server
 
 ## Running without Docker (Debugging Only)
 

server/app/services/__init__.py

@@ -14,7 +14,7 @@
 from basyx.aas.adapter.aasx import DictSupplementaryFileContainer
 from basyx.aas.backend.local_file import LocalFileIdentifiableStore
 from basyx.aas.model.provider import DictIdentifiableStore
-from interfaces.repository import WSGIApp
+from app.interfaces.repository import WSGIApp
 from typing import Tuple, Union
 
 

server/app/main.py server/app/services/run_repository.pyserver/app/main.py renamed to server/app/services/run_repository.py

@@ -15,10 +15,14 @@ RUN apk update && \
     pip install uwsgi && \
     apk del git bash
 
-
-COPY server/uwsgi.ini /etc/uwsgi/
-COPY server/supervisord.ini /etc/supervisor/conf.d/supervisord.ini
-COPY server/stop-supervisor.sh /etc/supervisor/stop-supervisor.sh
+# Copy only the files we need to run the container
+# The argumentation for this is to keep the containers as slim as possible.
+COPY ./sdk /sdk
+COPY ./server/app /server/app
+COPY ./server/pyproject.toml /server/pyproject.toml
+COPY ./server/docker/repository/uwsgi.ini /etc/uwsgi/
+COPY ./server/docker/common/supervisord.ini /etc/supervisor/conf.d/supervisord.ini
+COPY ./server/docker/common/stop-supervisor.sh /etc/supervisor/stop-supervisor.sh
 RUN chmod +x /etc/supervisor/stop-supervisor.sh
 
 # Makes it possible to use a different configuration
@@ -41,17 +45,15 @@ ENV STORAGE_OVERWRITE=False
 VOLUME ["/input", "/storage"]
 
 # Copy the entrypoint that will generate Nginx additional configs
-COPY server/entrypoint.sh /entrypoint.sh
+COPY server/docker/repository/entrypoint.sh /entrypoint.sh
 RUN chmod +x /entrypoint.sh
 
 ENTRYPOINT ["/entrypoint.sh"]
 
 ENV SETUPTOOLS_SCM_PRETEND_VERSION=1.0.0
 
-COPY ./sdk /sdk
-COPY ./server/app /app
-WORKDIR /app
-RUN pip install ../sdk
-RUN pip install .
+WORKDIR /server/app
+RUN pip install ../../sdk
+RUN pip install ..
 
 CMD ["/usr/bin/supervisord", "-c", "/etc/supervisor/conf.d/supervisord.ini"]

server/stop-supervisor.sh server/docker/common/stop-supervisor.shserver/stop-supervisor.sh renamed to server/docker/common/stop-supervisor.sh

@@ -1,5 +1,5 @@
 [uwsgi]
-wsgi-file = /app/main.py
+wsgi-file = /server/app/services/run_repository.py
 socket = /tmp/uwsgi.sock
 chown-socket = nginx:nginx
 chmod-socket = 664

server/supervisord.ini server/docker/common/supervisord.iniserver/supervisord.ini renamed to server/docker/common/supervisord.ini

@@ -0,0 +1,15 @@
+# Repository Standalone
+
+This example Docker compose configuration starts a repository server. 
+
+The container image can also be built and run via:
+```
+$ docker compose up
+```
+
+Input files are read from `./input` and stored persistently under `./storage` on your host system. 
+The server can be accessed at http://localhost:8080/api/v3.0/ from your host system. 
+To get a different setup, the `compose.yaml` file can be adapted using the options described in the main server [README.md](../../README.md#options), similar to the third [running example](#running-examples).
+
+Note that the `Dockerfile` has to be specified explicitly via `dockerfile: server/Dockerfile`, as the build context must be set to the parent directory of `/server` to allow access to the local `/sdk`.
+