pyxecm 2.0.2__py3-none-any.whl → 2.0.3__py3-none-any.whl

pyxecm/__init__.py

@@ -1,4 +1,4 @@
-"""pyxecm - A python library to interact with Opentext Extended ECM REST API."""
+"""pyxecm - A python library to interact with Opentext REST APIs."""
 
 from .avts import AVTS
 from .coreshare import CoreShare
@@ -8,7 +8,8 @@ from .otca import OTCA
 from .otcs import OTCS
 from .otds import OTDS
 from .otiv import OTIV
+from .otkd import OTKD
 from .otmm import OTMM
 from .otpd import OTPD
 
-__all__ = ["AVTS", "OTAC", "OTAWP", "OTCA", "OTCS", "OTDS", "OTIV", "OTMM", "OTPD", "CoreShare"]
+__all__ = ["AVTS", "OTAC", "OTAWP", "OTCA", "OTCS", "OTDS", "OTIV", "OTKD", "OTMM", "OTPD", "CoreShare"]

pyxecm/avts.py

@@ -396,8 +396,10 @@ class AVTS:
 
         if response is not None:
             self._accesstoken = response.get("access_token", None)
+        else:
+            self._accesstoken = None
 
-        return response
+        return self._accesstoken
 
     # end method definition
 

pyxecm/customizer/api/app.py

