ldap-ui 0.10.0__py3-none-any.whl → 0.10.2__py3-none-any.whl

ldap_ui/__init__.py

@@ -1 +1 @@
-__version__ = "0.10.0"
+__version__ = "0.10.2"

ldap_ui/app.py

@@ -9,8 +9,6 @@ No sessions, no cookies, nothing else.
 """
 
 import logging
-import sys
-from contextlib import contextmanager
 from http import HTTPStatus
 
 from fastapi import FastAPI, Request, Response
@@ -23,67 +21,16 @@ from ldap import (  # type: ignore
     INVALID_CREDENTIALS,  # type: ignore
     NO_SUCH_OBJECT,  # type: ignore
     OBJECT_CLASS_VIOLATION,  # type: ignore
-    SCOPE_BASE,  # type: ignore
-    UNWILLING_TO_PERFORM,  # type: ignore
+    UNWILLING_TO_PERFORM,  # type: ignore  # type: ignore
     LDAPError,  # type: ignore
 )
 
-from . import __version__, settings
-from .ldap_api import api
-from .ldap_helpers import WITH_OPERATIONAL_ATTRS, ldap_connect
-
-LOG = logging.getLogger("ldap-ui")
-
-LDAP_ERROR_TO_STATUS = {
-    ALREADY_EXISTS: HTTPStatus.CONFLICT,
-    INSUFFICIENT_ACCESS: HTTPStatus.FORBIDDEN,
-    INVALID_CREDENTIALS: HTTPStatus.UNAUTHORIZED,
-    NO_SUCH_OBJECT: HTTPStatus.NOT_FOUND,
-    OBJECT_CLASS_VIOLATION: HTTPStatus.BAD_REQUEST,
-    UNWILLING_TO_PERFORM: HTTPStatus.FORBIDDEN,
-}
-
-
-def format_ldap_error(exc: LDAPError) -> str:
-    cause = exc.args[0] if exc.args else {}
-    desc = cause.get("desc", "LDAP error").strip().capitalize()
-    if "info" in cause:
-        return f"{desc}: {cause['info'].strip().capitalize()}"
-    return f"{desc}"
-
-
-if not settings.BASE_DN or not settings.SCHEMA_DN:
-    try:  # Auto-detection from root DSE
-        connect = contextmanager(ldap_connect)
-        with connect() as connection:
-            _dn, attrs = connection.search_s(  # type: ignore
-                "",
-                SCOPE_BASE,
-                attrlist=WITH_OPERATIONAL_ATTRS,
-            )[0]
-            base_dns = attrs.get("namingContexts", [])
-            if len(base_dns) == 1:
-                settings.BASE_DN = settings.BASE_DN or base_dns[0].decode()
-            else:
-                LOG.warning("No unique base DN: %s", base_dns)
-            schema_dns = attrs.get("subschemaSubentry", [])
-            settings.SCHEMA_DN = settings.SCHEMA_DN or schema_dns[0].decode()
-    except LDAPError as err:
-        LOG.error(format_ldap_error(err), exc_info=err)
-
-if not settings.BASE_DN:
-    LOG.critical("An LDAP base DN is required!")
-    sys.exit(1)
-
-if not settings.SCHEMA_DN:
-    LOG.critical("An LDAP schema DN is required!")
-    sys.exit(1)
-
+from . import __version__, ldap_api, settings
 
 # Main ASGI entry
 
 app = FastAPI(debug=settings.DEBUG, title="LDAP UI", version=__version__)
-app.include_router(api)
+app.include_router(ldap_api.api)
 app.mount("/", StaticFiles(packages=["ldap_ui"], html=True))
 
 app.add_middleware(GZipMiddleware, minimum_size=1000, compresslevel=5)
@@ -102,31 +49,42 @@ async def cache_buster(request: Request, call_next) -> Response:
 
 # API error handling
 
-
-def error_response(
-    exc: LDAPError, status: HTTPStatus, headers: dict[str, str] | None = None
-) -> JSONResponse:
-    return JSONResponse({"detail": [format_ldap_error(exc)]}, status, headers=headers)
+LDAP_ERROR_TO_STATUS = {
+    ALREADY_EXISTS: HTTPStatus.CONFLICT,
+    INSUFFICIENT_ACCESS: HTTPStatus.FORBIDDEN,
+    INVALID_CREDENTIALS: HTTPStatus.UNAUTHORIZED,
+    NO_SUCH_OBJECT: HTTPStatus.NOT_FOUND,
+    OBJECT_CLASS_VIOLATION: HTTPStatus.BAD_REQUEST,
+    UNWILLING_TO_PERFORM: HTTPStatus.FORBIDDEN,
+}
 
 
-@app.exception_handler(INVALID_CREDENTIALS)
-def handle_invalid_credentials(_request: Request, exc: INVALID_CREDENTIALS):
-    return error_response(
-        exc,
-        HTTPStatus.UNAUTHORIZED,
-        headers={"WWW-Authenticate": 'Basic realm="Please log in", charset="UTF-8"'},
-    )
+@app.exception_handler(LDAPError)
+def handle_ldap_error(request: Request, exc: LDAPError) -> Response:
+    "General handler for LDAP errors"
 
+    exc_type = type(exc)
+    if exc_type is UNWILLING_TO_PERFORM:
+        logging.critical("Need BIND_DN or BIND_PATTERN to authenticate")
 
-@app.exception_handler(UNWILLING_TO_PERFORM)
-def handle_unwilling_to_perform(_request: Request, exc: UNWILLING_TO_PERFORM):
-    LOG.warning("Need BIND_DN or BIND_PATTERN to authenticate")
-    return error_response(exc, HTTPStatus.FORBIDDEN)
+    if exc_type is INVALID_CREDENTIALS:
+        return Response(
+            status_code=HTTPStatus.UNAUTHORIZED,
+            headers={
+                "WWW-Authenticate": 'Basic realm="Please log in", charset="UTF-8"'
+            },
+        )
 
+    if exc_type not in LDAP_ERROR_TO_STATUS:
+        # Unknown error --> log it since FastApi won't do it for us
+        logging.exception("Error in %s %s:", request.method, request.url, exc_info=exc)
 
-@app.exception_handler(LDAPError)
-def handle_ldap_error(_request: Request, exc: LDAPError):
-    "General handler for other LDAP errors"
-    return error_response(
-        exc, LDAP_ERROR_TO_STATUS.get(type(exc), HTTPStatus.INTERNAL_SERVER_ERROR)
+    cause = exc.args[0] if exc.args else {}
+    desc = cause.get("desc", "LDAP error").capitalize()
+    msg = f"{desc}" if "info" not in cause else f"{desc}: {cause['info'].capitalize()}"
+    return JSONResponse(
+        {"detail": [msg]},
+        status_code=LDAP_ERROR_TO_STATUS.get(
+            exc_type, HTTPStatus.INTERNAL_SERVER_ERROR
+        ),
     )

ldap_ui/entities.py

@@ -1,6 +1,6 @@
 "Data types for ReST endpoints"
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 
 
 class TreeItem(BaseModel):
@@ -12,32 +12,20 @@ class TreeItem(BaseModel):
     level: int
 
 
-class Meta(BaseModel):
-    "Attribute classification for an entry"
-
-    dn: str
-    required: list[str]
-    aux: list[str]
-    binary: list[str]
-    autoFilled: list[str]
-    isNew: bool = False
-
-
 Attributes = dict[str, list[str]]
 
+AttributeNames = list[str]  # Names of modified attributes
+
 
 class Entry(BaseModel):
     "Directory entry"
 
+    dn: str
     attrs: Attributes
-    meta: Meta
-    changed: list[str] = Field(default_factory=list)
-
-
-class ChangedAttributes(BaseModel):
-    "List of modified attributes"
-
-    changed: list[str]
+    binary: AttributeNames
+    autoFilled: AttributeNames
+    changed: AttributeNames
+    isNew: bool = False
 
 
 class ChangePasswordRequest(BaseModel):