mas-cli 5.1.4__py3-none-any.whl

mas/cli/install/settings/db2Settings.py

@@ -0,0 +1,252 @@
+# *****************************************************************************
+# Copyright (c) 2024 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
+#
+# *****************************************************************************
+
+from os import path
+from prompt_toolkit import print_formatted_text
+
+
+class Db2SettingsMixin():
+    # In silentMode, no prompts will show up for "happy path" DB2 configuration scenarios. Prompts will still show up when an input is absolutely required
+    # Settings under showAdvancedOptions are always prompted
+    def configDb2(self, silentMode=False) -> None:
+        if not silentMode:
+            self.printH1("Configure Databases")
+        # The channel used for Db2 used has not changed since the January 2024 catalog update
+        self.params["db2_channel"] = "v110509.0"
+
+        # If neither Iot, Manage or Facilities is being installed, we have nothing to do
+        if not self.installIoT and not self.installManage and not self.installFacilities:
+            print_formatted_text("No applications have been selected that require a Db2 installation")
+            self.setParam("db2_action_system", "none")
+            self.setParam("db2_action_manage", "none")
+            self.setParam("db2_action_facilities", "none")
+            return
+
+        # For now we are limiting users to bring your own database for Manage on s390x & ppc64le
+        # Eventually we will be able to remove this clause and allow the standard logic to work for s390x, ppc64le and amd64
+        if (self.architecture == "s390x" or self.architecture == "ppc64le") and self.installManage:
+            # silentMode does not apply for s390x/ppc64le because it requires interaction when selecting local config directory
+            self.printDescription([
+                "Installation of a Db2 instance using the IBM Db2 Universal Operator is not currently supported on s390x /ppc64le, please provide configuration details for the database you wish to use.",
+            ])
+            instanceId = self.getParam('mas_instance_id')
+            workspaceId = self.getParam("mas_workspace_id")
+
+            self.setParam("mas_appws_bindings_jdbc_manage", "workspace-application")
+            self.setParam("db2_action_manage", "byo")
+            self.selectLocalConfigDir()
+
+            # Check if a configuration already exists before creating a new one
+            jdbcCfgFile = path.join(self.localConfigDir, f"jdbc-{instanceId}-manage.yaml")
+            print_formatted_text(f"Searching for {self.manageAppName} database configuration file in {jdbcCfgFile} ...")
+            if path.exists(jdbcCfgFile):
+                if self.yesOrNo(f"{self.manageAppName} database configuration file 'jdbc-{instanceId}-manage.yaml' already exists.  Do you want to generate a new one"):
+                    self.generateJDBCCfg(instanceId=instanceId, scope="workspace-application", workspaceId=workspaceId, appId="manage", destination=jdbcCfgFile)
+            else:
+                print_formatted_text(f"Expected file ({jdbcCfgFile}) was not found, generating a valid {self.manageAppName} database configuration file now ...")
+                self.generateJDBCCfg(instanceId=instanceId, scope="workspace-application", workspaceId=workspaceId, appId="manage", destination=jdbcCfgFile)
+            return
+
+        # Proceed as normal
+        # We know we are installing either IoT, Manage or Facilities, and on amd64 target architecture
+        if not silentMode:
+            self.printDescription([
+                f"The installer can setup one or more IBM Db2 instances in your OpenShift cluster for the use of applications that require a JDBC datasource (IoT, {self.manageAppName}, Monitor, & Predict, Real Estate and Facilities) or you may choose to configure MAS to use an existing database"
+            ])
+
+        self.setDB2DefaultSettings()
+
+        instanceId = self.getParam('mas_instance_id')
+        # Do we need to set up an IoT database?
+        if self.installIoT:
+            if not silentMode:
+                self.printH2("Database Configuration for Maximo IoT")
+                self.printDescription([
+                    "Maximo IoT requires a shared system-scope Db2 instance because others application in the suite require access to the same database source",
+                    " - Only IBM Db2 is supported for this database"
+                ])
+            createSystemDb2UsingUniversalOperator = True
+            if not silentMode:
+                createSystemDb2UsingUniversalOperator = self.yesOrNo("Create system Db2 instance using the IBM Db2 Universal Operator")
+            if createSystemDb2UsingUniversalOperator:
+                self.setParam("db2_action_system", "install")
+            else:
+                self.setParam("db2_action_system", "byo")
+
+                self.selectLocalConfigDir()
+
+                # Check if a configuration already exists before creating a new one
+                jdbcCfgFile = path.join(self.localConfigDir, f"jdbc-{instanceId}-system.yaml")
+                print_formatted_text(f"Searching for system database configuration file in {jdbcCfgFile} ...")
+                if path.exists(jdbcCfgFile):
+                    if self.yesOrNo(f"System database configuration file 'jdbc-{instanceId}-system.yaml' already exists.  Do you want to generate a new one"):
+                        self.generateJDBCCfg(instanceId=instanceId, scope="system", destination=jdbcCfgFile)
+                else:
+                    print_formatted_text(f"Expected file ({jdbcCfgFile}) was not found, generating a valid system database configuration file now ...")
+                    self.generateJDBCCfg(instanceId=instanceId, scope="system", destination=jdbcCfgFile)
+        else:
+            self.setParam("db2_action_system", "none")
+
+        if self.installManage:
+            if not silentMode:
+                self.printH2(f"Database Configuration for Maximo {self.manageAppName}")
+                self.printDescription([
+                    f"Maximo {self.manageAppName} can be configured to share the system Db2 instance or use it's own dedicated database:",
+                    " - Use of a shared instance has a significant footprint reduction but is only recommended for development/test/demo installs",
+                    " - In most production systems you will want to use a dedicated database",
+                    " - IBM Db2, Oracle Database, & Microsoft SQL Server are all supported database options"
+                ])
+            # Determine whether to use the system or a dedicated database
+            reuseSystemDb2 = False
+            if self.installIoT:
+                if not silentMode:
+                    reuseSystemDb2 = self.yesOrNo(f"Re-use System Db2 instance for {self.manageAppName} application")
+            if reuseSystemDb2:
+                # We are going to bind Manage to the system database, which has already been set up in the previous step
+                self.setParam("mas_appws_bindings_jdbc_manage", "system")
+                self.setParam("db2_action_manage", "none")
+            else:
+                self.setParam("mas_appws_bindings_jdbc_manage", "workspace-application")
+                createSystemDb2UsingUniversalOperator = True
+                if not silentMode:
+                    createSystemDb2UsingUniversalOperator = self.yesOrNo(f"Create {self.manageAppName} dedicated Db2 instance using the IBM Db2 Universal Operator")
+                if createSystemDb2UsingUniversalOperator:
+                    self.setParam("db2_action_manage", "install")
+                    if not silentMode:
+                        self.printDescription([
+                            f"Available Db2 instance types for {self.manageAppName}:",
+                            "  1. DB2 Warehouse (Default option)",
+                            "  2. DB2 Online Transactional Processing (OLTP)"
+                        ])
+                        self.promptForListSelect(message=f"Select the {self.manageAppName} dedicated DB2 instance type", options=["db2wh", "db2oltp"], param="db2_type", default="1")
+                    else:
+                        self.setParam("db2_type", "db2wh")
+                else:
+                    workspaceId = self.getParam("mas_workspace_id")
+                    self.setParam("db2_action_manage", "byo")
+
+                    self.selectLocalConfigDir()
+
+                    # Check if a configuration already exists before creating a new one
+                    jdbcCfgFile = path.join(self.localConfigDir, f"jdbc-{instanceId}-manage.yaml")
+                    print_formatted_text(f"Searching for {self.manageAppName} database configuration file in {jdbcCfgFile} ...")
+                    if path.exists(jdbcCfgFile):
+                        if self.yesOrNo(f"{self.manageAppName} database configuration file 'jdbc-{instanceId}-manage.yaml' already exists.  Do you want to generate a new one"):
+                            self.generateJDBCCfg(instanceId=instanceId, scope="workspace-application", workspaceId=workspaceId, appId="manage", destination=jdbcCfgFile)
+                    else:
+                        print_formatted_text(f"Expected file ({jdbcCfgFile}) was not found, generating a valid {self.manageAppName} database configuration file now ...")
+                        self.generateJDBCCfg(instanceId=instanceId, scope="workspace-application", workspaceId=workspaceId, appId="manage", destination=jdbcCfgFile)
+        else:
+            self.setParam("db2_action_manage", "none")
+
+        # Do we need to create and configure a Db2 for Facilities ?
+        if self.installFacilities:
+            self.printH2("Database Configuration for Maximo Real Estate and Facilities")
+            if self.yesOrNo("Create Real Estate and Facilities dedicated Db2 instance using the IBM Db2 Universal Operator"):
+                self.setParam("db2_action_facilities", "install")
+            else:
+                self.setParam("db2_action_facilities", "none")
+                instanceId = self.getParam('mas_instance_id')
+                workspaceId = self.getParam("mas_workspace_id")
+                self.selectLocalConfigDir()
+
+                # Check if a configuration already exists before creating a new one
+                jdbcCfgFile = path.join(self.localConfigDir, f"jdbc-{instanceId}-facilities.yaml")
+                print_formatted_text(f"Searching for Real Estate and Facilities database configuration file in {jdbcCfgFile} ...")
+                if path.exists(jdbcCfgFile):
+                    if self.yesOrNo(f"Real Estate and Facilities database configuration file 'jdbc-{instanceId}-facilities.yaml' already exists.  Do you want to generate a new one"):
+                        self.generateJDBCCfg(instanceId=instanceId, scope="workspace-application", workspaceId=workspaceId, appId="facilities", destination=jdbcCfgFile)
+                else:
+                    print_formatted_text(f"Expected file ({jdbcCfgFile}) was not found, generating a valid Real Estate and Facilities database configuration file now ...")
+                    self.generateJDBCCfg(instanceId=instanceId, scope="workspace-application", workspaceId=workspaceId, appId="facilities", destination=jdbcCfgFile)
+        else:
+            self.setParam("db2_action_facilities", "none")
+
+        # Do we need to configure Db2u?
+        if self.getParam("db2_action_system") == "install" or self.getParam("db2_action_manage") == "install" or self.getParam("db2_action_facilities") == "install":
+            if self.showAdvancedOptions:
+                self.printH2("Installation Namespace")
+                self.promptForString("Install namespace", "db2_namespace", default="db2u")
+
+                # Node Affinity & Tolerations
+                # -------------------------------------------------------------------------
+                self.printH2("Node Affinity and Tolerations")
+                self.printDescription([
+                    f"Note that the same settings are applied to both the IoT and {self.manageAppName} Db2 instances",
+                    "Use existing node labels and taints to control scheduling of the Db2 workload in your cluster",
+                    "For more information refer to the Red Hat documentation:",
+                    " - <Orange><u>https://docs.openshift.com/container-platform/4.18/nodes/scheduling/nodes-scheduler-node-affinity.html</u></Orange>",
+                    " - <Orange><u>https://docs.openshift.com/container-platform/4.18/nodes/scheduling/nodes-scheduler-taints-tolerations.html</u></Orange>",
+                    " - <Orange><u>https://docs.openshift.com/container-platform/4.17/nodes/scheduling/nodes-scheduler-node-affinity.html</u></Orange>",
+                    " - <Orange><u>https://docs.openshift.com/container-platform/4.17/nodes/scheduling/nodes-scheduler-taints-tolerations.html</u></Orange>"
+                ])
+
+                if self.yesOrNo("Configure node affinity"):
+                    self.promptForString(" + Key", "db2_affinity_key")
+                    self.promptForString(" + Value", "db2_affinity_value")
+
+                if self.yesOrNo("Configure node tolerations"):
+                    self.promptForString(" + Key", "db2_tolerate_key")
+                    self.promptForString(" + Value", "db2_tolerate_value")
+                    self.promptForString(" + Effect", "db2_tolerate_effect")
+
+                self.printH2("Database CPU & Memory")
+                self.printDescription([
+                    f"Note that the same settings are applied to both the IoT and {self.manageAppName} Db2 instances"
+                ])
+
+                if self.yesOrNo("Customize CPU and memory request/limit"):
+                    self.promptForString(" + CPU Request", "db2_cpu_requests", default=self.getParam("db2_cpu_requests"))
+                    self.promptForString(" + CPU Limit", "db2_cpu_limits", default=self.getParam("db2_cpu_limits"))
+                    self.promptForString(" + Memory Request", "db2_memory_requests", default=self.getParam("db2_memory_requests"))
+                    self.promptForString(" + Memory Limit", "db2_memory_limits", default=self.getParam("db2_memory_limits"))
+
+                self.printH2("Database Storage Capacity")
+                self.printDescription([
+                    f"Note that the same settings are applied to both the IoT and {self.manageAppName} Db2 instances"
+                ])
+
+                if self.yesOrNo("Customize storage capacity"):
+                    self.promptForString(" + Data Volume", "db2_data_storage_size", default=self.getParam("db2_data_storage_size"))
+                    self.promptForString(" + Temporary Volume", "db2_temp_storage_size", default=self.getParam("db2_temp_storage_size"))
+                    self.promptForString(" + Metadata Volume", "db2_meta_storage_size", default=self.getParam("db2_meta_storage_size"))
+                    self.promptForString(" + Transaction Logs Volume", "db2_logs_storage_size", default=self.getParam("db2_logs_storage_size"))
+                    self.promptForString(" + Backup Volume", "db2_backup_storage_size", default=self.getParam("db2_backup_storage_size"))
+            else:
+                self.setParam("db2_namespace", "db2u")
+
+    def setDB2DefaultSettings(self) -> None:
+
+        self.setParam("db2_cpu_requests", "4000m")
+        self.setParam("db2_cpu_limits", "6000m")
+        self.setParam("db2_memory_requests", "8Gi")
+        self.setParam("db2_memory_limits", "12Gi")
+
+        if self.isSNO():
+            # Set smaller defaults for SNO deployments
+            self.setParam("db2_meta_storage_size", "10Gi")
+            self.setParam("db2_backup_storage_size", "10Gi")
+            self.setParam("db2_logs_storage_size", "10Gi")
+            self.setParam("db2_temp_storage_size", "10Gi")
+            self.setParam("db2_data_storage_size", "20Gi")
+
+            # Configure the access mode to RWO
+            self.params["db2_meta_storage_accessmode"] = "ReadWriteOnce"
+            self.params["db2_backup_storage_accessmode"] = "ReadWriteOnce"
+            self.params["db2_logs_storage_accessmode"] = "ReadWriteOnce"
+            self.params["db2_data_storage_accessmode"] = "ReadWriteOnce"
+            self.params["db2_cpu_requests"] = "300m"
+
+        else:
+            self.setParam("db2_meta_storage_size", "20Gi")
+            self.setParam("db2_backup_storage_size", "100Gi")
+            self.setParam("db2_logs_storage_size", "100Gi")
+            self.setParam("db2_temp_storage_size", "100Gi")
+            self.setParam("db2_data_storage_size", "100Gi")

