mas-cli 12.0.0__py3-none-any.whl → 12.27.0__py3-none-any.whl

mas/cli/install/app.py

@@ -40,11 +40,17 @@ from mas.cli.validators import (
     WorkspaceNameFormatValidator,
     TimeoutFormatValidator,
     StorageClassValidator,
+    JsonValidator,
     OptimizerInstallPlanValidator
 )
 
 from mas.devops.ocp import createNamespace, getStorageClasses
-from mas.devops.mas import getCurrentCatalog, getDefaultStorageClasses
+from mas.devops.mas import (
+    getCurrentCatalog,
+    getDefaultStorageClasses,
+    isVersionEqualOrAfter
+)
+from mas.devops.sls import findSLSByNamespace
 from mas.devops.data import getCatalog
 from mas.devops.tekton import (
     installOpenShiftPipelines,
@@ -158,47 +164,69 @@ class InstallApp(BaseApp, InstallSettingsMixin, InstallSummarizerMixin, ConfigGe
         year = date[:2]
         return f" - {monthName} 20{year} Update\n   <Orange><u>https://ibm-mas.github.io/cli/catalogs/{name}</u></Orange>"
 
-    def formatRelease(self, release: str) -> str:
-        return f"{release} ... {self.catalogReleases[release]['core']}"
-
     @logMethodCall
     def processCatalogChoice(self) -> list:
         self.catalogDigest = self.chosenCatalog["catalog_digest"]
-        self.catalogCp4dVersion = self.chosenCatalog["cpd_product_version_default"]
         self.catalogMongoDbVersion = self.chosenCatalog["mongo_extras_version_default"]
+        if self.architecture != "s390x" and self.architecture != "ppc64le":
+            self.catalogCp4dVersion = self.chosenCatalog["cpd_product_version_default"]
+
+            applications = {
+                "Core": "mas_core_version",
+                "Manage": "mas_manage_version",
+                "IoT": "mas_iot_version",
+                "Monitor": "mas_monitor_version",
+                "Assist": "mas_assist_version",
+                "Optimizer": "mas_optimizer_version",
+                "Predict": "mas_predict_version",
+                "Inspection": "mas_visualinspection_version",
+                "Facilities": "mas_facilities_version",
+            }
+        else:
+            applications = {
+                "Core": "mas_core_version",
+                "Manage": "mas_manage_version",
+            }
 
-        self.catalogReleases = []
+        self.catalogReleases = {}
         self.catalogTable = []
 
-        applications = {
-            "Core": "mas_core_version",
-            "Manage": "mas_manage_version",
-            "IoT": "mas_iot_version",
-            "Monitor": "mas_monitor_version",
-            "Assist": "mas_assist_version",
-            "Optimizer": "mas_optimizer_version",
-            "Predict": "mas_predict_version",
-            "Inspection": "mas_visualinspection_version",
-        }
-
         # Dynamically fetch the channels from the chosen catalog
         # based on mas core
         for channel in self.chosenCatalog["mas_core_version"]:
-            self.catalogReleases.append(channel)
+            # {"9.1-feature": "9.1.x-feature"}
+            self.catalogReleases.update({channel.replace('.x', ''): channel})
 
         # Generate catalogTable
         for application, key in applications.items():
-            self.catalogTable.append({"": application} | self.chosenCatalog[key])
+            # 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:
+                    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)})
+
+        if self.architecture == "s390x" or self.architecture == "ppc64le":
+            summary = [
+                "",
+                "<u>Catalog Details</u>",
+                f"Catalog Image:         icr.io/cpopen/ibm-maximo-operator-catalog:{self.getParam('mas_catalog_version')}",
+                f"Catalog Digest:        {self.catalogDigest}",
+                f"MAS Releases:          {', '.join(sorted(self.catalogReleases, reverse=True))}",
+                f"MongoDb:               {self.catalogMongoDbVersion}",
+            ]
+        else:
+            summary = [
+                "",
+                "<u>Catalog Details</u>",
+                f"Catalog Image:         icr.io/cpopen/ibm-maximo-operator-catalog:{self.getParam('mas_catalog_version')}",
+                f"Catalog Digest:        {self.catalogDigest}",
+                f"MAS Releases:          {', '.join(sorted(self.catalogReleases, reverse=True))}",
+                f"Cloud Pak for Data:    {self.catalogCp4dVersion}",
+                f"MongoDb:               {self.catalogMongoDbVersion}",
+            ]
 
