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

iop/cli/parser.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+import argparse
+
+
+def create_parser() -> argparse.ArgumentParser:
+    """Create and configure the IOP CLI parser."""
+    main_parser = argparse.ArgumentParser(
+        epilog=(
+            "Remote mode: set IOP_URL (e.g. http://localhost:8080) to run all commands\n"
+            "against a remote IRIS instance via its REST API. Optional env vars:\n"
+            "  IOP_USERNAME, IOP_PASSWORD, IOP_NAMESPACE (default: USER),\n"
+            "  IOP_VERIFY_SSL (set to 0 to disable TLS verification).\n"
+            "Alternatively use -R /path/to/settings.py or set IOP_SETTINGS=\n"
+            "(file must contain a REMOTE_SETTINGS dict with at least 'url').\n"
+            "Use --force-local to suppress remote mode entirely."
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser = main_parser.add_mutually_exclusive_group()
+
+    parser.add_argument(
+        "-d", "--default", help="set the default production", nargs="?", const="not_set"
+    )
+    parser.add_argument("-l", "--list", help="list productions", action="store_true")
+    parser.add_argument(
+        "-s", "--start", help="start a production", nargs="?", const="not_set"
+    )
+    parser.add_argument("-S", "--stop", help="stop a production", action="store_true")
+    parser.add_argument("-k", "--kill", help="kill a production", action="store_true")
+    parser.add_argument("-r", "--restart", help="restart a production", action="store_true")
+    parser.add_argument("-x", "--status", help="status a production", action="store_true")
+    parser.add_argument(
+        "-m",
+        "-M",
+        "--migrate",
+        help="migrate production and classes with a Python migration file",
+    )
+    parser.add_argument(
+        "-e", "--export", help="export a production", nargs="?", const="not_set"
+    )
+    parser.add_argument("-v", "--version", help="display version", action="store_true")
+    parser.add_argument("-L", "--log", help="display log", nargs="?", const="not_set")
+    parser.add_argument(
+        "-q",
+        "--queue",
+        help="display runtime queue information",
+        nargs="?",
+        const="not_set",
+    )
+    parser.add_argument(
+        "-i", "--init", help="init the iop module in iris", nargs="?", const="not_set"
+    )
+    parser.add_argument(
+        "--bindings",
+        help="list IOP-generated IRIS proxy class bindings",
+        action="store_true",
+    )
+    parser.add_argument(
+        "--unbind",
+        help="remove an IOP-generated IRIS proxy class binding",
+    )
+    parser.add_argument(
+        "-t", "--test", help="test the iop module in iris", nargs="?", const="not_set"
+    )
+    parser.add_argument("-u", "--update", help="update a production", action="store_true")
+    parser.add_argument(
+        "--plan",
+        help="build a conservative production change plan from a Python settings file",
+    )
+    parser.add_argument("--review-plan", help="print a saved production change plan")
+    parser.add_argument("--apply-plan", help="apply a saved production change plan")
+    parser.add_argument("--verify-plan", help="verify a saved production change plan")
+    parser.add_argument(
+        "--rollback-backup",
+        help="restore a production from a plan/apply backup directory",
+    )
+
+    start = main_parser.add_argument_group("start arguments")
+    start.add_argument(
+        "-D", "--detach", help="start a production in detach mode", action="store_true"
+    )
+
+    test = main_parser.add_argument_group("test arguments")
+    test.add_argument(
+        "-C", "--classname", help="test classname", nargs="?", const="not_set"
+    )
+    test.add_argument(
+        "-B",
+        "--body",
+        help="test body (JSON string or @path/to/file.json)",
+        nargs="?",
+        const="not_set",
+    )
+
+    migrate = main_parser.add_argument_group("migrate arguments")
+    migrate.add_argument(
+        "--force-local",
+        help="force local mode, skip remote even if REMOTE_SETTINGS or IOP_URL is present",
+        action="store_true",
+    )
+    migrate.add_argument(
+        "--dry-run",
+        "--explain",
+        dest="migration_plan",
+        help="show the migration plan and validation messages without writing to IRIS",
+        action="store_true",
+    )
+    migrate.add_argument(
+        "--strict-production-validation",
+        help="fail migration when production validation reports issues",
+        action="store_true",
+    )
+
+    export = main_parser.add_argument_group("export arguments")
+    export.add_argument(
+        "--format",
+        dest="export_format",
+        choices=("json", "python", "class", "graph", "mermaid"),
+        default="json",
+        help="export format for -e/--export",
+    )
+
+    bindings = main_parser.add_argument_group("bindings arguments")
+    bindings.add_argument(
+        "--unused",
+        help="with --bindings, show only proxy classes unused by productions",
+        action="store_true",
+    )
+
+    plan = main_parser.add_argument_group("production plan arguments")
+    plan.add_argument(
+        "--production",
+        help="target production name for --plan, or override the plan production",
+    )
+    plan.add_argument("--out", help="write --plan JSON to this path")
+    plan.add_argument(
+        "--settings",
+        help="settings.py file containing the desired Production for --apply-plan",
+    )
+    plan.add_argument(
+        "--backup-dir",
+        default=".iop/backups",
+        help="directory for apply backup artifacts",
+    )
+    plan.add_argument(
+        "--allow-destructive",
+        help="allow destructive plan operations or rollback",
+        action="store_true",
+    )
+
+    remote = main_parser.add_argument_group("remote arguments")
+    remote.add_argument(
+        "-R",
+        "--remote-settings",
+        help="path to a settings.py containing REMOTE_SETTINGS (overrides IOP_SETTINGS env var)",
+        metavar="FILE",
+    )
+
+    namespace = main_parser.add_argument_group("namespace arguments")
+    namespace.add_argument(
+        "-n", "--namespace", help="set namespace", nargs="?", const="not_set"
+    )
+
+    return main_parser

iop/cli/types.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum, auto
+
+
+class CommandType(Enum):
+    DEFAULT = auto()
+    LIST = auto()
+    START = auto()
+    STOP = auto()
+    KILL = auto()
+    RESTART = auto()
+    STATUS = auto()
+    TEST = auto()
+    VERSION = auto()
+    EXPORT = auto()
+    MIGRATE = auto()
+    LOG = auto()
+    QUEUE = auto()
+    INIT = auto()
+    BINDINGS = auto()
+    UNBIND = auto()
+    HELP = auto()
+    UPDATE = auto()
+    PLAN = auto()
+    REVIEW_PLAN = auto()
+    APPLY_PLAN = auto()
+    VERIFY_PLAN = auto()
+    ROLLBACK_BACKUP = auto()
+
+
+@dataclass
+class CommandArgs:
+    """Container for parsed command arguments."""
+
+    default: str | None = None
+    list: bool = False
+    start: str | None = None
+    detach: bool = False
+    stop: bool = False
+    kill: bool = False
+    restart: bool = False
+    status: bool = False
+    migrate: str | None = None
+    export: str | None = None
+    export_format: str = "json"
+    version: bool = False
+    log: str | None = None
+    queue: str | None = None
+    init: str | None = None
+    bindings: bool = False
+    unused: bool = False
+    unbind: str | None = None
+    test: str | None = None
+    classname: str | None = None
+    body: str | None = None
+    namespace: str | None = None
+    force_local: bool = False
+    remote_settings: str | None = None
+    update: bool = False
+    migration_plan: bool = False
+    strict_production_validation: bool = False
+    plan: str | None = None
+    production: str | None = None
+    out: str | None = None
+    review_plan: str | None = None
+    apply_plan: str | None = None
+    verify_plan: str | None = None
+    rollback_backup: str | None = None
+    settings: str | None = None
+    backup_dir: str = ".iop/backups"
+    allow_destructive: bool = False

iop/cls/IOP/Common.cls

@@ -187,7 +187,7 @@ Method OnTearDown() As %Status
     set tSC = $$$OK
     if $isObject(..%class) {
         try {
-            do ..%class."_dispatch_on_tear_down"()
+            do ..%class."_dispatch_on_tear_down"($this)
         } catch ex {
             set tSC = ex.AsStatus()
         }
@@ -313,7 +313,7 @@ ClassMethod OnGetConnections(
     do pItem.GetModifiedSetting("%classname", .tClassname)
     do pItem.GetModifiedSetting("%module", .tModule)
 
-    // try to instantiate class
+    // Prepare the Python import path for connection discovery.
     if tClasspaths '="" {
             set sys = ##class(%SYS.Python).Import("sys")
             set delimiter = $s($system.Version.GetOS()="Windows":";",1:":")
@@ -329,7 +329,14 @@ ClassMethod OnGetConnections(
     set builtins = ##class(%SYS.Python).Import("builtins")
     set module = ##class(%SYS.Python).Import(tModule)
     set class = builtins.getattr(module, tClassname)
+    // Allocate without calling Python __init__. Connection discovery must not
+    // run user startup code; IoP uses on_init() as the lifecycle hook.
     set tClass = class."__new__"(class)
+    Try {
+        do tClass."_warn_if_custom_init"()
+    }
+    Catch ex {
+    }
 
     set tPythonList = tClass."on_get_connections"()
     set tPythonListLen = tPythonList."__len__"()
@@ -535,6 +542,8 @@ Method CreateClassInstance(module As %SYS.Python) As %SYS.Python [ Private ]
 {
     set builtins = ##class(%SYS.Python).Import("builtins")
     set class = builtins.getattr(module, ..%classname)
+    // Intentionally bypass Python __init__. IRIS applies handles/settings and
+    // then calls on_init() through _dispatch_on_init().
     quit class."__new__"(class)
 }
 

iop/cls/IOP/PrivateSession/Duplex.cls

@@ -250,7 +250,7 @@ Method OnTearDown() As %Status
     #dim tSC As %Status = $$$OK
     try {
         If ..%InPrivateSession Set tSC=..StopPrivateSession() Quit:$$$ISERR(tSC)
-        do ..%class."_dispatch_on_tear_down"()
+        do ..%class."_dispatch_on_tear_down"($this)
     } catch {
         Set tSC=$$$EnsSystemError
     }

iop/cls/IOP/Service/Remote/Rest/v1.cls

@@ -14,11 +14,18 @@ XData UrlMap [ XMLNamespace = "http://www.intersystems.com/urlmap" ]
 <Route Url="/kill"     Method="POST" Call="PostKill"/>
 <Route Url="/restart"  Method="POST" Call="PostRestart"/>
 <Route Url="/update"   Method="POST" Call="PostUpdate"/>
+<Route Url="/component/start"   Method="POST" Call="PostComponentStart"/>
+<Route Url="/component/stop"    Method="POST" Call="PostComponentStop"/>
+<Route Url="/component/restart" Method="POST" Call="PostComponentRestart"/>
+<Route Url="/bindings" Method="GET" Call="GetBindings"/>
+<Route Url="/binding"  Method="DELETE" Call="DeleteBinding"/>
 <Route Url="/list"     Method="GET"  Call="GetList"/>
 <Route Url="/default"  Method="GET"  Call="GetDefault"/>
 <Route Url="/default"  Method="PUT"  Call="PutDefault"/>
 <Route Url="/log"      Method="GET"  Call="GetLog"/>
 <Route Url="/export"   Method="GET"  Call="GetExport"/>
+<Route Url="/connections" Method="GET" Call="GetConnections"/>
+<Route Url="/queues"   Method="GET"  Call="GetQueues"/>
 <Route Url="/test"     Method="POST" Call="PostTest"/>
 </Routes>
 }
@@ -121,7 +128,19 @@ ClassMethod PostRestart() As %Status
 		Try { Set dyna = {}.%FromJSON(%request.Content) } Catch { Set dyna = {} }
 		Set ns = ..ResolveNs(dyna)
 		If ns '= "" { Do ..NamespaceCheck(ns)  New $NAMESPACE  Set $NAMESPACE = ns }
-		$$$ThrowOnError(##class(Ens.Director).RestartProduction())
+		$$$ThrowOnError(##class(Ens.Director).GetProductionStatus(.production, .status))
+		If production = "" { Set production = $Get(^Ens.Configuration("csp","LastProduction")) }
+		If production = "" { Throw $$$ERROR("NoProductionSpecified") }
+		Set sc = ##class(Ens.Director).RestartProduction()
+		If $$$ISERR(sc) {
+			Set errorText = $SYSTEM.Status.GetErrorText(sc)
+			If $Find(errorText, "ErrProductionNotQuiescent") {
+				$$$ThrowOnError(##class(Ens.Director).StopProduction(10, 1))
+				$$$ThrowOnError(##class(Ens.Director).StartProduction(production))
+			} Else {
+				$$$ThrowOnError(sc)
+			}
+		}
 		Return ..%WriteResponse({"status": "restarted"}.%ToJSON())
 	} Catch ex {
 		Return ..%WriteErrorResponse(ex.DisplayString())
@@ -141,6 +160,89 @@ ClassMethod PostUpdate() As %Status
 	}
 }
 
+ClassMethod PostComponentStart() As %Status
+{
+	Try {
+		Set dyna = {}.%FromJSON(%request.Content)
+		Set ns = ..ResolveNs(dyna)
+		Set component = dyna.%Get("component")
+		If component = "" { Set component = dyna.%Get("item") }
+		If component = "" { Throw $$$ERROR("NoComponentSpecified") }
+		If ns '= "" { Do ..NamespaceCheck(ns)  New $NAMESPACE  Set $NAMESPACE = ns }
+		$$$ThrowOnError(##class(Ens.Director).EnableConfigItem(component, 1, 1))
+		Return ..%WriteResponse({"status": "started", "component": (component)}.%ToJSON())
+	} Catch ex {
+		Return ..%WriteErrorResponse(ex.DisplayString())
+	}
+}
+
+ClassMethod PostComponentStop() As %Status
+{
+	Try {
+		Set dyna = {}.%FromJSON(%request.Content)
+		Set ns = ..ResolveNs(dyna)
+		Set component = dyna.%Get("component")
+		If component = "" { Set component = dyna.%Get("item") }
+		If component = "" { Throw $$$ERROR("NoComponentSpecified") }
+		If ns '= "" { Do ..NamespaceCheck(ns)  New $NAMESPACE  Set $NAMESPACE = ns }
+		$$$ThrowOnError(##class(Ens.Director).EnableConfigItem(component, 0, 1))
+		Return ..%WriteResponse({"status": "stopped", "component": (component)}.%ToJSON())
+	} Catch ex {
+		Return ..%WriteErrorResponse(ex.DisplayString())
+	}
+}
+
+ClassMethod PostComponentRestart() As %Status
+{
+	Try {
+		Set dyna = {}.%FromJSON(%request.Content)
+		Set ns = ..ResolveNs(dyna)
+		Set component = dyna.%Get("component")
+		If component = "" { Set component = dyna.%Get("item") }
+		If component = "" { Throw $$$ERROR("NoComponentSpecified") }
+		If ns '= "" { Do ..NamespaceCheck(ns)  New $NAMESPACE  Set $NAMESPACE = ns }
+		$$$ThrowOnError(##class(Ens.Director).EnableConfigItem(component, 0, 1))
+		$$$ThrowOnError(##class(Ens.Director).EnableConfigItem(component, 1, 1))
+		Return ..%WriteResponse({"status": "restarted", "component": (component)}.%ToJSON())
+	} Catch ex {
+		Return ..%WriteErrorResponse(ex.DisplayString())
+	}
+}
+
+ClassMethod DeleteBinding() As %Status
+{
+	Try {
+		Set ns = ..GetNsParam()
+		Set classname = %request.Get("class")
+		If classname = "" { Set classname = %request.Get("classname") }
+		If classname = "" { Throw $$$ERROR("NoClassSpecified") }
+		If ns '= "" { Do ..NamespaceCheck(ns)  New $NAMESPACE  Set $NAMESPACE = ns }
+		$$$ThrowOnError(##class(IOP.Utils).DeleteComponentProxy(classname))
+		Return ..%WriteResponse({"status": "unbound", "class": (classname)}.%ToJSON())
+	} Catch ex {
+		Return ..%WriteErrorResponse(ex.DisplayString())
+	}
+}
+
+ClassMethod GetBindings() As %Status
+{
+	Try {
+		Set ns = ..GetNsParam()
+		Set unused = ..BooleanQueryParam(%request.Get("unused"))
+		If ns '= "" { Do ..NamespaceCheck(ns)  New $NAMESPACE  Set $NAMESPACE = ns }
+		Set jsonStr = ##class(IOP.Utils).ListComponentProxies(unused)
+		Return ..%WriteResponse(jsonStr)
+	} Catch ex {
+		Return ..%WriteErrorResponse(ex.DisplayString())
+	}
+}
+
+ClassMethod BooleanQueryParam(pValue As %String) As %Boolean [ Internal, Private ]
+{
+	Set value = $ZCONVERT(pValue,"L")
+	Quit $Select(value="1":1,value="true":1,value="yes":1,value="on":1,1:0)
+}
+
 ClassMethod GetList() As %Status
 {
 	Try {
@@ -248,8 +350,45 @@ ClassMethod GetExport() As %Status
 		While 'xdata.AtEnd { Set xml = xml _ xdata.Read(32000) }
 
 		// Convert to JSON via Python xmltodict
-		Set iopUtils = ##class(IOP.Wrapper).Import("iop._utils")
-		Set jsonStr = iopUtils."_Utils"."xml_to_json"(xml)
+		Set iopUtils = ##class(IOP.Wrapper).Import("iop.migration.utils")
+		Set builtins = ##class(%SYS.Python).Import("builtins")
+		If builtins.hasattr(iopUtils, "xml_to_json") {
+			Set jsonStr = builtins.getattr(iopUtils, "xml_to_json")."__call__"(xml)
+		} Else {
+			Set jsonStr = iopUtils."_Utils"."xml_to_json"(xml)
+		}
+		Return ..%WriteResponse(jsonStr)
+	} Catch ex {
+		Return ..%WriteErrorResponse(ex.DisplayString())
+	}
+}
+
+/// GET /connections?production=MyApp.Production&namespace=USER
+/// Returns runtime graph connections from OnGetConnections.
+ClassMethod GetConnections() As %Status
+{
+	Try {
+		Set ns = ..GetNsParam()
+		If ns '= "" { Do ..NamespaceCheck(ns)  New $NAMESPACE  Set $NAMESPACE = ns }
+		Set production = %request.Get("production")
+		If production = "" { Set production = $Get(^Ens.Configuration("csp","LastProduction"), "") }
+		Set jsonStr = ##class(IOP.Utils).ExportProductionConnections(production)
+		Return ..%WriteResponse(jsonStr)
+	} Catch ex {
+		Return ..%WriteErrorResponse(ex.DisplayString())
+	}
+}
+
+/// GET /queues?production=MyApp.Production&namespace=USER
+/// Returns queue counters for production items.
+ClassMethod GetQueues() As %Status
+{
+	Try {
+		Set ns = ..GetNsParam()
+		If ns '= "" { Do ..NamespaceCheck(ns)  New $NAMESPACE  Set $NAMESPACE = ns }
+		Set production = %request.Get("production")
+		If production = "" { Set production = $Get(^Ens.Configuration("csp","LastProduction"), "") }
+		Set jsonStr = ##class(IOP.Utils).ExportProductionQueueInfo(production)
 		Return ..%WriteResponse(jsonStr)
 	} Catch ex {
 		Return ..%WriteErrorResponse(ex.DisplayString())
@@ -359,6 +498,9 @@ ClassMethod PutMigrate() As %DynamicObject
 		set namespace = ..ResolveNs(dyna)
 		set targetDirectory = dyna.%Get("remote_folder")
 		set packageName = dyna.%Get("package")
+		set settingsFile = dyna.%Get("settings_file")
+		set strictProductionValidation = dyna.%Get("strict_production_validation")
+		If settingsFile = "" { Set settingsFile = "settings.py" }
 		// check for namespace existence and user permissions against namespace
 		If '..NamespaceCheck(namespace) {
 			Return ""
@@ -407,8 +549,13 @@ ClassMethod PutMigrate() As %DynamicObject
 
 		//Do the iop migration
 
-		set iopUtils = ##class(IOP.Wrapper).Import("iop._utils")
-    	do iopUtils."_Utils".migrate(##class(%Library.File).NormalizeFilename("settings.py", packagePath))
+		set iopUtils = ##class(IOP.Wrapper).Import("iop.migration.utils")
+		set builtins = ##class(%SYS.Python).Import("builtins")
+		If builtins.hasattr(iopUtils, "migrate") {
+			do builtins.getattr(iopUtils, "migrate")."__call__"(##class(%Library.File).NormalizeFilename(settingsFile, packagePath),"REMOTE",namespace,strictProductionValidation)
+		} Else {
+			do iopUtils."_Utils".migrate(##class(%Library.File).NormalizeFilename(settingsFile, packagePath))
+		}
 	}
 	Catch ex {
 		$$$ThrowOnError(ex.AsStatus())