mas/cli/install/settings/kafkaSettings.py

@@ -0,0 +1,103 @@
+# *****************************************************************************
+# Copyright (c) 2024 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
+#
+# *****************************************************************************
+
+from os import path
+from prompt_toolkit import print_formatted_text
+
+
+class KafkaSettingsMixin():
+    def configKafka(self) -> None:
+        if self.installIoT:
+            self.printH1("Configure Kafka")
+            self.printDescription([
+                "Maximo IoT requires a shared system-scope Kafka instance",
+                "Supported Kafka providers: Strimzi, Red Hat AMQ Streams, IBM Cloud Event Streams and AWS MSK",
+                "You may also choose to configure MAS to use an existing Kafka instance by providing a pre-existing configuration file"
+            ])
+            if self.yesOrNo("Create system Kafka instance using one of the supported providers"):
+                self.setParam("kafka_action_system", "install")
+
+                if self.showAdvancedOptions:
+                    self.printDescription([
+                        "",
+                        "Kafka Provider:",
+                        "  1. Strimzi (opensource)",
+                        "  2. Red Hat AMQ Streams (requires a separate license)",
+                        "  3. IBM Cloud Event Streams (paid IBM Cloud service)",
+                        "  4. AWS MSK (paid AWS service)"
+                    ])
+                    self.promptForListSelect("Select Kafka provider", ["strimzi", "redhat", "ibm", "aws"], "kafka_provider")
+                else:
+                    self.setParam("kafka_provider", "strimzi")
+
+                if self.getParam("kafka_provider") == "strimzi":
+                    self.printDescription([
+                        "",
+                        "Strimzi: Cluster Version",
+                        "The version of the Strimzi operator available on your cluster will determine the supported versions of Kafka that can be deployed.",
+                        " - If you are using the latest available operator catalog then the default version below can be accepted",
+                        " - If you are using older operator catalogs (e.g. in a disconnected install) you should confirm the supported versions in your OperatorHub"
+                    ])
+                    if self.showAdvancedOptions:
+                        self.promptForString("Strimzi namespace", "kafka_namespace", default="strimzi")
+                    self.promptForString("Kafka version", "kafka_version", default="3.9.0")
+
+                elif self.getParam("kafka_provider") == "redhat":
+                    self.printDescription([
+                        "",
+                        "Red Hat AMQ Streams: Cluster Version",
+                        "The version of the Red Hat AMQ Streams operator available on your cluster will determine the supported versions of Kafka that can be deployed.",
+                        " - If you are using the latest available operator catalog then the default version below can be accepted",
+                        " - If you are using older operator catalogs (e.g. in a disconnected install) you should confirm the supported versions in your OperatorHub"
+                    ])
+                    self.promptForString("Install namespace", "kafka_namespace", default="amq-streams")
+                    self.promptForString("Kafka version", "kafka_version", default="3.8.0")
+
+                elif self.getParam("kafka_provider") == "ibm":
+                    print()
+                    self.promptForString("IBM Cloud API Key", "ibmcloud_apikey", isPassword=True)
+                    self.promptForString("IBM Event Streams resource group" "eventstreams_resourcegroup", default="Default")
+                    self.promptForString("IBM Event Streams instance name", "eventstreams_name", default=f"eventstreams-{self.getParam('mas_instance_id')}")
+                    self.promptForString("IBM Event Streams location", "eventstreams_location", default="us-east")
+
+                elif self.getParam("kafka_provider") == "aws":
+                    self.printDescription([
+                        "",
+                        "While provisioning the AWS MSK instance, you will be required to provide the AWS Virtual Private Cloud ID and subnet details",
+                        "where your instance will be deployed to properly configure inbound and outbound connectivity.",
+                        "You should be able to find these information inside your VPC and subnet configurations in the target AWS account.",
+                        "For more details about AWS subnet/CIDR configuration, refer: <Orange><u>https://docs.aws.amazon.com/vpc/latest/userguide/subnet-sizing.html</u></Orange>"
+                    ])
+                    self.promptForString("AWS Access Key ID", "aws_access_key_id", isPassword=True)
+                    self.promptForString("AWS Secret Access Key" "aws_secret_access_key", isPassword=True)
+                    self.promptForString("AWS Region", "aws_region", default="us-east-1")
+                    self.promptForString("Virtual Private Cloud (VPC) ID", "vpc_id")
+                    self.promptForString("MSK Instance Username", "aws_kafka_user_name", default="masuser")
+                    self.promptForString("MSK Instance Password", "aws_kafka_user_password", isPassword=True)
+                    self.promptForString("MSK Instance Type", "aws_msk_instance_type", default="kafka.m5.large")
+                    self.promptForString("MSK Total Number of Broker Nodes", "aws_msk_instance_number", default="3")
+                    self.promptForString("MSK Storage Size (in GB)", "aws_msk_volume_size", defauklt="100")
+                    self.promptForString("Availability Zone 1 CIDR", "aws_msk_cidr_az1")
+                    self.promptForString("Availability Zone 2 CIDR", "aws_msk_cidr_az2")
+                    self.promptForString("Availability Zone 3 CIDR", "aws_msk_cidr_az3")
+                    self.promptForString("Ingress CIDR", "aws_msk_ingress_cidr")
+                    self.promptForString("Egress CIDR", "aws_msk_egress_cidr")
+            else:
+                self.setParam("kafka_action_system", "byo")
+                self.selectLocalConfigDir()
+                instanceId = self.getParam('mas_instance_id')
+
+                # Check if a configuration already exists
+                kafkaCfgFile = path.join(self.localConfigDir, f"kafka-{instanceId}-system.yaml")
+                print_formatted_text(f"Searching for system kafka configuration file in {kafkaCfgFile} ...")
+                if path.exists(kafkaCfgFile):
+                    print_formatted_text(f"Provided Kafka configuration file {kafkaCfgFile} will be applied")
+                else:
+                    self.fatalError(f"Kafka configuration file does not exist: '{kafkaCfgFile}'.  In order to continue, provide an existing Kafka configuration file or choose one of the supported Kafka providers to be installed")

