iris-pex-embedded-python 3.7.2b2__py3-none-any.whl → 4.0.0__py3-none-any.whl

iop/runtime/director.py

@@ -0,0 +1,415 @@
+"""Local IRIS director functions and deprecated _Director facade."""
+
+import asyncio
+import datetime
+import functools
+import signal
+import warnings
+from dataclasses import dataclass
+from functools import wraps
+
+from ..messages.dispatch import dispatch_deserializer, dispatch_serializer
+from ..messages.serialization import MessageClassImportError
+from ..migration import utils as _migration_utils
+from ..runtime import iris as _iris
+
+
+@dataclass
+class SigintHandler:
+    sigint: bool = False
+    sigint_log: bool = False
+    log_only: bool = False
+
+    def signal_handler(self, signal, frame):
+        if self.sigint or self.log_only:
+            self.sigint_log = True
+        self.sigint = True
+
+
+def create_business_service(target):
+    """The create_business_service() method initiates the specified business service.
+
+    Parameters:
+    connection: an IRISConnection object that specifies the connection to an IRIS instance for Java.
+    target: a string that specifies the name of the business service in the production definition.
+
+    Returns:
+        an object that contains an instance of IRISBusinessService
+    """
+    iris_object = (
+        _iris.get_iris().cls("IOP.Director").dispatchCreateBusinessService(target)
+    )
+    return iris_object
+
+
+def create_python_business_service(target):
+    """The create_business_service() method initiates the specified business service.
+
+    Parameters:
+    connection: an IRISConnection object that specifies the connection to an IRIS instance for Java.
+    target: a string that specifies the name of the business service in the production definition.
+
+    Returns:
+        an object that contains an instance of IRISBusinessService
+    """
+    iris_object = (
+        _iris.get_iris().cls("IOP.Director").dispatchCreateBusinessService(target)
+    )
+    return iris_object.GetClass()
+
+
+### List of function to manage the production
+### start production
+def start_production_with_log(production_name=None):
+    if production_name is None or production_name == "":
+        production_name = get_default_production()
+    # create two async task
+    loop = asyncio.get_event_loop()
+    # add signal handler
+    handler = SigintHandler()
+    loop.add_signal_handler(
+        signal.SIGINT,
+        functools.partial(handler.signal_handler, signal.SIGINT, loop),
+    )
+    loop.run_until_complete(
+        asyncio.gather(
+            _start_production_async(production_name, handler),
+            _log_production_async(handler),
+        )
+    )
+    loop.close()
+
+
+async def _start_production_async(production_name: str, handler: SigintHandler):
+    start_production(production_name)
+    while True:
+        if handler.sigint:
+            stop_production()
+            break
+        await asyncio.sleep(1)
+
+
+def start_production(production_name=None):
+    if production_name is None or production_name == "":
+        production_name = get_default_production()
+    status = _iris.get_iris().cls("Ens.Director").StartProduction(production_name)
+    _migration_utils.raise_on_error(status)
+
+
+### stop production
+def stop_production():
+    _iris.get_iris().cls("Ens.Director").StopProduction()
+
+
+### restart production
+def restart_production():
+    _iris.get_iris().cls("Ens.Director").RestartProduction()
+
+
+### shutdown production
+def shutdown_production():
+    _iris.get_iris().cls("Ens.Director").StopProduction(10, 1)
+
+
+### update production
+def update_production():
+    _iris.get_iris().cls("Ens.Director").UpdateProduction()
+
+
+### start production component
+def start_component(component_name):
+    status = (
+        _iris.get_iris()
+        .cls("Ens.Director")
+        .EnableConfigItem(
+            component_name,
+            1,
+            1,
+        )
+    )
+    _migration_utils.raise_on_error(status)
+
+
+### stop production component
+def stop_component(component_name):
+    status = (
+        _iris.get_iris()
+        .cls("Ens.Director")
+        .EnableConfigItem(
+            component_name,
+            0,
+            1,
+        )
+    )
+    _migration_utils.raise_on_error(status)
+
+
+### restart production component
+def restart_component(component_name):
+    stop_component(component_name)
+    start_component(component_name)
+
+
+### list production
+def list_productions():
+    return _iris.get_iris().cls("IOP.Director").dispatchListProductions()
+
+
+### status production
+def status_production():
+    dikt = _iris.get_iris().cls("IOP.Director").StatusProduction()
+    if dikt["Production"] is None or dikt["Production"] == "":
+        dikt["Production"] = get_default_production()
+    return dikt
+
+
+### set default production
+def set_default_production(production_name=""):
+    # set ^Ens.Configuration("SuperUser","LastProduction")
+    glb = _iris.get_iris().gref("^Ens.Configuration")
+    glb["csp", "LastProduction"] = production_name
+
+
+### get default production
+def get_default_production():
+    glb = _iris.get_iris().gref("^Ens.Configuration")
+    default_production_name = glb["csp", "LastProduction"]
+    if default_production_name is None or default_production_name == "":
+        default_production_name = "Not defined"
+    return default_production_name
+
+
+def format_log(row: list) -> str:
+    # 0,  1,          2,   3,         4,         5,           6,            7,     8,    9,          10,        11
+    # ID, ConfigName, Job, MessageId, SessionId, SourceClass, SourceMethod, Stack, Text, TimeLogged, TraceCat, Type
+    # yield all except stack aand tracecat
+    # in first position, the timelogged
+    # cast the result to string
+    # convert Type to its string value
+    # Assert,Error,Warning,Info,Trace,Alert
+    typ = row[11]
+    if typ == 1:
+        typ = "Assert"
+    elif typ == 2:
+        typ = "Error"
+    elif typ == 3:
+        typ = "Warning"
+    elif typ == 4:
+        typ = "Info"
+    elif typ == 5:
+        typ = "Trace"
+    elif typ == 6:
+        typ = "Alert"
+    return (
+        str(row[9])
+        + " "
+        + typ
+        + " "
+        + str(row[1])
+        + " "
+        + str(row[2])
+        + " "
+        + str(row[3])
+        + " "
+        + str(row[4])
+        + " "
+        + str(row[5])
+        + " "
+        + str(row[6])
+        + " "
+        + str(row[8])
+    )
+
+
+def read_top_log(top) -> list:
+    sql = """
+    SELECT top ?
+    ID, ConfigName, Job, MessageId, SessionId, SourceClass, SourceMethod, Stack, Text, TimeLogged, TraceCat, Type
+    FROM Ens_Util.Log
+    order by id desc
+    """
+    result = []
+    stmt = _iris.get_iris().sql.prepare(sql)
+    rs = stmt.execute(top)
+    for row in rs:
+        result.append(format_log(row))
+    return result
+
+
+def read_log() -> list:
+    sql = """
+    SELECT 
+    ID, ConfigName, Job, MessageId, SessionId, SourceClass, SourceMethod, Stack, Text, TimeLogged, TraceCat, Type
+    FROM Ens_Util.Log
+    where TimeLogged >= ?
+    order by id desc
+    """
+    result = []
+    stmt = _iris.get_iris().sql.prepare(sql)
+    time = datetime.datetime.now() - datetime.timedelta(seconds=1)
+    # convert to utc time
+    time = time.astimezone(datetime.timezone.utc)
+    rs = stmt.execute(time.isoformat(sep=" "))
+    for row in rs:
+        result.append(format_log(row))
+    return result
+
+
+async def _log_production_async(handler):
+    """Log production
+    if ctrl+c is pressed, the log is stopped
+    """
+    while True:
+        for row in reversed(read_log()):
+            print(row)
+        if handler.sigint_log:
+            break
+        await asyncio.sleep(1)
+
+
+def log_production_top(top=10):
+    """
+    Log the top N logs of the production
+    Parameters:
+    top: the number of log to display
+    """
+    for row in reversed(read_top_log(top)):
+        print(row)
+
+
+def log_production():
+    """Log production
+    if ctrl+c is pressed, the log is stopped
+    """
+    loop = asyncio.get_event_loop()
+    handler = SigintHandler(log_only=True)
+    loop.add_signal_handler(
+        signal.SIGINT,
+        functools.partial(handler.signal_handler, signal.SIGINT, loop),
+    )
+
+    for row in reversed(read_top_log(10)):
+        print(row)
+
+    loop.run_until_complete(_log_production_async(handler))
+    loop.close()
+
+
+def test_component(target, message=None, classname=None, body=None):
+    """
+    Test a component
+    Parameters:
+    target: the name of the component
+    classname: the name of the class to test
+    body: the body of the message
+    """
+    iris = _iris.get_iris()
+    if not message:
+        message = iris.cls("Ens.Request")._New()
+    if classname:
+        # if classname start with 'iris.' then create an iris object
+        if classname.startswith("iris."):
+            # strip the iris. prefix
+            classname = classname[5:]
+            if body:
+                message = iris.cls(classname)._New(body)
+            else:
+                message = iris.cls(classname)._New()
+        # else create a python object
+        else:
+            message = iris.cls("IOP.Message")._New()
+            message.classname = classname
+            if body:
+                message.json = body
+            else:
+                message.json = _migration_utils.string_to_stream("{}")
+    # serialize the message
+    serial_message = dispatch_serializer(message)
+    response = iris.cls("IOP.Utils").dispatchTestComponent(target, serial_message)
+    try:
+        deserialized_response = dispatch_deserializer(response)
+    except MessageClassImportError:
+        if response._IsA("IOP.Message"):
+            body = (
+                _migration_utils.stream_to_string(response.json)
+                if response.type == "Stream"
+                else response.json
+            )
+            deserialized_response = {
+                "classname": response.classname,
+                "body": body,
+                "truncated": False,
+            }
+        else:
+            raise
+    return deserialized_response
+
+
+def _deprecated_static(name: str):
+    target = globals()[name]
+    if asyncio.iscoroutinefunction(target):
+
+        @wraps(target)
+        async def async_wrapper(*args, **kwargs):
+            warnings.warn(
+                f"iop.runtime.director._Director.{name}() and iop.Director.{name}() are deprecated; "
+                f"use iop.runtime.director.{name}() instead. This facade will be removed in v5.0.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            return await globals()[name](*args, **kwargs)
+
+        return staticmethod(async_wrapper)
+
+    @wraps(target)
+    def wrapper(*args, **kwargs):
+        warnings.warn(
+            f"iop.runtime.director._Director.{name}() and iop.Director.{name}() are deprecated; "
+            f"use iop.runtime.director.{name}() instead. This facade will be removed in v5.0.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return globals()[name](*args, **kwargs)
+
+    return staticmethod(wrapper)
+
+
+class _Director:
+    """Compatibility facade for the local IRIS director API."""
+
+    _bs = {}
+
+    def get_business_service(self, target, force_session_id=False):
+        """Get and cache a Python business service by production item name."""
+        if target not in self._bs or self._bs[target] is None:
+            self._bs[target] = create_python_business_service(target)
+        if force_session_id:
+            self._bs[target].iris_handle._SessionId = ""
+            self._bs[target].iris_handle.ForceSessionId()
+        return self._bs[target]
+
+    create_business_service = _deprecated_static("create_business_service")
+    create_python_business_service = _deprecated_static(
+        "create_python_business_service"
+    )
+    start_production_with_log = _deprecated_static("start_production_with_log")
+    _start_production_async = _deprecated_static("_start_production_async")
+    start_production = _deprecated_static("start_production")
+    stop_production = _deprecated_static("stop_production")
+    restart_production = _deprecated_static("restart_production")
+    shutdown_production = _deprecated_static("shutdown_production")
+    update_production = _deprecated_static("update_production")
+    start_component = _deprecated_static("start_component")
+    stop_component = _deprecated_static("stop_component")
+    restart_component = _deprecated_static("restart_component")
+    list_productions = _deprecated_static("list_productions")
+    status_production = _deprecated_static("status_production")
+    set_default_production = _deprecated_static("set_default_production")
+    get_default_production = _deprecated_static("get_default_production")
+    format_log = _deprecated_static("format_log")
+    read_top_log = _deprecated_static("read_top_log")
+    read_log = _deprecated_static("read_log")
+    _log_production_async = _deprecated_static("_log_production_async")
+    log_production_top = _deprecated_static("log_production_top")
+    log_production = _deprecated_static("log_production")
+    test_component = _deprecated_static("test_component")

iop/runtime/environment.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import importlib
+import os
+import sys
+from collections.abc import Iterator
+from contextlib import contextmanager
+
+
+@contextmanager
+def temporary_env(name: str, value: str | None) -> Iterator[None]:
+    """Temporarily set an environment variable, restoring the previous value."""
+    missing = object()
+    previous = os.environ.get(name, missing)
+    if value is not None:
+        os.environ[name] = value
+    try:
+        yield
+    finally:
+        if previous is missing:
+            os.environ.pop(name, None)
+        else:
+            os.environ[name] = str(previous)
+
+
+def normalize_path(path: str) -> str:
+    return os.path.abspath(os.path.normpath(path))
+
+
+def prepend_sys_path(path: str) -> str:
+    """Move *path* to the front of sys.path and invalidate import caches."""
+    normalized = normalize_path(path)
+    while normalized in sys.path:
+        sys.path.remove(normalized)
+    sys.path.insert(0, normalized)
+    importlib.invalidate_caches()
+    return normalized
+
+
+def remove_sys_path(path: str | None) -> None:
+    if not path:
+        return
+    normalized = normalize_path(path)
+    while normalized in sys.path:
+        sys.path.remove(normalized)
+    importlib.invalidate_caches()
+
+
+@contextmanager
+def temporary_sys_path(path: str | None) -> Iterator[str | None]:
+    """Temporarily prepend *path* to sys.path, then remove it."""
+    if not path:
+        yield None
+        return
+    normalized = prepend_sys_path(path)
+    try:
+        yield normalized
+    finally:
+        remove_sys_path(normalized)

iop/{_iris.py → runtime/iris.py}

@@ -1,8 +1,8 @@
 import os
-from typing import Any, Optional
+from typing import Any
 
 
-def get_iris(namespace: Optional[str] = None) -> Any:
+def get_iris(namespace: str | None = None) -> Any:
     if namespace:
         os.environ["IRISNAMESPACE"] = namespace
     import iris

iop/runtime/local.py

@@ -0,0 +1,145 @@
+"""Local director: thin instance-method wrapper around local IRIS director calls.
+
+This gives the CLI a uniform interface so it can swap between
+_LocalDirector and _RemoteDirector without any branching.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+
+from ..migration import utils as _migration_utils
+from . import director as _director
+from .protocol import DirectorProtocol as _DirectorProtocol  # noqa: F401 --- IGNORE ---
+
+
+class _LocalDirector(_DirectorProtocol):
+    """Local director: thin instance-method wrapper around local IRIS calls."""
+
+    # ------------------------------------------------------------------
+    # Production lifecycle
+    # ------------------------------------------------------------------
+
+    def get_default_production(self) -> str:
+        return _director.get_default_production()
+
+    def set_default_production(self, production_name: str = "") -> None:
+        _director.set_default_production(production_name)
+
+    def list_productions(self) -> dict:
+        return _director.list_productions()
+
+    def status_production(self) -> dict:
+        return _director.status_production()
+
+    def start_production(self, production_name: str | None = None) -> None:
+        _director.start_production(production_name)
+
+    def start_production_with_log(self, production_name: str | None = None) -> None:
+        _director.start_production_with_log(production_name)
+
+    def stop_production(self) -> None:
+        _director.stop_production()
+
+    def shutdown_production(self) -> None:
+        _director.shutdown_production()
+
+    def restart_production(self) -> None:
+        _director.restart_production()
+
+    def update_production(self) -> None:
+        _director.update_production()
+
+    def start_component(self, component_name: str) -> None:
+        _director.start_component(component_name)
+
+    def stop_component(self, component_name: str) -> None:
+        _director.stop_component(component_name)
+
+    def restart_component(self, component_name: str) -> None:
+        _director.restart_component(component_name)
+
+    def list_bindings(self, unused_only: bool = False) -> list[dict]:
+        return _migration_utils.list_component_bindings(unused_only=unused_only)
+
+    def unbind_component(self, iris_classname: str) -> None:
+        _migration_utils.unregister_component(iris_classname)
+
+    # ------------------------------------------------------------------
+    # Logging
+    # ------------------------------------------------------------------
+
+    def log_production_top(self, top: int = 10) -> None:
+        _director.log_production_top(top)
+
+    def log_production(self) -> None:
+        _director.log_production()
+
+    # ------------------------------------------------------------------
+    # Test
+    # ------------------------------------------------------------------
+
+    def test_component(
+        self,
+        target: str | None,
+        message=None,
+        classname: str | None = None,
+        body: str | dict | None = None,
+        restart: bool = True,  # ignored locally — included to satisfy DirectorProtocol
+    ):
+        return _director.test_component(target, message, classname, body)
+
+    # ------------------------------------------------------------------
+    # Export
+    # ------------------------------------------------------------------
+
+    def export_production(self, production_name: str) -> dict:
+        return json.loads(_migration_utils.export_production(production_name))
+
+    def export_production_connections(self, production_name: str) -> dict:
+        return _migration_utils.export_production_connections(production_name)
+
+    def export_production_queue_info(self, production_name: str) -> dict:
+        return _migration_utils.export_production_queue_info(production_name)
+
+    def apply_production_plan(
+        self,
+        plan: dict,
+        allow_destructive: bool = False,
+    ) -> dict:
+        return _migration_utils.apply_production_plan(
+            plan,
+            allow_destructive=allow_destructive,
+        )
+
+    # ------------------------------------------------------------------
+    # Init / setup
+    # ------------------------------------------------------------------
+
+    def setup(self, path: str | None = None) -> None:
+        _migration_utils.setup(path)
+
+    # ------------------------------------------------------------------
+    # Migrate
+    # ------------------------------------------------------------------
+
+    def migrate(
+        self,
+        path: str,
+        strict_production_validation: bool = False,
+    ) -> None:
+        _migration_utils.migrate(
+            path,
+            mode="LOCAL",
+            namespace=self.namespace,
+            strict_production_validation=strict_production_validation,
+        )
+
+    # ------------------------------------------------------------------
+    # Metadata
+    # ------------------------------------------------------------------
+
+    @property
+    def namespace(self) -> str:
+        return os.getenv("IRISNAMESPACE", "not set")

iop/{_director_protocol.py → runtime/protocol.py}

@@ -8,7 +8,7 @@ required).
 
 from __future__ import annotations
 
-from typing import Any, Optional, Protocol, runtime_checkable
+from typing import Any, Protocol, runtime_checkable
 
 
 @runtime_checkable
@@ -23,14 +23,19 @@ class DirectorProtocol(Protocol):
     def set_default_production(self, production_name: str = "") -> None: ...
     def list_productions(self) -> dict: ...
     def status_production(self) -> dict: ...
-    def start_production(self, production_name: Optional[str] = None) -> None: ...
+    def start_production(self, production_name: str | None = None) -> None: ...
     def start_production_with_log(
-        self, production_name: Optional[str] = None
+        self, production_name: str | None = None
     ) -> None: ...
     def stop_production(self) -> None: ...
     def shutdown_production(self) -> None: ...
     def restart_production(self) -> None: ...
     def update_production(self) -> None: ...
+    def start_component(self, component_name: str) -> None: ...
+    def stop_component(self, component_name: str) -> None: ...
+    def restart_component(self, component_name: str) -> None: ...
+    def list_bindings(self, unused_only: bool = False) -> list[dict]: ...
+    def unbind_component(self, iris_classname: str) -> None: ...
 
     # ------------------------------------------------------------------
     # Logging
@@ -45,10 +50,11 @@ class DirectorProtocol(Protocol):
 
     def test_component(
         self,
-        target: Optional[str],
+        target: str | None,
         message=None,
-        classname: Optional[str] = None,
-        body: "str | dict | None" = None,
+        classname: str | None = None,
+        body: str | dict | None = None,
+        restart: bool = True,
     ) -> Any: ...
 
     # ------------------------------------------------------------------
@@ -56,18 +62,29 @@ class DirectorProtocol(Protocol):
     # ------------------------------------------------------------------
 
     def export_production(self, production_name: str) -> dict: ...
+    def export_production_connections(self, production_name: str) -> dict: ...
+    def export_production_queue_info(self, production_name: str) -> dict: ...
+    def apply_production_plan(
+        self,
+        plan: dict,
+        allow_destructive: bool = False,
+    ) -> dict: ...
 
     # ------------------------------------------------------------------
     # Init / setup
     # ------------------------------------------------------------------
 
-    def setup(self, path: Optional[str] = None) -> None: ...
+    def setup(self, path: str | None = None) -> None: ...
 
     # ------------------------------------------------------------------
     # Migrate
     # ------------------------------------------------------------------
 
-    def migrate(self, path: str) -> None: ...
+    def migrate(
+        self,
+        path: str,
+        strict_production_validation: bool = False,
+    ) -> None: ...
 
     # ------------------------------------------------------------------
     # Metadata