-        summary = [
-            "",
-            "<u>Catalog Details</u>",
-            f"Catalog Image:         icr.io/cpopen/ibm-maximo-operator-catalog:{self.getParam('mas_catalog_version')}",
-            f"Catalog Digest:        {self.catalogDigest}",
-            f"MAS Releases:          {', '.join(self.catalogReleases)}",
-            f"Cloud Pak for Data:    {self.catalogCp4dVersion}",
-            f"MongoDb:               {self.catalogMongoDbVersion}",
-        ]
         return summary
 
     @logMethodCall
@@ -237,28 +265,64 @@ class InstallApp(BaseApp, InstallSettingsMixin, InstallSummarizerMixin, ConfigGe
             self.printDescription(catalogSummary)
             self.printDescription([
                 "",
-                "Multiple releases of Maximo Application Suite are available, each is supported under IBM's standard 3+1+3 support model.",
-                "Choose the release of IBM Maximo Application Suite that you want to use for this installation from the table below:",
+                "Two types of release are available:",
+                " - GA releases of Maximo Application Suite are supported under IBM's standard 3+1+3 support lifecycle policy.",
+                " - 'Feature' releases allow early access to new features for evaluation in non-production environments and are only supported through to the next GA release.",
                 ""
             ])
 
             print(tabulate(self.catalogTable, headers="keys", tablefmt="simple_grid"))
 
-            releaseCompleter = WordCompleter(self.catalogReleases)
+            releaseCompleter = WordCompleter(sorted(self.catalogReleases, reverse=True))
             releaseSelection = self.promptForString("Select release", completer=releaseCompleter)
 
-            self.setParam("mas_channel", releaseSelection)
+            self.setParam("mas_channel", self.catalogReleases[releaseSelection])
 
     @logMethodCall
     def configSLS(self) -> None:
-        self.printH1("Configure Product License")
+        self.printH1("Configure AppPoint Licensing")
+        self.printDescription(
+            [
+                "By default the MAS instance will be configured to use a cluster-shared License, this provides a shared pool of AppPoints available to all MAS instances on the cluster.",
+                "",
+            ]
+        )
+
+        self.slsMode = 1
+        self.slsLicenseFileLocal = None
+
+        if self.showAdvancedOptions:
+            self.printDescription(
+                [
+                    "Alternatively you may choose to install using a dedicated license only available to this MAS instance.",
+                    "  1. Install MAS with Cluster-Shared License (AppPoints)",
+                    "  2. Install MAS with Dedicated License (AppPoints)",
+                ]
+            )
+            self.slsMode = self.promptForInt("SLS Mode", default=1)
+
+            if self.slsMode not in [1, 2]:
+                self.fatalError(f"Invalid selection: {self.slsMode}")
+
+        if not (self.slsMode == 2 and not self.getParam("sls_namespace")):
+            sls_namespace = "ibm-sls" if self.slsMode == 1 else self.getParam("sls_namespace")
+            if findSLSByNamespace(sls_namespace, dynClient=self.dynamicClient):
+                print_formatted_text(HTML(f"<MediumSeaGreen>SLS auto-detected: {sls_namespace}</MediumSeaGreen>"))
+                print()
+                if not self.yesOrNo("Upload/Replace the license file"):
+                    self.setParam("sls_action", "gencfg")
+                    return
+
         self.slsLicenseFileLocal = self.promptForFile("License file", mustExist=True, envVar="SLS_LICENSE_FILE_LOCAL")
+        self.setParam("sls_action", "install")
+
+    @logMethodCall
+    def configDRO(self) -> None:
         self.promptForString("Contact e-mail address", "uds_contact_email")
         self.promptForString("Contact first name", "uds_contact_firstname")
         self.promptForString("Contact last name", "uds_contact_lastname")
 
         if self.showAdvancedOptions:
-            self.promptForString("IBM Suite License Services (SLS) Namespace", "sls_namespace", default="ibm-sls")
             self.promptForString("IBM Data Reporter Operator (DRO) Namespace", "dro_namespace", default="redhat-marketplace")
 
     @logMethodCall
@@ -269,8 +333,8 @@ class InstallApp(BaseApp, InstallSettingsMixin, InstallSummarizerMixin, ConfigGe
 
     @logMethodCall
     def configGrafana(self) -> None:
-        if self.architecture == "s390x":
-            # We are not supporting Grafana on s390x at the moment
+        if self.architecture == "s390x" or self.architecture == "ppc64le":
+            # We are not supporting Grafana on s390x /ppc64le at the moment
             self.setParam("grafana_action", "none")
         else:
             try:
@@ -312,7 +376,7 @@ class InstallApp(BaseApp, InstallSettingsMixin, InstallSummarizerMixin, ConfigGe
             self.printDescription([
                 f"Unknown catalog {self.getParam('mas_catalog_version')}, please manually select the version of Cloud Pak for Data to use"
             ])
-            self.promptForString("Cloud Pak for Data product version", "cpd_product_version", default="4.8.0")
+            self.promptForString("Cloud Pak for Data product version", "cpd_product_version", default="5.1.3")
             logger.debug(f"Using user-provided (prompt) CP4D product version: {self.getParam('cpd_product_version')}")
         else:
             logger.debug(f"Using user-provided (flags) CP4D product version: {self.getParam('cpd_product_version')}")
@@ -379,6 +443,9 @@ class InstallApp(BaseApp, InstallSettingsMixin, InstallSummarizerMixin, ConfigGe
         ])
         self.promptForString("Workspace name", "mas_workspace_name", validator=WorkspaceNameFormatValidator())
 
+        if self.slsMode == 2 and not self.getParam("sls_namespace"):
+            self.setParam("sls_namespace", f"mas-{self.getParam('mas_instance_id')}-sls")
+
         self.configOperationMode()
         self.configCATrust()
         self.configDNSAndCerts()
@@ -555,13 +622,27 @@ class InstallApp(BaseApp, InstallSettingsMixin, InstallSummarizerMixin, ConfigGe
         if self.installMonitor:
             self.configAppChannel("monitor")
 
-        self.installManage = self.yesOrNo("Install Manage")
+        self.manageAppName = "Manage"
+        self.isManageFoundation = False
+        self.installManage = self.yesOrNo(f"Install {self.manageAppName}")
+
+        # If the selection was to not install manage but we are in mas_channel 9.1 or later, we need to set self.isManageFoundation to True
+        # Also, we need to force self.installManage to be True because Manage must always be installed in MAS 9.1 or later
+        if not self.installManage:
+            if not self.getParam("mas_channel").startswith("8.") and not self.getParam("mas_channel").startswith("9.0"):
+                self.installManage = True
+                self.isManageFoundation = True
+                self.setParam("is_full_manage", "false")
+                self.setParam("mas_app_settings_aio_flag", "false")
+                self.manageAppName = "Manage foundation"
+                self.printDescription([f"{self.manageAppName} installs the following capabilities: User, Security groups, Application configurator and Mobile configurator."])
+        else:
+            self.setParam("is_full_manage", "true")
 
         if self.installManage:
             self.configAppChannel("manage")
 
-        # Predict for MAS 8.10 is effectively unsupported now, because it has not shipped support for Cloud Pak for Data 4.8 as of June 2023 catalog update
-        if self.installIoT and self.installManage and self.getParam("mas_channel") != "8.10.x":
+        if self.installIoT and self.installManage:
             self.installPredict = self.yesOrNo("Install Predict")
         else:
             self.installPredict = False
@@ -570,7 +651,7 @@ class InstallApp(BaseApp, InstallSettingsMixin, InstallSummarizerMixin, ConfigGe
             self.configAppChannel("predict")
 
         # Assist is only installable on MAS 9.0.x due to withdrawal of support for Watson Discovery in our managed dependency stack and the inability of Assist 8.x to support this
-        if not self.getParam("mas_channel").startswith("8."):
+        if isVersionEqualOrAfter('9.0.0', self.getParam("mas_channel")):
             self.installAssist = self.yesOrNo("Install Assist")
             if self.installAssist:
                 self.configAppChannel("assist")
@@ -585,9 +666,12 @@ class InstallApp(BaseApp, InstallSettingsMixin, InstallSummarizerMixin, ConfigGe
         if self.installInspection:
             self.configAppChannel("visualinspection")
 
-        self.installAiBroker = self.yesOrNo("Install AI Broker")
-        if self.installAiBroker:
-            self.configAppChannel("aibroker")
+        if isVersionEqualOrAfter('9.1.0', self.getParam("mas_channel")) and self.getParam("mas_channel") != '9.1.x-feature':
+            self.installFacilities = self.yesOrNo("Install Real Estate and Facilities")
+            if self.installFacilities:
+                self.configAppChannel("facilities")
+        else:
+            self.installFacilities = False
 
     @logMethodCall
     def configAppChannel(self, appId):
@@ -651,21 +735,23 @@ class InstallApp(BaseApp, InstallSettingsMixin, InstallSummarizerMixin, ConfigGe
     def optimizerSettings(self) -> None:
         if self.installOptimizer:
             self.printH1("Configure Maximo Optimizer")
-            self.printDescription(["Customize your Optimizer installation, 'full' and 'limited' install plans are available, refer to the product documentation for more information"])
-
-            self.promptForString("Plan [full/limited]", "mas_app_plan_optimizer", default="full", validator=OptimizerInstallPlanValidator())
+            if self.isSNO():
+                self.printDescription(["Using Optimizer 'limited' plan as it is being installed in a single node cluster"])
+                self.setParam("mas_app_plan_optimizer", "limited")
+            else:
+                self.printDescription(["Customize your Optimizer installation, 'full' and 'limited' install plans are available, refer to the product documentation for more information"])
+                self.promptForString("Plan [full/limited]", "mas_app_plan_optimizer", default="full", validator=OptimizerInstallPlanValidator())
 
     @logMethodCall
     def predictSettings(self) -> None:
         if self.showAdvancedOptions and self.installPredict:
             self.printH1("Configure Maximo Predict")
             self.printDescription([
-                "Predict application supports integration with IBM SPSS and Watson Openscale which are optional services installed on top of IBM Cloud Pak for Data",
+                "Predict application supports integration with IBM SPSS which is an optional service installed on top of IBM Cloud Pak for Data",
                 "Unless requested these will not be installed"
             ])
             self.configCP4D()
             self.yesOrNo("Install IBM SPSS Statistics", "cpd_install_spss")
-            self.yesOrNo("Install Watson OpenScale", "cpd_install_openscale")
 
     @logMethodCall
     def assistSettings(self) -> None:
@@ -680,6 +766,81 @@ class InstallApp(BaseApp, InstallSettingsMixin, InstallSummarizerMixin, ConfigGe
                 self.promptForString("IBM Cloud API Key", "cos_apikey", isPassword=True)
                 self.promptForString("IBM Cloud Resource Group", "cos_resourcegroup")
 
+    @logMethodCall
+    def facilitiesSettings(self) -> None:
+        if self.installFacilities:
+            self.printH1("Configure Maximo Real Estate and Facilities")
+            self.printDescription([
+                "Real Estate and Facilities custom configurations"
+            ])
+            self.printDescription([
+                "Maximo Real Estate and Facilities Size:",
+                "  1. Small",
+                "  2. Medium",
+                "  3. Large"
+            ])
+            self.promptForListSelect("Select the size:", ["small", "medium", "large"], "mas_ws_facilities_size")
+
+            if self.showAdvancedOptions:
+                self.printH2("Maximo Real Estate and Facilities Settings - Advanced")
+                self.printDescription([
+                    "Advanced configurations for Real Estate and Facilities are added through an additional file called facilities-configs.yaml"
+                ])
+                if self.yesOrNo("Supply extra XML tags for Real Estate and Facilities server.xml"):
+                    self.promptForString("Real Estate and Facilities Liberty Extension Secret Name", "mas_ws_facilities_liberty_extension_XML")
+                if self.yesOrNo("Supply custom AES Encryption Password"):
+                    self.promptForString("Real Estate and Facilities AES Vault Secret Name", "mas_ws_facilities_vault_secret")
+
+                self.promptForString("Set Real Estate and Facilities Routes Timeout:", "mas_ws_facilities_routes_timeout", default="600s")
+                self.promptForInt("Set Facilities maximum connection poll size:", "mas_ws_facilities_db_maxconnpoolsize", default=200)
+
+                self.printDescription(["Real Estate and Facilities Persistent Volume Storage Configuration"])
+                defaultStorageClasses = getDefaultStorageClasses(self.dynamicClient)
+                notUseAutodetectedStorageClasses = False
+                if defaultStorageClasses.provider is not None:
+                    self.storageClassProvider = defaultStorageClasses.provider
+                    print_formatted_text(HTML(f"<MediumSeaGreen>Storage provider auto-detected: {defaultStorageClasses.providerName}</MediumSeaGreen>"))
+                    print_formatted_text(HTML(f"<LightSlateGrey>  - Storage class (ReadWriteMany): {defaultStorageClasses.rwx}</LightSlateGrey>"))
+                    print_formatted_text(HTML(f"<LightSlateGrey>  - Storage class (ReadWriteOnce): {defaultStorageClasses.rwo}</LightSlateGrey>"))
+                    if self.yesOrNo("Use the auto-detected storage classes"):
+                        self.printDescription([
+                            "Storage Mode for Userfiles PVC:",
+                            "  1. ReadWriteMany",
+                            "  2. ReadWriteOnce"
+                        ])
+                        storageMode = self.promptForListSelect("Select the storage mode for user files PVC:", ["ReadWriteMany", "ReadWriteOnce"], "mas_ws_facilities_storage_userfiles_mode", default=1)
+                        _ = self.setParam("mas_ws_facilities_storage_userfiles_class", defaultStorageClasses.rwx) if storageMode == "ReadWriteMany" else self.setParam("mas_ws_facilities_storage_userfiles_class", defaultStorageClasses.rwo)
+                        self.promptForInt("User file PVC size (Gb):", "mas_ws_facilities_storage_userfiles_size", default=50)
+                        storageMode = self.promptForListSelect("Select the storage mode for log PVC:", ["ReadWriteMany", "ReadWriteOnce"], "mas_ws_facilities_storage_log_mode", default=1)
+                        _ = self.setParam("mas_ws_facilities_storage_log_class", defaultStorageClasses.rwx) if storageMode == "ReadWriteMany" else self.setParam("mas_ws_facilities_storage_log_class", defaultStorageClasses.rwo)
+                        self.promptForInt("Log PVC size (Gb):", "mas_ws_facilities_storage_log_size", default=30)
+                    else:
+                        notUseAutodetectedStorageClasses = True
+                if defaultStorageClasses.provider is None or notUseAutodetectedStorageClasses:
+                    for storageClass in getStorageClasses(self.dynamicClient):
+                        print_formatted_text(HTML(f"<LightSlateGrey>  - {storageClass.metadata.name}</LightSlateGrey>"))
+                    self.promptForString("Select storage class for user files PVC:", "mas_ws_facilities_storage_userfiles_class")
+                    self.promptForString("Select storage class for log PVC:", "mas_ws_facilities_storage_log_class")
+                    self.printDescription([
+                        "Storage Mode for Userfiles PVC:",
+                        "  1. ReadWriteMany",
+                        "  2. ReadWriteOnce"
+                    ])
+                    self.promptForListSelect("Select the storage mode for user files PVC:", ["ReadWriteMany", "ReadWriteOnce"], "mas_ws_facilities_storage_userfiles_mode", default=1)
+                    self.promptForListSelect("Select the storage mode for log PVC:", ["ReadWriteMany", "ReadWriteOnce"], "mas_ws_facilities_storage_log_mode", default=1)
+                    self.promptForInt("User file PVC size (Gb):", "mas_ws_facilities_storage_userfiles_size", default=50)
+                    self.promptForInt("Log PVC size (Gb):", "mas_ws_facilities_storage_log_size", default=30)
+
+                if self.yesOrNo("Supply configuration for dedicated workflow agents"):
+                    print_formatted_text(HTML("<LightSlateGrey> Example: '[{\"name\":\"dwfa1\",\"members\":[{\"name\": \"u1\", \"class\": \"user\"}]}, {\"name\":\"dwfa2\",\"members\":[{\"name\": \"u2\", \"class\": \"user\"},{\"name\":\"g1\", \"class\":\"group\"}]}]' </LightSlateGrey>"))
+                    self.promptForString("Dedicated Workflow Agent JSON:", "mas_ws_facilities_dwfagents", validator=JsonValidator())
+
+                # If advanced options is selected, we need to create a file to add props not supported by Tekton
+                self.selectLocalConfigDir()
+                facilitiesConfigsPath = path.join(self.localConfigDir, "facilities-configs.yaml")
+                self.generateFacilitiesCfg(destination=facilitiesConfigsPath)
+                self.setParam("mas_ws_facilities_config_file", "/workspace/configs/facilities-configs.yaml")
+
     @logMethodCall
     def chooseInstallFlavour(self) -> None:
         self.printH1("Choose Install Mode")
@@ -695,8 +856,9 @@ class InstallApp(BaseApp, InstallSettingsMixin, InstallSummarizerMixin, ConfigGe
             " - Customize Maximo Manage database settings (schema, tablespace, indexspace)",
             " - Customize Maximo Manage server bundle configuration (defaults to \"all\" configuration)",
             " - Enable optional Maximo Manage integration Cognos Analytics and Watson Studio Local",
-            " - Enable optional Maximo Predict integration with SPSS and Watson OpenScale",
+            " - Enable optional Maximo Predict integration with SPSS",
             " - Enable optional IBM Turbonomic integration",
+            " - Enable optional Real Estate and Facilities configurations",
             " - Customize Db2 node affinity and tolerations, memory, cpu, and storage settings (when using the IBM Db2 Universal Operator)",
             " - Choose alternative Apache Kafka providers (default to Strimzi)",
             " - Customize Grafana storage settings"
@@ -727,6 +889,7 @@ class InstallApp(BaseApp, InstallSettingsMixin, InstallSummarizerMixin, ConfigGe
 
         # Licensing (SLS and DRO)
         self.configSLS()
+        self.configDRO()
         self.configICRCredentials()
 
         # MAS Core
@@ -741,7 +904,7 @@ class InstallApp(BaseApp, InstallSettingsMixin, InstallSummarizerMixin, ConfigGe
         self.optimizerSettings()
         self.predictSettings()
         self.assistSettings()
-        self.aibrokerSettings()
+        self.facilitiesSettings()
 
         # Dependencies
         self.configMongoDb()
@@ -771,10 +934,11 @@ class InstallApp(BaseApp, InstallSettingsMixin, InstallSummarizerMixin, ConfigGe
         self.installPredict = False
         self.installInspection = False
         self.installOptimizer = False
-        self.installAiBroker = False
+        self.installFacilities = False
         self.deployCP4D = False
         self.db2SetAffinity = False
         self.db2SetTolerations = False
+        self.slsLicenseFileLocal = None
 
         self.approvals = {
             "approval_core": {"id": "suite-verify"},  # After Core Platform verification has completed
@@ -784,10 +948,13 @@ class InstallApp(BaseApp, InstallSettingsMixin, InstallSummarizerMixin, ConfigGe
             "approval_monitor": {"id": "app-cfg-monitor"},  # After Monitor workspace has been configured
             "approval_optimizer": {"id": "app-cfg-optimizer"},  # After Optimizer workspace has been configured
             "approval_predict": {"id": "app-cfg-predict"},  # After Predict workspace has been configured
-            "approval_visualinspection": {"id": "app-cfg-visualinspection"}  # After Visual Inspection workspace has been configured
+            "approval_visualinspection": {"id": "app-cfg-visualinspection"},  # After Visual Inspection workspace has been configured
+            "approval_facilities": {"id": "app-cfg-facilities"},  # After Facilities workspace has been configured 
         }
 
         self.configGrafana()
+        self.configSNO()
+        self.setDB2DefaultSettings()
 
         for key, value in vars(self.args).items():
             # These fields we just pass straight through to the parameters and fail if they are not set
@@ -865,10 +1032,6 @@ class InstallApp(BaseApp, InstallSettingsMixin, InstallSummarizerMixin, ConfigGe
                 if value is not None and value != "":
                     self.setParam("mas_app_channel_visualinspection", value)
                     self.installInspection = True
-            elif key == "aibroker_channel":
-                if value is not None and value != "":
-                    self.setParam("mas_app_channel_aibroker", value)
-                    self.installAiBroker = True
             elif key == "optimizer_channel":
                 if value is not None and value != "":
                     self.setParam("mas_app_channel_optimizer", value)
@@ -876,6 +1039,10 @@ class InstallApp(BaseApp, InstallSettingsMixin, InstallSummarizerMixin, ConfigGe
             elif key == "optimizer_plan":
                 if value is not None and value != "":
                     self.setParam("mas_app_plan_optimizer", value)
+            elif key == "facilities_channel":
+                if value is not None and value != "":
+                    self.setParam("mas_app_channel_facilities", value)
+                    self.installFacilities = True
 
             # Manage advanced settings that need extra processing
             elif key == "mas_app_settings_server_bundle_size":
@@ -884,6 +1051,21 @@ class InstallApp(BaseApp, InstallSettingsMixin, InstallSummarizerMixin, ConfigGe
                     if value in ["jms", "snojms"]:
                         self.setParam("mas_app_settings_persistent_volumes_flag", "true")
 
+            # MongoDB
+            elif key == "mongodb_namespace":
+                if value is not None and value != "":
+                    self.setParam(key, value)
+                    self.setParam("sls_mongodb_cfg_file", f"/workspace/configs/mongo-{value}.yml")
+
+            # SLS
+            elif key == "license_file":
+                if value is not None and value != "":
+                    self.slsLicenseFileLocal = value
+                    self.setParam("sls_action", "install")
+            elif key == "dedicated_sls":
+                if value:
+                    self.setParam("sls_namespace", f"mas-{self.args.mas_instance_id}-sls")
+
             # These settings are used by the CLI rather than passed to the PipelineRun
             elif key == "storage_accessmode":
                 if value is None:
@@ -893,10 +1075,6 @@ class InstallApp(BaseApp, InstallSettingsMixin, InstallSummarizerMixin, ConfigGe
                 if value is None:
                     self.fatalError(f"{key} must be set")
                 self.pipelineStorageClass = value
-            elif key == "license_file":
-                if value is None:
-                    self.fatalError(f"{key} must be set")
-                self.slsLicenseFileLocal = value
 
             elif key.startswith("approval_"):
                 if key not in self.approvals:
@@ -904,16 +1082,15 @@ class InstallApp(BaseApp, InstallSettingsMixin, InstallSummarizerMixin, ConfigGe
 
                 if value != "":
                     valueParts = value.split(":")
-                    if len(valueParts) != 4:
-                        self.fatalError(f"Unsupported format for {key} ({value}).  Expected APPROVAL_KEY:MAX_RETRIES:RETRY_DELAY:IGNORE_FAILURE")
+                    if len(valueParts) != 3:
+                        self.fatalError(f"Unsupported format for {key} ({value}).  Expected MAX_RETRIES:RETRY_DELAY:IGNORE_FAILURE")
                     else:
                         try:
-                            self.approvals[key]["approvalKey"] = valueParts[0]
-                            self.approvals[key]["maxRetries"] = int(valueParts[1])
-                            self.approvals[key]["retryDelay"] = int(valueParts[2])
-                            self.approvals[key]["ignoreFailure"] = bool(valueParts[3])
+                            self.approvals[key]["maxRetries"] = int(valueParts[0])
+                            self.approvals[key]["retryDelay"] = int(valueParts[1])
+                            self.approvals[key]["ignoreFailure"] = bool(valueParts[2])
                         except ValueError:
-                            self.fatalError(f"Unsupported format for {key} ({value}).  Expected string:int:int:boolean")
+                            self.fatalError(f"Unsupported format for {key} ({value}).  Expected int:int:boolean")
 
             # Arguments that we don't need to do anything with
             elif key in ["accept_license", "dev_mode", "skip_pre_check", "skip_grafana_install", "no_confirm", "no_wait_for_pvc", "help", "advanced", "simplified"]:
@@ -927,14 +1104,40 @@ class InstallApp(BaseApp, InstallSettingsMixin, InstallSummarizerMixin, ConfigGe
                     self.setParam("mas_manual_cert_mgmt", False)
                     self.manualCertsDir = None
 
+            elif key == "enable_ipv6":
+                self.setParam("enable_ipv6", True)
+
             # Fail if there's any arguments we don't know how to handle
             else:
                 print(f"Unknown option: {key} {value}")
                 self.fatalError(f"Unknown option: {key} {value}")
 
+        if self.installManage:
+            # If Manage is being installed and --is-full-manage was set to something different than "false", assume it is "true"
+            if self.getParam("is_full_manage") != "false":
+                self.setParam("is_full_manage", "true")
+
+            # Configure Storage and Access mode
+            self.manageStorageAndAccessMode()
+
+        if self.installFacilities:
+            # Verifiy if any of the props that needs to be in a file are given
+            if self.getParam("mas_ws_facilities_storage_log_size") != "" or self.getParam("mas_ws_facilities_storage_userfiles_size") != "" or self.getParam("mas_ws_facilities_db_maxconnpoolsize") or self.getParam("mas_ws_facilities_dwfagents"):
+                self.selectLocalConfigDir()
+                facilitiesConfigsPath = path.join(self.localConfigDir, "facilities-configs.yaml")
+                self.generateFacilitiesCfg(destination=facilitiesConfigsPath)
+                self.setParam("mas_ws_facilities_config_map_name", "facilities-config")
+
         # Load the catalog information
         self.chosenCatalog = getCatalog(self.getParam("mas_catalog_version"))
 
+        # License file is only optional for existing SLS instance
+        if self.slsLicenseFileLocal is None:
+            if findSLSByNamespace(self.getParam("sls_namespace"), dynClient=self.dynamicClient):
+                self.setParam("sls_action", "gencfg")
+            else:
+                self.fatalError("--license-file must be set for new SLS install")
+
         # Once we've processed the inputs, we should validate the catalog source & prompt to accept the license terms
         if not self.devMode:
             self.validateCatalogSource()
@@ -958,6 +1161,10 @@ class InstallApp(BaseApp, InstallSettingsMixin, InstallSummarizerMixin, ConfigGe
         self.devMode = args.dev_mode
         self.skipGrafanaInstall = args.skip_grafana_install
 
+        # Set image_pull_policy of the CLI in interactive mode
+        if args.image_pull_policy and args.image_pull_policy != "":
+            self.setParam("image_pull_policy", args.image_pull_policy)
+
         self.approvals = {}
 
         # Store all args
@@ -979,6 +1186,10 @@ class InstallApp(BaseApp, InstallSettingsMixin, InstallSummarizerMixin, ConfigGe
             print_formatted_text(HTML("<Red>Error: The Kubernetes dynamic Client is not available.  See log file for details</Red>"))
             exit(1)
 
+        # Perform a check whether the cluster is set up for airgap install, this will trigger an early failure if the cluster is using the now
+        # deprecated MaximoApplicationSuite ImageContentSourcePolicy instead of the new ImageDigestMirrorSet
+        self.isAirgap()
+
         # Configure the installOptions for the appropriate architecture
         self.catalogOptions = supportedCatalogs[self.architecture]
 
@@ -1001,15 +1212,19 @@ class InstallApp(BaseApp, InstallSettingsMixin, InstallSummarizerMixin, ConfigGe
         if self.deployCP4D:
             self.configCP4D()
 
-        # The entitlement file for SLS is mounted as a secret in /workspace/entitlement
-        entitlementFileBaseName = path.basename(self.slsLicenseFileLocal)
-        self.setParam("sls_entitlement_file", f"/workspace/entitlement/{entitlementFileBaseName}")
-
-        # Set up the secrets for additional configs, podtemplates and manual certificates
+        # Set up the secrets for additional configs, podtemplates, sls license file and manual certificates
         self.additionalConfigs()
         self.podTemplates()
+        self.slsLicenseFile()
         self.manualCertificates()
 
+        if not self.noConfirm and not self.waitForPVC:
+            self.printDescription(["If you are using storage classes that utilize 'WaitForFirstConsumer' binding mode choose 'No' at the prompt below"])
+            self.waitForPVC = self.yesOrNo("Wait for PVCs to bind")
+
+        if not self.waitForPVC:
+            self.setParam("no_wait_for_pvc", True)
+
         # Show a summary of the installation configuration
         self.printH1("Non-Interactive Install Command")
         self.printDescription([
@@ -1037,12 +1252,6 @@ class InstallApp(BaseApp, InstallSettingsMixin, InstallSummarizerMixin, ConfigGe
             self.printH1("Launch Install")
             pipelinesNamespace = f"mas-{self.getParam('mas_instance_id')}-pipelines"
 
-            if not self.noConfirm:
-                self.printDescription(["If you are using storage classes that utilize 'WaitForFirstConsumer' binding mode choose 'No' at the prompt below"])
-                wait = self.yesOrNo("Wait for PVCs to bind")
-            else:
-                wait = False
-
             with Halo(text='Validating OpenShift Pipelines installation', spinner=self.spinner) as h:
                 installOpenShiftPipelines(self.dynamicClient)
                 h.stop_and_persist(symbol=self.successIcon, text="OpenShift Pipelines Operator is installed and ready to use")
@@ -1054,12 +1263,13 @@ class InstallApp(BaseApp, InstallSettingsMixin, InstallSummarizerMixin, ConfigGe
                     instanceId=self.getParam("mas_instance_id"),
                     storageClass=self.pipelineStorageClass,
                     accessMode=self.pipelineStorageAccessMode,
-                    waitForBind=wait
+                    waitForBind=self.waitForPVC,
+                    configureRBAC=(self.getParam("service_account_name") == "")
                 )
                 prepareInstallSecrets(
                     dynClient=self.dynamicClient,
                     instanceId=self.getParam("mas_instance_id"),
-                    slsLicenseFile=self.slsLicenseFileLocal,
+                    slsLicenseFile=self.slsLicenseFileSecret,
                     additionalConfigs=self.additionalConfigsSecret,
                     podTemplates=self.podTemplatesSecret,
                     certs=self.certsSecret
@@ -1094,11 +1304,11 @@ class InstallApp(BaseApp, InstallSettingsMixin, InstallSummarizerMixin, ConfigGe
          - present with the chosen state field initialized to ""
         """
         for approval in self.approvals.values():
-            if "approvalKey" in approval:
+            if "maxRetries" in approval:
                 # Enable this approval workload
-                logger.debug(f"Approval workflow for {approval['id']} will be enabled during install ({approval['maxRetries']} / {approval['retryDelay']}s / {approval['approvalKey']} / {approval['ignoreFailure']})")
-                self.initializeApprovalConfigMap(namespace, approval['id'], approval['approvalKey'], approval['maxRetries'], approval['retryDelay'], approval['ignoreFailure'])
+                logger.debug(f"Approval workflow for {approval['id']} will be enabled during install ({approval['maxRetries']} / {approval['retryDelay']}s / {approval['ignoreFailure']})")
+                self.initializeApprovalConfigMap(namespace, approval['id'], True, approval['maxRetries'], approval['retryDelay'], approval['ignoreFailure'])
             else:
                 # Disable this approval workload
                 logger.debug(f"Approval workflow for {approval['id']} will be disabled during install")
-                self.initializeApprovalConfigMap(namespace, approval['id'])
+                self.initializeApprovalConfigMap(namespace, approval['id'], False)