mas/cli/install/settings/manageSettings.py

@@ -0,0 +1,273 @@
+# *****************************************************************************
+# Copyright (c) 2024 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
+#
+# *****************************************************************************
+
+import logging
+logger = logging.getLogger(__name__)
+
+
+class ManageSettingsMixin():
+
+    def arcgisSettings(self) -> None:
+        # If Spatial is selected, then prompt to choose to add IBM Maximo Location Services for Esri, and prompt license
+        if "spatial=" in self.getParam("mas_appws_components") and self.getParam("mas_app_channel_manage").startswith("9."):
+            self.printDescription([
+                "",
+                "Maximo Spatial requires a map server provider in order to enable geospatial capabilities",
+                "You may choose your preferred map provider later or you can enable IBM Maximo Location Services for Esri now",
+                f"This includes ArcGIS Enterprise as part of the {self.manageAppName} and Maximo Spatial bundle (Additional AppPoints required)."
+            ])
+
+            if self.yesOrNo("Include IBM Maximo Location Services for Esri"):
+                self.setParam("install_arcgis", "true")
+                self.setParam("mas_arcgis_channel", self.getParam("mas_app_channel_manage"))
+
+                self.printDescription([
+                    "",
+                    "IBM Maximo Location Services for Esri License Terms",
+                    "For information about your IBM Maximo Location Services for Esri License visit: ",
+                    " - <Orange><u>https://ibm.biz/MAXArcGIS90-License</u></Orange>",
+                    "To continue with the installation, you must accept these additional license terms"
+                ])
+
+                if not self.yesOrNo("Do you accept the license terms"):
+                    exit(1)
+
+    def manageSettings(self) -> None:
+        if self.installManage:
+            self.printH1(f"Configure Maximo {self.manageAppName}")
+            self.printDescription([f"Customize your {self.manageAppName} installation, refer to the product documentation for more information"])
+
+            self.manageSettingsComponents()
+            self.arcgisSettings()
+
+            self.manageSettingsServerBundleConfig()
+            self.manageSettingsJMS()
+            self.manageSettingsDatabase()
+            self.manageSettingsCustomizationArchive()
+            self.manageSettingsOther()
+            self.manageStorageAndAccessMode()
+
+    def manageStorageAndAccessMode(self) -> None:
+        # Default to RWX storage classes, but fall back to RWO in SNO or when user
+        # has chosen not to provide a RWX storage class
+        storageClass = self.getParam("storage_class_rwx")
+        accessMode = "ReadWriteMany"
+        if self.isSNO() or self.getParam("storage_class_rwx") == "none":
+            storageClass = self.getParam("storage_class_rwo")
+            accessMode = "ReadWriteOnce"
+
+        self.setParam("mas_app_settings_doclinks_pvc_storage_class", storageClass)
+        self.setParam("mas_app_settings_bim_pvc_storage_class", storageClass)
+        self.setParam("mas_app_settings_jms_queue_pvc_storage_class", storageClass)
+
+        self.setParam("mas_app_settings_doclinks_pvc_accessmode", accessMode)
+        self.setParam("mas_app_settings_bim_pvc_accessmode", accessMode)
+        self.setParam("mas_app_settings_jms_queue_pvc_accessmode", accessMode)
+
+    def manageSettingsComponents(self) -> None:
+        # Only ask to install Manage components if this is a full Manage installation
+        # If this is a Manage Foundation installation, leave mas_appws_components blank
+        if self.isManageFoundation:
+            self.params["mas_appws_components"] = ""
+        else:
+            self.printH2(f"Maximo {self.manageAppName} Components")
+            self.printDescription([f"The default configuration will install {self.manageAppName} with Health enabled, alternatively choose exactly what industry solutions and add-ons will be configured"])
+
+            self.params["mas_appws_components"] = "base=latest,health=latest"
+            if self.yesOrNo("Select components to enable"):
+                self.params["mas_appws_components"] = "base=latest"
+                if self.yesOrNo(" - Asset Configuration Manager"):
+                    self.params["mas_appws_components"] += ",acm=latest"
+                if self.yesOrNo(" - Aviation"):
+                    self.params["mas_appws_components"] += ",aviation=latest"
+                if self.yesOrNo(" - Civil Infrastructure"):
+                    self.params["mas_appws_components"] += ",civil=latest"
+                if self.yesOrNo(" - Envizi"):
+                    self.params["mas_appws_components"] += ",envizi=latest"
+                if self.yesOrNo(" - Health"):
+                    self.params["mas_appws_components"] += ",health=latest"
+                if self.yesOrNo(" - Health, Safety and Environment"):
+                    self.params["mas_appws_components"] += ",hse=latest"
+                if self.yesOrNo(" - Maximo IT"):
+                    self.params["mas_appws_components"] += ",icd=latest"
+                if self.yesOrNo(" - Nuclear"):
+                    self.params["mas_appws_components"] += ",nuclear=latest"
+                if self.yesOrNo(" - Oil & Gas"):
+                    self.params["mas_appws_components"] += ",oilandgas=latest"
+                if self.yesOrNo(" - Connector for Oracle Applications"):
+                    self.params["mas_appws_components"] += ",oracleadapter=latest"
+                if self.yesOrNo(" - Connector for SAP Application"):
+                    self.params["mas_appws_components"] += ",sapadapter=latest"
+                if self.yesOrNo(" - Service Provider"):
+                    self.params["mas_appws_components"] += ",serviceprovider=latest"
+                if self.yesOrNo(" - Spatial"):
+                    self.params["mas_appws_components"] += ",spatial=latest"
+                if self.yesOrNo(" - Strategize"):
+                    self.params["mas_appws_components"] += ",strategize=latest"
+                if self.yesOrNo(" - Transportation"):
+                    self.params["mas_appws_components"] += ",transportation=latest"
+                if self.yesOrNo(" - Tririga"):
+                    self.params["mas_appws_components"] += ",tririga=latest"
+                if self.yesOrNo(" - Utilities"):
+                    self.params["mas_appws_components"] += ",utilities=latest"
+                if self.yesOrNo(" - Workday Applications"):
+                    self.params["mas_appws_components"] += ",workday=latest"
+                if self.yesOrNo(" - AIP"):
+                    self.params["mas_appws_components"] += ",aip=latest"
+                logger.debug(f"Generated mas_appws_components = {self.params['mas_appws_components']}")
+
+                if ",icd=" in self.params["mas_appws_components"]:
+                    self.printH2("Maximo IT License Terms")
+                    self.printDescription([
+                        "For information about your Maximo IT License, see <Orange><u>https://ibm.biz/MAXIT81-License</u></Orange>",
+                        "To continue with the installation, you must accept these additional license terms"
+                    ])
+
+                    if not self.yesOrNo("Do you accept the license terms"):
+                        exit(1)
+
+    def manageSettingsDatabase(self) -> None:
+        if self.showAdvancedOptions:
+            self.printH2(f"Maximo {self.manageAppName} Settings - Database")
+            self.printDescription([f"Customise the schema, tablespace, indexspace, and encryption settings used by {self.manageAppName}"])
+
+            if self.yesOrNo("Customize database settings"):
+                self.promptForString("Schema", "mas_app_settings_db2_schema", default="maximo")
+                self.promptForString("Tablespace", "mas_app_settings_tablespace", default="MAXDATA")
+                self.promptForString("Indexspace", "mas_app_settings_indexspace", default="MAXINDEX")
+
+                if self.yesOrNo("Customize database encryption settings"):
+                    self.promptForString("MXE_SECURITY_CRYPTO_KEY", "mas_app_settings_crypto_key")
+                    self.promptForString("MXE_SECURITY_CRYPTOX_KEY", "mas_app_settings_cryptox_key")
+                    self.promptForString("MXE_SECURITY_OLD_CRYPTO_KEY", "mas_app_settings_old_crypto_key")
+                    self.promptForString("MXE_SECURITY_OLD_CRYPTOX_KEY", "mas_app_settings_old_cryptox_key")
+                    self.yesOrNo("Override database encryption secrets with provided keys", "mas_app_settings_override_encryption_secrets_flag")
+
+    def manageSettingsServerBundleConfig(self) -> None:
+        if not self.isManageFoundation:
+            if self.showAdvancedOptions:
+                self.printH2(f"Maximo {self.manageAppName} Settings - Server Bundles")
+                self.printDescription([
+                    f"Define how you want to configure {self.manageAppName} servers:",
+                    f" - You can have one or multiple {self.manageAppName} servers distributing workload",
+                    " - Additionally, you can choose to include JMS server for messaging queues",
+                    "",
+                    "Configurations:",
+                    "  1. Deploy the 'all' server pod only (workload is concentrated in just one server pod but consumes less resource)",
+                    "  2. Deploy the 'all' and 'jms' bundle pods (workload is concentrated in just one server pod and includes jms server)"
+                ])
+
+                if not self.isSNO():
+                    self.printDescription([
+                        "  3. Deploy the 'mea', 'report', 'ui' and 'cron' bundle pods (workload is distributed across multiple server pods)",
+                        "  4. Deploy the 'mea', 'report', 'ui', 'cron' and 'jms' bundle pods (workload is distributed across multiple server pods and includes jms server)"
+                    ])
+
+                manageServerBundleSelection = self.promptForString("Select a server bundle configuration")
+
+                if manageServerBundleSelection == "1":
+                    self.setParam("mas_app_settings_server_bundles_size", "dev")
+                elif manageServerBundleSelection == "2":
+                    self.setParam("mas_app_settings_server_bundles_size", "snojms")
+                    self.setParam("mas_app_settings_persistent_volumes_flag", "true")
+                elif manageServerBundleSelection == "3":
+                    self.setParam("mas_app_settings_server_bundles_size", "small")
+                elif manageServerBundleSelection == "4":
+                    self.setParam("mas_app_settings_server_bundles_size", "jms")
+                    self.setParam("mas_app_settings_persistent_volumes_flag", "true")
+                else:
+                    self.fatalError("Invalid selection")
+            else:
+                self.setParam("mas_app_settings_server_bundles_size", "dev")
+
+    def manageSettingsJMS(self) -> None:
+        if self.getParam("mas_app_settings_server_bundles_size") in ["jms", "snojms"]:
+            self.printDescription([
+                f"Only {self.manageAppName} JMS sequential queues (sqin and sqout) are enabled by default.",
+                "However, you can enable both sequential (sqin and sqout) and continuous queues (cqin and cqout)"
+            ])
+
+            self.yesOrNo(f"Enable both {self.manageAppName} JMS sequential and continuous queues", "mas_app_settings_default_jms")
+
+    def manageSettingsCustomizationArchive(self) -> None:
+        # Only ask about customization archive in full Manage installation
+        if not self.isManageFoundation:
+            self.printH2(f"Maximo {self.manageAppName} Settings - Customization")
+            self.printDescription([
+                f"Provide a customization archive to be used in the {self.manageAppName} build process"
+            ])
+
+            if self.yesOrNo("Include customization archive"):
+                self.promptForString("Customization archive name", "mas_app_settings_customization_archive_name")
+                self.promptForString("Customization archive path/url", "mas_app_settings_customization_archive_url")
+                if self.yesOrNo("Provide authentication to access customization archive URL"):
+                    self.promptForString("Username", "mas_app_settings_customization_archive_username")
+                    self.promptForString("Password", "mas_app_settings_customization_archive_password", isPassword=True)  # pragma: allowlist secret
+
+    def manageSettingsDemodata(self) -> None:
+        self.yesOrNo("Create demo data", "mas_app_settings_demodata")
+
+    def manageSettingsTimezone(self) -> None:
+        self.promptForString(f"{self.manageAppName} server timezone", "mas_app_settings_server_timezone", default="GMT")
+        # Set Manage dedicated Db2 instance timezone to be same as Manage server timezone
+        self.setParam("db2_timezone", self.getParam("mas_app_settings_server_timezone"))
+
+    def manageSettingsLanguages(self) -> None:
+        self.printH2(f"Maximo {self.manageAppName} Settings - Languages")
+        self.printDescription([
+            f"Define the base language for Maximo {self.manageAppName}"
+        ])
+        self.promptForString("Base language", "mas_app_settings_base_lang", default="EN")
+
+        self.printDescription([
+            f"Define the additional languages to be configured in Maximo {self.manageAppName}. provide a comma-separated list of supported languages codes, for example: 'JA,DE,AR'",
+            "A complete list of available language codes is available online:",
+            "    <Orange><u>https://www.ibm.com/docs/en/mas-cd/mhmpmh-and-p-u/continuous-delivery?topic=deploy-language-support</u></Orange>"
+        ])
+
+        self.promptForString("Secondary languages", "mas_app_settings_secondary_langs")
+
+    def manageSettingsCP4D(self) -> None:
+        if self.getParam("mas_app_channel_manage") in ["8.7.x", "9.0.x"] and self.showAdvancedOptions:
+            self.printDescription([
+                f"Integration with Cognos Analytics provides additional support for reporting features in Maximo {self.manageAppName}, for more information refer to the documentation online: ",
+                " - <Orange><u>https://ibm.biz/BdMuxs</u></Orange>"
+            ])
+            self.yesOrNo("Enable integration with Cognos Analytics", "cpd_install_cognos")
+            self.yesOrNo("Enable integration with Watson Studio Local", "mas_appws_bindings_health_flag")
+
+            if self.getParam("cpd_install_cognos") == "true" or self.getParam("mas_appws_bindings_health_flag") == "true":
+                self.configCP4D()
+
+    def manageSettingsOther(self) -> None:
+        self.printH2(f"Maximo {self.manageAppName} Settings - Other")
+        if self.isManageFoundation:
+            self.printDescription([
+                "Configure additional settings:",
+                "  - Base and additional languages",
+                "  - Server timezone"
+            ])
+            if self.yesOrNo("Configure Additional Settings"):
+                self.manageSettingsTimezone()
+                self.manageSettingsLanguages()
+        else:
+            self.printDescription([
+                "Configure additional settings:",
+                "  - Demo data",
+                "  - Base and additional languages",
+                "  - Server timezone",
+                "  - Cognos integration (install Cloud Pak for Data)",
+                "  - Watson Studio Local integration (install Cloud Pak for Data)"
+            ])
+            if self.yesOrNo("Configure Additional Settings"):
+                self.manageSettingsDemodata()
+                self.manageSettingsTimezone()
+                self.manageSettingsLanguages()
+                self.manageSettingsCP4D()