http.py: Fix redirects, bugs, and SDK installation (#362)

This fixes the redirects from the AAS repository 
paths to the Submodel repository paths to work
properly.

Furthermore, the installation of dependencies 
inside the server Docker image was previously 
using the latest release of the SDK. This means,
that we could not ensure that each commit in the
`main` branch of our monorepo would be 
interoperable between SDK and server, as a PR 
would have to be closed in order for the server CI
would not report any errors. In order to fix this,
issue in the development process, the server 
Docker image now installs the SDK from the local
repository, rather than from GitHub.

Lastly, this fixes a wrong status code reported
when specifing a model that is malformed or 
missing information. The specification expects a
400 (Bad Request) response, but the server sent a 
422 (Unprocessable Content). 

Fixes #315

Author: Frosty2500

.github/workflows/ci.yml

@@ -320,7 +320,7 @@ jobs:
       - uses: actions/checkout@v4
       - name: Build the Docker image
         run: |
-          docker build -t basyx-python-server .
+          docker build -t basyx-python-server -f Dockerfile ..
       - name: Run container
         run: |
            docker run -d --name basyx-python-server basyx-python-server

sdk/basyx/aas/adapter/http.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2024 the Eclipse BaSyx Authors
+# Copyright (c) 2025 the Eclipse BaSyx Authors
 #
 # This program and the accompanying materials are made available under the terms of the MIT License, available in
 # the LICENSE file of this project.
@@ -42,13 +42,14 @@
 import io
 import json
 import itertools
+import urllib
 
 from lxml import etree
 import werkzeug.exceptions
 import werkzeug.routing
 import werkzeug.urls
 import werkzeug.utils
-from werkzeug.exceptions import BadRequest, Conflict, NotFound, UnprocessableEntity
+from werkzeug.exceptions import BadRequest, Conflict, NotFound
 from werkzeug.routing import MapAdapter, Rule, Submount
 from werkzeug.wrappers import Request, Response
 from werkzeug.datastructures import FileStorage
@@ -252,7 +253,13 @@ def http_exception_to_response(exception: werkzeug.exceptions.HTTPException, res
 
 
 def is_stripped_request(request: Request) -> bool:
-    return request.args.get("level") == "core"
+    level = request.args.get("level")
+    if level not in {"deep", "core", None}:
+        raise BadRequest(f"Level {level} is not a valid level!")
+    extent = request.args.get("extent")
+    if extent is not None:
+        raise werkzeug.exceptions.NotImplemented(f"The parameter extent is not yet implemented for this server!")
+    return level == "core"
 
 
 T = TypeVar("T")
@@ -300,7 +307,7 @@ def check_type_supportance(cls, type_: type):
     @classmethod
     def assert_type(cls, obj: object, type_: Type[T]) -> T:
         if not isinstance(obj, type_):
-            raise UnprocessableEntity(f"Object {obj!r} is not of type {type_.__name__}!")
+            raise BadRequest(f"Object {obj!r} is not of type {type_.__name__}!")
         return obj
 
     @classmethod
@@ -312,10 +319,10 @@ def json_list(cls, data: Union[str, bytes], expect_type: Type[T], stripped: bool
             parsed = json.loads(data, cls=decoder)
             if not isinstance(parsed, list):
                 if not expect_single:
-                    raise UnprocessableEntity(f"Expected List[{expect_type.__name__}], got {parsed!r}!")
+                    raise BadRequest(f"Expected List[{expect_type.__name__}], got {parsed!r}!")
                 parsed = [parsed]
             elif expect_single:
-                raise UnprocessableEntity(f"Expected a single object of type {expect_type.__name__}, got {parsed!r}!")
+                raise BadRequest(f"Expected a single object of type {expect_type.__name__}, got {parsed!r}!")
             # TODO: the following is ugly, but necessary because references aren't self-identified objects
             #  in the json schema
             # TODO: json deserialization will always create an ModelReference[Submodel], xml deserialization determines
@@ -339,7 +346,7 @@ def json_list(cls, data: Union[str, bytes], expect_type: Type[T], stripped: bool
                 return [constructor(obj, *args) for obj in parsed]
 
         except (KeyError, ValueError, TypeError, json.JSONDecodeError, model.AASConstraintViolation) as e:
-            raise UnprocessableEntity(str(e)) from e
+            raise BadRequest(str(e)) from e
 
         return [cls.assert_type(obj, expect_type) for obj in parsed]
 
@@ -369,9 +376,9 @@ def xml(cls, data: bytes, expect_type: Type[T], stripped: bool) -> T:
             f: BaseException = e
             while f.__cause__ is not None:
                 f = f.__cause__
-            raise UnprocessableEntity(str(f)) from e
+            raise BadRequest(str(f)) from e
         except (etree.XMLSyntaxError, model.AASConstraintViolation) as e:
-            raise UnprocessableEntity(str(e)) from e
+            raise BadRequest(str(e)) from e
         return cls.assert_type(rv, expect_type)
 
     @classmethod
@@ -647,13 +654,13 @@ def _get_submodel_reference(cls, aas: model.AssetAdministrationShell, submodel_i
     @classmethod
     def _get_slice(cls, request: Request, iterator: Iterable[T]) -> Tuple[Iterator[T], int]:
         limit_str = request.args.get('limit', default="10")
-        cursor_str = request.args.get('cursor', default="0")
+        cursor_str = request.args.get('cursor', default="1")
         try:
-            limit, cursor = int(limit_str), int(cursor_str)
+            limit, cursor = int(limit_str), int(cursor_str) - 1  # cursor is 1-indexed
             if limit < 0 or cursor < 0:
                 raise ValueError
         except ValueError:
-            raise BadRequest("Cursor and limit must be positive integers!")
+            raise BadRequest("Limit can not be negative, cursor must be positive!")
         start_index = cursor
         end_index = cursor + limit
         paginated_slice = itertools.islice(iterator, start_index, end_index)
@@ -667,14 +674,31 @@ def _get_shells(self, request: Request) -> Tuple[Iterator[model.AssetAdministrat
             aas = filter(lambda shell: shell.id_short == id_short, aas)
 
         asset_ids = request.args.getlist("assetIds")
-        if asset_ids is not None:
-            # Decode and instantiate SpecificAssetIds
-            # This needs to be a list, otherwise we can only iterate it once.
-            specific_asset_ids: List[model.SpecificAssetId] = list(
-                map(lambda asset_id: HTTPApiDecoder.base64urljson(asset_id, model.SpecificAssetId, False), asset_ids))
-            # Filter AAS based on these SpecificAssetIds
-            aas = filter(lambda shell: all(specific_asset_id in shell.asset_information.specific_asset_id
-                                           for specific_asset_id in specific_asset_ids), aas)
+
+        if asset_ids:
+            specific_asset_ids = []
+            global_asset_ids = []
+
+            for asset_id in asset_ids:
+                asset_id_json = base64url_decode(asset_id)
+                asset_dict = json.loads(asset_id_json)
+                name = asset_dict["name"]
+                value = asset_dict["value"]
+
+                if name == "specificAssetId":
+                    decoded_specific_id = HTTPApiDecoder.json_list(value, model.SpecificAssetId,
+                                                                   False, True)[0]
+                    specific_asset_ids.append(decoded_specific_id)
+                elif name == "globalAssetId":
+                    global_asset_ids.append(value)
+
+            # Filter AAS based on both SpecificAssetIds and globalAssetIds
+            aas = filter(lambda shell: (
+                    (not specific_asset_ids or all(specific_asset_id in shell.asset_information.specific_asset_id
+                                                   for specific_asset_id in specific_asset_ids)) and
+                    (len(global_asset_ids) <= 1 and
+                        (not global_asset_ids or shell.asset_information.global_asset_id in global_asset_ids))
+            ), aas)
 
         paginated_aas, end_index = self._get_slice(request, aas)
         return paginated_aas, end_index
@@ -843,7 +867,7 @@ def delete_aas_submodel_refs_submodel(self, request: Request, url_args: Dict, re
         aas.commit()
         return response_t()
 
-    def aas_submodel_refs_redirect(self, request: Request, url_args: Dict, map_adapter: MapAdapter,
+    def aas_submodel_refs_redirect(self, request: Request, url_args: Dict, map_adapter: MapAdapter, response_t=None,
                                    **_kwargs) -> Response:
         aas = self._get_shell(url_args)
         # the following makes sure the reference exists
@@ -852,7 +876,7 @@ def aas_submodel_refs_redirect(self, request: Request, url_args: Dict, map_adapt
             "submodel_id": url_args["submodel_id"]
         }, force_external=True)
         if "path" in url_args:
-            redirect_url += url_args["path"] + "/"
+            redirect_url += "/" + url_args["path"]
         if request.query_string:
             redirect_url += "?" + request.query_string.decode("ascii")
         return werkzeug.utils.redirect(redirect_url, 307)
@@ -940,6 +964,8 @@ def get_submodel_submodel_elements_id_short_path(self, request: Request, url_arg
     def get_submodel_submodel_elements_id_short_path_metadata(self, request: Request, url_args: Dict,
                                                               response_t: Type[APIResponse], **_kwargs) -> Response:
         submodel_element = self._get_submodel_submodel_elements_id_short_path(url_args)
+        if isinstance(submodel_element, model.Capability) or isinstance(submodel_element, model.Operation):
+            raise BadRequest(f"{submodel_element.id_short} does not allow the content modifier metadata!")
         return response_t(submodel_element, stripped=True)
 
     def get_submodel_submodel_elements_id_short_path_reference(self, request: Request, url_args: Dict,

server/Dockerfile

@@ -13,13 +13,12 @@ ENV PYTHONUNBUFFERED=1
 RUN apk update && \
     apk add --no-cache nginx supervisor gcc musl-dev linux-headers python3-dev git bash && \
     pip install uwsgi && \
-    pip install --no-cache-dir git+https://github.com/eclipse-basyx/basyx-python-sdk@main#subdirectory=sdk && \
     apk del git bash
 
 
-COPY uwsgi.ini /etc/uwsgi/
-COPY supervisord.ini /etc/supervisor/conf.d/supervisord.ini
-COPY stop-supervisor.sh /etc/supervisor/stop-supervisor.sh
+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
 RUN chmod +x /etc/supervisor/stop-supervisor.sh
 
 # Makes it possible to use a different configuration
@@ -34,12 +33,16 @@ ENV LISTEN_PORT=80
 ENV CLIENT_BODY_BUFFER_SIZE=1M
 
 # Copy the entrypoint that will generate Nginx additional configs
-COPY entrypoint.sh /entrypoint.sh
+COPY server/entrypoint.sh /entrypoint.sh
 RUN chmod +x /entrypoint.sh
 
 ENTRYPOINT ["/entrypoint.sh"]
 
-COPY ./app /app
+ENV SETUPTOOLS_SCM_PRETEND_VERSION=1.0.0
+
+COPY ./sdk /sdk
+COPY ./server/app /app
 WORKDIR /app
+RUN pip install ../sdk
 
 CMD ["/usr/bin/supervisord", "-c", "/etc/supervisor/conf.d/supervisord.ini"]

server/README.md

@@ -15,7 +15,7 @@ See [below](#options) on how to configure this.
 ## Building
 The container image can be built via:
 ```
-$ docker buildx build -t basyx-python-sdk-http-server .
+$ docker build -t basyx-python-server -f Dockerfile ..
 ```
 
 ## Running
@@ -46,17 +46,17 @@ The container can be configured via environment variables:
 
 Putting it all together, the container can be started via the following command:
 ```
-$ docker run -p 8080:80 -v ./storage:/storage basyx-python-sdk-http-server
+$ docker run -p 8080:80 -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 .\storage:/storage basyx-python-sdk-http-server
+> docker run -p 8080:80 -v .\storage:/storage basyx-python-server
 ```
 
 Per default, the server will use the `LOCAL_FILE_READ_ONLY` storage type and serve the API under `/api/v3.0` and read files from `/storage`. If you want to change this, you can do so like this:
 ```
-$ docker run -p 8080:80 -v ./storage2:/storage2 -e API_BASE_PATH=/api/v3.1 -e STORAGE_TYPE=LOCAL_FILE_BACKEND -e STORAGE_PATH=/storage2 basyx-python-sdk-http-server
+$ docker run -p 8080:80 -v ./storage2:/storage2 -e API_BASE_PATH=/api/v3.1 -e STORAGE_TYPE=LOCAL_FILE_BACKEND -e STORAGE_PATH=/storage2 basyx-python-server
 ```
 
 ## Building and running the image with docker-compose
@@ -70,7 +70,9 @@ This is the exemplary `docker-compose` file for the server:
 ````yaml
 services:
   app:
-    build: .
+    build:
+      context: ..
+      dockerfile: server/Dockerfile
     ports:
     - "8080:80"
     volumes:

server/compose.yml

@@ -1,6 +1,8 @@
 services:
   app:
-    build: .
+    build:
+      context: ..
+      dockerfile: server/Dockerfile
     ports:
     - "8080:80"
     volumes: