mas-cli 21.9.0__tar.gz → 21.9.2__tar.gz

{mas_cli-21.9.0/python/src/mas_cli.egg-info → mas_cli-21.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mas-cli
-Version: 21.9.0
+Version: 21.9.2
 Summary: Python Admin CLI for Maximo Application Suite
 Author-email: David Parker <parkerda@uk.ibm.com>
 License-Expression: EPL-1.0

{mas_cli-21.9.0 → mas_cli-21.9.2}/python/src/mas/cli/__init__.py

@@ -10,4 +10,4 @@
 
 from .cli import BaseApp  # noqa: F401
 
-__version__ = "21.9.0"  # Python module compatible semver
+__version__ = "21.9.2"  # Python module compatible semver

{mas_cli-21.9.0 → mas_cli-21.9.2}/python/src/mas/cli/cli.py

@@ -126,7 +126,7 @@ class BaseApp(PrintMixin, PromptMixin):
         logging.getLogger("urllib3").setLevel(logging.INFO)
 
         # Supports extended semver, unlike mas.cli.__version__
-        self.version: str = "21.9.0"
+        self.version: str = "21.9.2"
         self.h1count: int = 0
         self.h2count: int = 0
 

{mas_cli-21.9.0 → mas_cli-21.9.2}/python/src/mas/cli/install/app.py

@@ -273,11 +273,8 @@ class InstallApp(
 
         # Generate catalogTable
         for application, key in applications.items():
-            # Add 9.1-feature channel based off 9.0 to those apps that have not onboarded yet
             if key in self.chosenCatalog:
                 tempChosenCatalog = self.chosenCatalog[key].copy()
-                if "9.1.x-feature" not in tempChosenCatalog and "9.0.x" in tempChosenCatalog:
-                    tempChosenCatalog.update({"9.1.x-feature": tempChosenCatalog["9.0.x"]})
 
                 self.catalogTable.append({"": application} | {key.replace(".x", ""): value for key, value in sorted(tempChosenCatalog.items(), reverse=True)})
 

{mas_cli-21.9.0 → mas_cli-21.9.2}/python/src/mas/cli/must_gather/aiservice/instance.py

@@ -17,6 +17,18 @@ from kubernetes.dynamic import DynamicClient
 
 logger = logging.getLogger(__name__)
 
+# Tekton resources to collect (both v1 and v1beta1 for compatibility)
+TEKTON_RESOURCES = [
+    ("tekton.dev/v1", "Pipeline"),
+    ("tekton.dev/v1", "PipelineRun"),
+    ("tekton.dev/v1", "Task"),
+    ("tekton.dev/v1", "TaskRun"),
+    ("tekton.dev/v1beta1", "Pipeline"),
+    ("tekton.dev/v1beta1", "PipelineRun"),
+    ("tekton.dev/v1beta1", "Task"),
+    ("tekton.dev/v1beta1", "TaskRun"),
+]
+
 
 def discoverAIServiceInstances(dynClient: DynamicClient, instanceIds: Optional[str] = None) -> List[str]:
     """Discover AI Service instances in the cluster.
@@ -111,7 +123,7 @@ def _generateAIServiceSummary(dynClient: DynamicClient, namespace: str, outputFi
             f.write("-" * 80 + "\n")
             try:
                 api = dynClient.resources.get(api_version="aiservice.ibm.com/v1", kind="AIServiceTenant")
-                tenants = api.get(namespace=namespace)
+                tenants = api.get()
                 if tenants.items:
                     for tenant in tenants.items:
                         f.write(f"Name: {tenant.metadata.name}\n")
@@ -133,8 +145,8 @@ def addAIServiceToCollectionPlan(plan, dynClient: DynamicClient, outputDir: str,
     """Add AI Service collection tasks to the collection plan.
 
     Discovers AI Service instances and for each instance, adds collection groups for:
-    - The instance namespace (mas-{instance}-aiservice)
-    - Tenant namespaces (mas-{instance}-aiservice-{tenant})
+    - The instance namespace (aiservice-{instance})
+    - Tenant namespaces (aiservice-{instance}-{tenant})
     - Pipeline namespaces (aiservice-{instance}-pipelines)
 
     Args:
@@ -147,6 +159,7 @@ def addAIServiceToCollectionPlan(plan, dynClient: DynamicClient, outputDir: str,
     from mas.cli.must_gather.common.task_generation import generateNamespaceCollectionTasks
     from mas.cli.must_gather.aiservice import tenant as aiservice_tenant
     from mas.cli.must_gather.aiservice import pipelines as aiservice_pipelines
+    from mas.cli.must_gather.common import generateReconcileLogsCollectionTasks
 
     logger.info("Discovering AI Service instances")
     try:
@@ -155,7 +168,7 @@ def addAIServiceToCollectionPlan(plan, dynClient: DynamicClient, outputDir: str,
             logger.info(f"Discovered {len(instanceIds)} AI Service instance(s): {', '.join(sorted(instanceIds))}")
             for instanceId in sorted(instanceIds):
                 # Generate tasks for AI Service instance namespace
-                instanceNamespace = f"mas-{instanceId}-aiservice"
+                instanceNamespace = f"aiservice-{instanceId}"
                 tasks = generateNamespaceCollectionTasks(
                     dynClient=dynClient,
                     namespace=instanceNamespace,
@@ -165,27 +178,47 @@ def addAIServiceToCollectionPlan(plan, dynClient: DynamicClient, outputDir: str,
                     customResources=None,
                     ibmCRDs=ibmCRDs,
                 )
+
+                # Add AI Service specific reconcile logs tasks
+                operators = [
+                    (instanceNamespace, "control-plane", "ibm-aiservice"),
+                    (instanceNamespace, "aiservice.ibm.com/appType", "entitymgr-tenant-operator"),
+                    (instanceNamespace, "control-plane", "controller-manager"),
+                    (instanceNamespace, "operator", "ibm-truststore-mgr"),
+                ]
+                tasks.extend(generateReconcileLogsCollectionTasks(operators, outputDir))
+
                 plan.addGroup(f"AI Service Instance ({instanceId})", tasks)
                 logger.debug(f"Added {len(tasks)} AI Service instance collection tasks for {instanceId}")
 
                 # Discover tenants for this instance
+                # Discover InferenceServices created by each tenant
+                ISVC_RESOURCES = [("serving.kserve.io/v1beta1", "InferenceService")]
                 logger.debug(f"Discovering AI Service tenants for instance {instanceId}")
                 try:
                     tenantIds = aiservice_tenant.discoverAIServiceTenants(dynClient, instanceId=instanceId)
                     if tenantIds:
                         logger.info(f"Discovered {len(tenantIds)} AI Service tenant(s) for instance {instanceId}: {', '.join(sorted(tenantIds))}")
                         for tenantId in sorted(tenantIds):
-                            tenantNamespace = f"mas-{instanceId}-aiservice-{tenantId}"
                             # Generate tasks for AI Service tenant namespace
                             tasks = generateNamespaceCollectionTasks(
                                 dynClient=dynClient,
-                                namespace=tenantNamespace,
+                                namespace=tenantId,
                                 outputDir=outputDir,
                                 noLogs=noLogs,
                                 secretData=False,
-                                customResources=None,
+                                customResources=ISVC_RESOURCES,
                                 ibmCRDs=ibmCRDs,
                             )
+
+                            # Add AI Service tenant specific reconcile logs tasks
+                            operators = [
+                                (tenantId, "control-plane", "ibm-aiservice-tenant"),
+                                (tenantId, "control-plane", "controller-manager"),
+                                (tenantId, "operator", "ibm-truststore-mgr"),
+                            ]
+                            tasks.extend(generateReconcileLogsCollectionTasks(operators, outputDir))
+
                             plan.addGroup(f"AI Service Tenant ({instanceId}/{tenantId})", tasks)
                             logger.debug(f"Added {len(tasks)} AI Service tenant collection tasks for {instanceId}/{tenantId}")
                     else:
@@ -209,7 +242,7 @@ def addAIServiceToCollectionPlan(plan, dynClient: DynamicClient, outputDir: str,
                                 outputDir=outputDir,
                                 noLogs=noLogs,
                                 secretData=False,
-                                customResources=None,
+                                customResources=TEKTON_RESOURCES,
                                 ibmCRDs=ibmCRDs,
                             )
                             plan.addGroup(f"AI Service Pipelines ({pipelineNamespace})", tasks)

{mas_cli-21.9.0 → mas_cli-21.9.2}/python/src/mas/cli/must_gather/aiservice/tenant.py

@@ -32,21 +32,21 @@ def discoverAIServiceTenants(dynClient: DynamicClient, instanceId: str, tenantId
         List[str]: List of AI Service tenant IDs
     """
     tenants = []
-    namespace = f"aiservice-{instanceId}"
 
     try:
         api = dynClient.resources.get(api_version="aiservice.ibm.com/v1", kind="AIServiceTenant")
-        aiserviceTenants = api.get(namespace=namespace)
+        label_selector = f"aiservice.ibm.com/instanceId={instanceId}"
+        aiserviceTenants = api.get(label_selector=label_selector)
 
         for tenantCr in aiserviceTenants.items:
             tenantId = tenantCr.metadata.name
             if tenantId not in tenants:
                 tenants.append(tenantId)
 
-        logger.info(f"Discovered {len(tenants)} AI Service tenants in namespace {namespace}")
+        logger.info(f"Discovered {len(tenants)} AI Service tenants")
 
     except Exception as e:
-        logger.debug(f"Could not discover AI Service tenants in {namespace}: {e}")
+        logger.debug(f"Could not discover AI Service tenants: {e}")
 
     # Filter by tenant IDs if provided
     if tenantIds:

{mas_cli-21.9.0 → mas_cli-21.9.2}/python/src/mas/cli/must_gather/app.py

@@ -281,7 +281,7 @@ class MustGatherApp(BaseApp):
             CollectionPlan: Complete plan with all collection tasks organized into groups
         """
         from .collection_plan import CollectionPlan
-        from .dependencies import kafka, mongodb, grafana, cert_manager, db2, cp4d
+        from .dependencies import kafka, mongodb, grafana, cert_manager, db2, cp4d, rhoai
 
         # Type assertion: dynClient is guaranteed to be non-None by connect()
         assert self.dynamicClient is not None, "Kubernetes client must be initialized before planning collection"
@@ -380,6 +380,18 @@ class MustGatherApp(BaseApp):
         else:
             logger.debug("Skipping CP4D collection (not in collectors list)")
 
+        # Red Hat OpenShift AI
+        if "rhoai" in enabledCollectors:
+            rhoai.addRHOAIToCollectionPlan(
+                plan=plan,
+                dynClient=self.dynamicClient,
+                outputDir=outputDir,
+                noLogs=parsedArgs.no_logs,
+                ibmCRDs=self.ibmCRDsList,
+            )
+        else:
+            logger.debug("Skipping Red Hat OpenShift AI collection (not in collectors list)")
+
         # SLS
         if "sls" in enabledCollectors:
             masInstanceIds = parsedArgs.mas_instance_ids.split(",") if parsedArgs.mas_instance_ids else None

{mas_cli-21.9.0 → mas_cli-21.9.2}/python/src/mas/cli/must_gather/arg_parser.py

@@ -72,7 +72,7 @@ def _parse_args_wrapper(args=None, namespace=None):
 
 
 # Define all available collectors
-ALL_COLLECTORS = ["ocp", "db2", "kafka", "mongodb", "cp4d", "cert-manager", "grafana", "sls", "mas", "aiservice", "lic"]
+ALL_COLLECTORS = ["ocp", "db2", "kafka", "mongodb", "cp4d", "cert-manager", "grafana", "sls", "mas", "rhoai", "aiservice", "lic"]
 
 
 def validateCollectors(collectorsStr: str) -> str:

mas_cli-21.9.2/python/src/mas/cli/must_gather/dependencies/rhoai.py

@@ -0,0 +1,129 @@
+# *****************************************************************************
+# Copyright (c) 2026 IBM Corporation and other Contributors.
+#
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+#
+# *****************************************************************************
+
+"""Red Hat OpenShift AI dependency collector."""
+
+import logging
+from typing import Set, List, Tuple, Optional
+from kubernetes.dynamic import DynamicClient
+
+from mas.cli.must_gather.common.task_generation import generateNamespaceCollectionTasks
+from .utils import checkNamespaceExists
+
+logger = logging.getLogger(__name__)
+
+# ODH Resources that are provided by RHOAI operator and used by AI Service
+ODH_RESOURCES = [
+    ("datasciencecluster.opendatahub.io/v1", "DataScienceCluster"),
+    ("dscinitialization.opendatahub.io/v1", "DSCInitialization"),
+    ("components.platform.opendatahub.io/v1alpha1", "Kserve"),
+    ("components.platform.opendatahub.io/v1alpha1", "ModelController"),
+    ("services.platform.opendatahub.io/v1alpha1", "Auth"),
+]
+
+
+def _discoverRHOAINamespaces(dynClient: DynamicClient) -> Set[str]:
+    """Discover Red Hat OpenShift AI namespaces.
+
+    Checks for standard RHOAI namespaces and returns those that exist.
+    RHOAI typically uses these namespaces:
+    - redhat-ods-operator: Operator namespace
+    - redhat-ods-applications: Applications namespace
+
+    Args:
+        dynClient (DynamicClient): Kubernetes Dynamic Client for API access
+
+    Returns:
+        set: Set of RHOAI namespace names that exist in the cluster
+    """
+    # RHOAI namespaces to check
+    candidateNamespaces = ["redhat-ods-operator", "redhat-ods-applications"]
+
+    discoveredNamespaces = set()
+    for namespace in candidateNamespaces:
+        if checkNamespaceExists(dynClient, namespace):
+            discoveredNamespaces.add(namespace)
+            logger.debug(f"Found RHOAI namespace: {namespace}")
+
+    return discoveredNamespaces
+
+
+def _generateRHOAICollectionTasks(
+    dynClient: DynamicClient,
+    namespace: str,
+    outputDir: str,
+    noLogs: bool = False,
+    customResources: Optional[List[Tuple[str, str]]] = None,
+    ibmCRDs: Optional[List[Tuple[str, str]]] = None,
+) -> List[Tuple]:
+    """Generate collection tasks for a RHOAI namespace.
+
+    Creates a list of collection tasks that can be executed in parallel
+    for collecting RHOAI resources from a specific namespace.
+
+    Args:
+        dynClient (DynamicClient): Kubernetes Dynamic Client for API access
+        namespace (str): Target namespace for collection
+        outputDir (str): Base output directory for collected resources
+        noLogs (bool, optional): If True, skip pod log collection. Defaults to False.
+        customResources (list, optional): Custom CRD tuples (apiVersion, kind) specific to this namespace type. Defaults to None.
+        ibmCRDs (list, optional): List of IBM CRD tuples (apiVersion, kind) to collect. Defaults to None.
+
+    Returns:
+        list: List of task tuples in format (task_name, func, *args)
+    """
+
+    # Use common namespace collection task generation
+    tasks = generateNamespaceCollectionTasks(
+        dynClient=dynClient,
+        namespace=namespace,
+        outputDir=outputDir,
+        noLogs=noLogs,
+        secretData=False,
+        customResources=customResources,
+        ibmCRDs=ibmCRDs,
+    )
+
+    return tasks
+
+
+def addRHOAIToCollectionPlan(plan, dynClient: DynamicClient, outputDir: str, noLogs: bool, ibmCRDs: list):
+    """Add RHOAI collection tasks to the collection plan.
+
+    Discovers RHOAI namespaces and adds collection groups for each namespace
+    to the provided collection plan.
+
+    Args:
+        plan (CollectionPlan): Collection plan to add tasks to
+        dynClient (DynamicClient): Kubernetes Dynamic Client for API access
+        outputDir (str): Base output directory for collected resources
+        noLogs (bool): If True, skip pod log collection
+        ibmCRDs (list): List of IBM CRD information for collection
+    """
+    logger.info("💭 Discovering Red Hat OpenShift AI namespaces")
+    try:
+        rhoaiNamespaces = _discoverRHOAINamespaces(dynClient)
+        if rhoaiNamespaces:
+            logger.debug(f"Discovered {len(rhoaiNamespaces)} RHOAI namespace(s): {', '.join(sorted(rhoaiNamespaces))}")
+            for ns in sorted(rhoaiNamespaces):
+                tasks = _generateRHOAICollectionTasks(
+                    dynClient=dynClient,
+                    namespace=ns,
+                    outputDir=outputDir,
+                    noLogs=noLogs,
+                    customResources=ODH_RESOURCES if ns == "redhat-ods-applications" else None,
+                    ibmCRDs=ibmCRDs,
+                )
+                plan.addGroup(f"Red Hat OpenShift AI ({ns})", tasks)
+                logger.debug(f"✅ {ns}: Added {len(tasks)} collection tasks")
+        else:
+            logger.warning("⚠️ No Red Hat OpenShift AI namespaces discovered")
+    except Exception as e:
+        logger.error(f"❌ RHOAI discovery failed: {e}")