@@ -105,7 +105,8 @@ async def lifespan(
 app = FastAPI(
     docs_url="/api",
     title="Customizer API",
-    openapi_url="/api/openapi.json",
+    openapi_url=api_settings.openapi_url,
+    root_path=api_settings.root_path,
     lifespan=lifespan,
     version=version("pyxecm"),
     openapi_tags=[
@@ -135,7 +136,6 @@ if api_settings.ws_terminal:
 if api_settings.csai:
     app.include_router(router=v1_csai_router)
 
-
 logger = logging.getLogger("CustomizerAPI")
 app.add_middleware(
     CORSMiddleware,

pyxecm/customizer/api/auth/functions.py

@@ -5,14 +5,20 @@ from typing import Annotated
 
 import requests
 from fastapi import APIRouter, Depends, HTTPException, status
-from fastapi.security import OAuth2PasswordBearer
+from fastapi.security import APIKeyHeader, OAuth2PasswordBearer
 
 from pyxecm.customizer.api.auth.models import User
 from pyxecm.customizer.api.settings import api_settings
 
 router = APIRouter()
 
-oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+oauth2_scheme = OAuth2PasswordBearer(
+    tokenUrl="token",
+    auto_error=False,
+    description="Authenticate with OTDS, user needs to be member of 'otadmins@otds.admin' group",
+    scheme_name="OTDS Authentication",
+)
+apikey_header = APIKeyHeader(name="x-api-key", auto_error=False, scheme_name="APIKey")
 
 
 def get_groups(response: dict, token: str) -> list:
@@ -42,43 +48,44 @@ def get_groups(response: dict, token: str) -> list:
     return []
 
 
-async def get_current_user(token: Annotated[str, Depends(oauth2_scheme)]) -> User:
+async def get_current_user(
+    token: Annotated[str, Depends(oauth2_scheme)], api_key: Annotated[str, Depends(apikey_header)]
+) -> User:
     """Get the current user from OTDS and verify it."""
 
-    if api_settings.api_token is not None and token == api_settings.api_token:
+    if api_settings.api_key is not None and api_key == api_settings.api_key:
         return User(
             id="api",
-            full_name="API Token",
+            full_name="API Key",
             groups=["otadmins@otds.admin"],
             is_admin=True,
             is_sysadmin=True,
         )
 
-    url = api_settings.otds_url + "/otdsws/rest/currentuser"
-    headers = {
-        "Accept": "application/json",
-        "otdsticket": token,
-    }
-    response = requests.request("GET", url, headers=headers, timeout=2)
-
-    if response.ok:
-        response = json.loads(response.text)
-
-        user = User(
-            id=response["user"]["id"],
-            full_name=response["user"]["name"],
-            groups=get_groups(response, token),
-            is_admin=response["isAdmin"],
-            is_sysadmin=response["isSysAdmin"],
-        )
-
-        return user
-    else:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Invalid authentication credentials",
-            headers={"WWW-Authenticate": "Bearer"},
-        )
+    if token and token.startswith("*OTDSSSO*"):
+        url = api_settings.otds_url + "/otdsws/rest/currentuser"
+        headers = {
+            "Accept": "application/json",
+            "otdsticket": token,
+        }
+        response = requests.request("GET", url, headers=headers, timeout=2)
+
+        if response.ok:
+            response = json.loads(response.text)
+
+            return User(
+                id=response["user"]["id"],
+                full_name=response["user"]["name"],
+                groups=get_groups(response, token),
+                is_admin=response["isAdmin"],
+                is_sysadmin=response["isSysAdmin"],
+            )
+
+    raise HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Invalid authentication credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
 
 
 async def get_authorized_user(current_user: Annotated[User, Depends(get_current_user)]) -> User:

pyxecm/customizer/api/common/functions.py

@@ -1,10 +1,13 @@
 """Define common functions."""
 
 import logging
+import os
 
 from pyxecm.customizer.api.common.payload_list import PayloadList
 from pyxecm.customizer.api.settings import CustomizerAPISettings, api_settings
 from pyxecm.customizer.k8s import K8s
+from pyxecm.customizer.settings import Settings
+from pyxecm.otcs import OTCS
 
 logger = logging.getLogger("pyxecm.customizer.api")
 
@@ -25,6 +28,36 @@ def get_k8s_object() -> K8s:
     return K8s(logger=logger, namespace=api_settings.namespace)
 
 
+def get_otcs_object() -> OTCS:
+    """Get an instance of a K8s object.
+
+    Returns:
+        K8s: Return a K8s object
+
+    """
+    settings = Settings()
+
+    cs = OTCS(
+        protocol=settings.otcs.url_backend.scheme,
+        hostname=settings.otcs.url_backend.host,
+        port=settings.otcs.url_backend.port,
+        public_url=str(settings.otcs.url),
+        username=settings.otcs.username,
+        password=settings.otcs.password.get_secret_value(),
+        user_partition=settings.otcs.partition,
+        resource_name=settings.otcs.resource_name,
+        base_path=settings.otcs.base_path,
+        support_path=settings.otcs.support_path,
+        download_dir=settings.otcs.download_dir,
+        feme_uri=settings.otcs.feme_uri,
+        logger=logger,
+    )
+
+    cs.authenticate()
+
+    return cs
+
+
 def get_settings() -> CustomizerAPISettings:
     """Get the API Settings object.
 
@@ -45,3 +78,24 @@ def get_otcs_logs_lock() -> dict:
     """
 
     return LOGS_LOCK
+
+
+def list_files_in_directory(directory: str) -> dict:
+    """Recursively list files in a directory and return a nested JSON structure with URLs."""
+    result = {}
+    for root, dirs, files in os.walk(directory):
+        # Sort directories and files alphabetically
+        dirs.sort()
+        files.sort()
+
+        current_level = result
+        path_parts = root.split(os.sep)
+        relative_path = os.path.relpath(root, directory)
+        for part in path_parts[len(directory.split(os.sep)) :]:
+            if part not in current_level:
+                current_level[part] = {}
+            current_level = current_level[part]
+        for file in files:
+            file_path = os.path.join(relative_path, file)
+            current_level[file] = file_path
+    return result

pyxecm/customizer/api/common/router.py

@@ -1,17 +1,19 @@
 """API Implemenation for the Customizer to start and control the payload processing."""
 
 import logging
+import mimetypes
 import os
 import signal
+import tempfile
 from http import HTTPStatus
 from typing import Annotated
 
-from fastapi import APIRouter, Depends, HTTPException
-from fastapi.responses import JSONResponse, RedirectResponse
+from fastapi import APIRouter, Depends, HTTPException, Query, Response
+from fastapi.responses import FileResponse, JSONResponse, RedirectResponse
 
 from pyxecm.customizer.api.auth.functions import get_authorized_user
 from pyxecm.customizer.api.auth.models import User
-from pyxecm.customizer.api.common.functions import PAYLOAD_LIST
+from pyxecm.customizer.api.common.functions import PAYLOAD_LIST, list_files_in_directory
 from pyxecm.customizer.api.common.models import CustomizerStatus
 
 router = APIRouter(tags=["default"])
@@ -70,3 +72,48 @@ def shutdown(user: Annotated[User, Depends(get_authorized_user)]) -> JSONRespons
     os.kill(os.getpid(), signal.SIGTERM)
 
     return JSONResponse({"status": "shutdown"}, status_code=HTTPStatus.ACCEPTED)
+
+
+@router.get(path="/browser_automations/assets")
+def list_browser_automation_files(
+    user: Annotated[User, Depends(get_authorized_user)],  # noqa: ARG001
+) -> JSONResponse:
+    """List all browser automation files."""
+
+    result = list_files_in_directory(
+        os.path.join(
+            tempfile.gettempdir(),
+            "browser_automations",
+        )
+    )
+
+    return JSONResponse(result)
+
+
+@router.get(path="/browser_automations/download")
+def get_browser_automation_file(
+    user: Annotated[User, Depends(get_authorized_user)],  # noqa: ARG001
+    file: Annotated[str, Query(description="File name")],
+) -> FileResponse:
+    """Download the logfile for a specific payload."""
+
+    filename = os.path.join(tempfile.gettempdir(), "browser_automations", file)
+
+    if not os.path.isfile(filename):
+        raise HTTPException(
+            status_code=HTTPStatus.NOT_FOUND,
+            detail="File -> '{}' not found".format(filename),
+        )
+
+    media_type, _ = mimetypes.guess_type(filename)
+
+    with open(filename, "rb") as f:
+        content = f.read()
+
+    return Response(
+        content,
+        media_type=media_type,
+        headers={
+            "Content-Disposition": f'attachment; filename="{os.path.basename(filename)}"',
+        },
+    )

pyxecm/customizer/api/settings.py

@@ -16,13 +16,15 @@ from pydantic_settings import (
 class CustomizerAPISettings(BaseSettings):
     """Settings for the Customizer API."""
 
-    api_token: str | None = Field(
+    api_key: str | None = Field(
         default=None,
-        description="Optional token that can be specified that has access to the Customizer API, bypassing the OTDS authentication.",
+        description="Optional API KEY that can be specified that has access to the Customizer API, bypassing the OTDS authentication.",
     )
     bind_address: str = Field(default="0.0.0.0", description="Interface to bind the Customizer API.")  # noqa: S104
     bind_port: int = Field(default=8000, description="Port to bind the Customizer API to")
     workers: int = Field(default=1, description="Number of workers to use for the API BackgroundTasks")
+    root_path: str = Field(default="/", description="Root path for the Customizer API")
+    openapi_url: str = Field(default="/api/openapi.json", description="OpenAPI URL")
 
     import_payload: bool = Field(default=False)
     payload: str = Field(
@@ -58,7 +60,7 @@ class CustomizerAPISettings(BaseSettings):
         description="Namespace to use for otxecm resource lookups",
     )
     maintenance_mode: bool = Field(
-        default=True,
+        default=False,
         description="Automatically enable and disable the maintenance mode during payload deployments.",
     )
 

pyxecm/customizer/api/terminal/router.py

@@ -2,6 +2,7 @@
 
 import asyncio
 import contextlib
+import json
 import os
 import pty
 import signal
@@ -15,13 +16,16 @@ router = APIRouter(tags=["terminal"])
 
 
 @router.websocket("/ws/terminal")
-async def ws_terminal(websocket: WebSocket, pod: str = Query(...), command: str = Query(...)) -> None:
+async def ws_terminal(
+    websocket: WebSocket, pod: str = Query(...), command: str = Query(...), container: str = Query(None)
+) -> None:
     """Websocket to connect to a shell session in a pod.
 
     Args:
         websocket (WebSocket): WebSocket to connect to the shell session.
         pod (str): pod name to connect to.
         command (str): command to be executed.
+        container (str, optional): container name to connect to.
 
     """
     await websocket.accept()
@@ -30,7 +34,7 @@ async def ws_terminal(websocket: WebSocket, pod: str = Query(...), command: str
         # Wait for the first message to be the token
         token = await websocket.receive_text()
 
-        user = await get_current_user(token)
+        user = await get_current_user(token=token, api_key=token)
         authrorized = await get_authorized_user(user)
 
         if not authrorized:
@@ -45,11 +49,17 @@ async def ws_terminal(websocket: WebSocket, pod: str = Query(...), command: str
     except WebSocketDisconnect:
         return
 
-    process = ["bash"] if pod == "customizer" else ["kubectl", "exec", "-it", pod, "--", command]
+    container = ["-c", container] if container else []
+
+    process = [command] if pod == "customizer" else ["kubectl", "exec", "-it", pod, *container, "--", command]
 
     pid, fd = pty.fork()
+    import fcntl
+    import struct
+    import termios
+
     if pid == 0:
-        subprocess.run(process, check=False)  # noqa: ASYNC221
+        process = subprocess.run(process, check=False)  # noqa: ASYNC221
 
     async def read_from_pty() -> None:
         loop = asyncio.get_event_loop()
@@ -64,24 +74,39 @@ async def ws_terminal(websocket: WebSocket, pod: str = Query(...), command: str
         try:
             while True:
                 data = await websocket.receive_text()
-                os.write(fd, data.encode())
+                if data.startswith("{") and data.endswith("}"):
+                    message = json.loads(data)
+                    if message.get("type") == "resize":
+                        rows = message.get("rows")
+                        cols = message.get("cols")
+
+                        packed_size = struct.pack("HHHH", rows, cols, 0, 0)
+                        fcntl.ioctl(fd, termios.TIOCSWINSZ, packed_size)
+
+                else:
+                    os.write(fd, data.encode())
         except Exception:  # noqa: S110
             pass
 
-    # Launch read/write tasks
-    read_task = asyncio.create_task(read_from_pty())
-    write_task = asyncio.create_task(write_to_pty())
+    try:
+        # Launch read/write tasks
+        read_task = asyncio.create_task(read_from_pty())
+        write_task = asyncio.create_task(write_to_pty())
+
+        done, pending = await asyncio.wait([read_task, write_task], return_when=asyncio.FIRST_COMPLETED)
 
-    done, pending = await asyncio.wait([read_task, write_task], return_when=asyncio.FIRST_COMPLETED)
+        # Cancel other task
+        for task in pending:
+            task.cancel()
+    finally:
+        with contextlib.suppress(Exception):
+            await websocket.close(code=status.WS_1008_POLICY_VIOLATION)
 
-    # Cancel other task
-    for task in pending:
-        task.cancel()
+        with contextlib.suppress(Exception):
+            process.terminate()
 
-    try:  # noqa: SIM105
-        os.kill(pid, signal.SIGKILL)
-    except ProcessLookupError:
-        pass  # Already exited
+        with contextlib.suppress(Exception):
+            os.kill(pid, signal.SIGKILL)
 
-    with contextlib.suppress(Exception):
-        os.close(fd)
+        with contextlib.suppress(Exception):
+            os.close(fd)

pyxecm/customizer/api/v1_csai/models.py

@@ -0,0 +1,18 @@
+"""Define Models for Payload."""
+
+from pydantic import BaseModel
+
+
+class CSAIEmbedMetadata(BaseModel):
+    """Defines Data Model for embeding metadata for documents and workspaces."""
+
+    node_id: int = None
+    crawl: bool = False
+    wait_for_completion: bool = False
+    message_override: dict = None
+    timeout: float = 30.0
+    document_metadata: bool = False
+    images: bool = False
+    image_prompt: str = ""
+    workspace_metadata: bool = True
+    remove_existing: bool = False

pyxecm/customizer/api/v1_csai/router.py

@@ -9,15 +9,40 @@ from fastapi.responses import JSONResponse
 
 from pyxecm.customizer.api.auth.functions import get_authorized_user
 from pyxecm.customizer.api.auth.models import User
-from pyxecm.customizer.api.common.functions import get_k8s_object, get_settings
+from pyxecm.customizer.api.common.functions import get_k8s_object, get_otcs_object, get_settings
 from pyxecm.customizer.api.settings import CustomizerAPISettings
+from pyxecm.customizer.api.v1_csai.models import CSAIEmbedMetadata
 from pyxecm.customizer.k8s import K8s
+from pyxecm.otcs import OTCS
 
 router = APIRouter(prefix="/api/v1/csai", tags=["csai"])
 
 logger = logging.getLogger("pyxecm.customizer.api.v1_csai")
 
 
+@router.post("/metadata")
+def embed_metadata(
+    user: Annotated[User, Depends(get_authorized_user)],  # noqa: ARG001
+    otcs_object: Annotated[OTCS, Depends(get_otcs_object)],
+    body: Annotated[CSAIEmbedMetadata, Body()],
+) -> JSONResponse:
+    """Embed the Metadata of the given objects.
+
+    Args:
+        user (Annotated[User, Depends): User required for authentication
+        otcs_object (Annotated[OTCS, Depends(get_otcs_object)]): OTCS object to interact with OTCS
+        body (Annotated[CSAIEmbedMetadata, Body): Request body
+
+    Returns:
+        JSONResponse: JSONResponse with success=true/false
+
+    """
+
+    success = otcs_object.aviator_embed_metadata(**body.model_dump())
+
+    return JSONResponse({"success": success})
+
+
 @router.get("")
 def get_csai_config_data(
     user: Annotated[User, Depends(get_authorized_user)],

pyxecm/customizer/api/v1_payload/functions.py

@@ -129,16 +129,22 @@ def import_payload(
         payload_dir = payload
 
     if payload_dir is None:
-        import_payload_file(payload, enabled, dependencies)
+        try:
+            import_payload_file(payload, enabled, dependencies)
+        except PayloadImportError as exc:
+            logger.error(exc)
+            logger.debug(exc, exc_info=True)
         return
+
     elif not os.path.isdir(payload_dir):
         return
 
     for filename in sorted(os.listdir(payload_dir)):
         try:
             import_payload_file(os.path.join(payload_dir, filename), enabled, dependencies)
-        except PayloadImportError:
-            logger.error("Payload import failed")
+        except PayloadImportError as exc:
+            logger.error(exc)
+            logger.debug(exc, exc_info=True)
 
 
 def prepare_dependencies(dependencies: list) -> list | None: