mas-cli 9.5.0__py3-none-any.whl → 10.0.1__py3-none-any.whl

mas/cli/install/settings/__init__.py

@@ -0,0 +1,21 @@
+# *****************************************************************************
+# 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 .db2Settings import Db2SettingsMixin
+from .kafkaSettings import KafkaSettingsMixin
+from .manageSettings import ManageSettingsMixin
+from .turbonomicSettings import TurbonomicSettingsMixin
+from .additionalConfigs import AdditionalConfigsMixin
+
+class InstallSettingsMixin(Db2SettingsMixin, KafkaSettingsMixin, ManageSettingsMixin, TurbonomicSettingsMixin, AdditionalConfigsMixin):
+  """
+  This class collects all the Mixins providing interactive prompts for mas-install
+  """
+  pass

mas/cli/install/settings/additionalConfigs.py

@@ -0,0 +1,150 @@
+# *****************************************************************************
+# 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 base64 import b64encode
+from glob import glob
+from prompt_toolkit import print_formatted_text
+
+import logging
+logger = logging.getLogger(__name__)
+
+class AdditionalConfigsMixin():
+    def additionalConfigs(self) -> None:
+        if self.interactiveMode:
+            self.printH1("Additional Configuration")
+            self.printDescription([
+                "Additional resource definitions can be applied to the OpenShift Cluster during the MAS configuration step",
+                "The primary purpose of this is to apply configuration for Maximo Application Suite itself, but you can use this to deploy ANY additional resource into your cluster"
+            ])
+
+            # If the user already set up BYO MongoDb or Kafka then they have already chosen to use additional configs
+            if self.localConfigDir is None:
+                if self.yesOrNo("Use additional configurations"):
+                    self.selectLocalConfigDir()
+
+        # If we've set up a local config directory then provide details about what's included in it
+        # and generate the secret that will be used in the pipeline
+        if self.localConfigDir is not None:
+            # Get list of files in localConfigDir
+            configFilesPath = rf'{self.localConfigDir}/*.yaml'
+            configFiles = glob(configFilesPath)
+            if len(configFiles) == 0:
+                self.fatalError(f"No configuration files (*.yaml) were found in {self.localConfigDir}")
+
+            print_formatted_text("The following additional configurations will be applied:")
+            for cf in configFiles:
+                print_formatted_text(f" - {path.basename(cf)}")
+
+            if not self.noConfirm:
+                if not self.yesOrNo("Are these the correct configuration files to apply"):
+                    print_formatted_text("Additional configuration files were not confirmed.  Aborting installation")
+                    exit(0)
+
+            # Generate the secret and apply it to the cluster
+            secret = {
+                "apiVersion": "v1",
+                "kind": "Secret",
+                "type": "Opaque",
+                "metadata": {
+                    "name": "pipeline-additional-configs"
+                }
+            }
+            additionalConfigsSecret = self.addFilesToSecret(secret, self.localConfigDir, "yaml")
+            logger.debug(additionalConfigsSecret)
+            self.additionalConfigsSecret = additionalConfigsSecret
+
+    def podTemplates(self) -> None:
+        if self.interactiveMode:
+            self.printH1("Configure Pod Templates")
+            self.printDescription([
+                "The CLI supports two pod template profiles out of the box that allow you to reconfigure MAS for either a guaranteed or best effort QoS level",
+                "For more information about the Kubernetes quality of service (QoS) levels, see https://kubernetes.io/docs/concepts/workloads/pods/pod-qos/",
+                "You may also choose to use your own customized pod template definitions",
+                ""
+            ])
+
+            if not self.yesOrNo("Use pod templates"):
+                return
+
+            self.printDescription([
+                "Make a selection from the list below:",
+                "",
+                "1. Guaranteed QoS",
+                "2. Best Effort QoS",
+                "3. Custom",
+                ""
+            ])
+
+            podTemplateChoice = self.promptForInt("Select pod templates profile")
+
+            if podTemplateChoice == 1:
+                self.setParam("mas_pod_templates_dir", path.join(self.templatesDir, "pod-templates", "guaranteed"))
+            elif podTemplateChoice == 2:
+                self.setParam("mas_pod_templates_dir", path.join(self.templatesDir, "pod-templates", "best-effort"))
+            elif podTemplateChoice == 3:
+                self.promptForDir("Pod templates directory", "mas_pod_templates_dir", mustExist=True)
+            else:
+                self.fatalError(f"Invalid selection: {podTemplateChoice}")
+
+        if self.getParam("mas_pod_templates_dir") != "":
+            templateFilesPath = rf'{self.getParam("mas_pod_templates_dir")}/*.yml'
+            templateFiles = glob(templateFilesPath)
+            if len(templateFiles) == 0:
+                self.fatalError(f"No pod templates (*.yml) were found in {self.getParam('mas_pod_templates_dir')}")
+
+            print_formatted_text("The following pod templates will be applied:")
+            for tf in templateFiles:
+                print_formatted_text(f" - {path.basename(tf)}")
+
+            if not self.noConfirm:
+                if not self.yesOrNo("Are these the correct pod templates to apply"):
+                    print_formatted_text("Pod templates were not confirmed.  Aborting installation")
+                    exit(0)
+
+            # Generate the secret and apply it to the cluster
+            secret = {
+                "apiVersion": "v1",
+                "kind": "Secret",
+                "type": "Opaque",
+                "metadata": {
+                    "name": "pipeline-pod-templates"
+                }
+            }
+            podTemplatesSecret = self.addFilesToSecret(secret, self.getParam("mas_pod_templates_dir"), "yml")
+            logger.debug(podTemplatesSecret)
+            self.podTemplatesSecret = podTemplatesSecret
+
+    def addFilesToSecret(self, secretDict: dict, configPath: str, extension: str) -> dict:
+        """
+        Add file (or files) to pipeline-additional-configs
+        """
+        filesToProcess = []
+        if path.isdir(configPath):
+            logger.debug(f"Adding all config files in directory {configPath}")
+            filesToProcess = glob(f"{configPath}/*.{extension}")
+        else:
+            logger.debug(f"Adding config file {configPath}")
+            filesToProcess = [configPath]
+
+        for fileToProcess in filesToProcess:
+            logger.debug(f" * Processing config file {fileToProcess}")
+            fileName = path.basename(fileToProcess)
+
+            # Load the file
+            with open(fileToProcess, 'r') as file:
+                data = file.read()
+
+            # Add/update an entry to the secret data
+            if "data" not in secretDict:
+                secretDict["data"] = {}
+            secretDict["data"][fileName] = b64encode(data.encode('ascii')).decode("ascii")
+
+        return secretDict

mas/cli/install/settings/db2Settings.py

@@ -0,0 +1,173 @@
+# *****************************************************************************
+# 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():
+    def configDb2(self) -> None:
+        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 not self.installIoT and not self.installManage:
+            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")
+            return
+
+        self.printDescription([
+            "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, Manage, Monitor, & Predict) or you may choose to configure MAS to use an existing database"
+        ])
+
+        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"
+
+            # Also reduce the CPU requests
+            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")
+
+        instanceId = self.getParam('mas_instance_id')
+        # Do we need to set up an IoT database?
+        if self.installIoT:
+            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"
+            ])
+            if self.yesOrNo("Create system Db2 instance using the IBM Db2 Universal Operator"):
+                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:
+            self.printH2("Database Configuration for Maximo Manage")
+            self.printDescription([
+                "Maximo Manage 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
+            if self.installIoT and self.yesOrNo("Re-use System Db2 instance for Manage application"):
+                # 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")
+                if self.yesOrNo("Create manage dedicated Db2 instance using the IBM Db2 Universal Operator"):
+                    self.setParam("db2_action_manage", "install")
+                    self.printDescription([
+                        "Available Db2 instance types for Manage:",
+                        "  1. DB2 Warehouse (Default option)",
+                        "  2. DB2 Online Transactional Processing (OLTP)"
+                    ])
+                    self.promptForListSelect(message="Select the Manage dedicated DB2 instance type", options=["db2wh", "db2oltp"], param="db2oltp", default="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 Manage database configuration file in {jdbcCfgFile} ...")
+                    if path.exists(jdbcCfgFile):
+                        if self.yesOrNo(f"Manage 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 Manage 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 configure Db2u?
+        if self.getParam("db2_action_system")  == "install" or self.getParam("db2_action_manage") == "install":
+            self.printH2("Installation Namespace")
+            self.promptForString("Install namespace", "db2_namespace", default="db2u")
+
+            # Node Affinity & Tolerations
+            # -------------------------------------------------------------------------
+            self.printH2("Node Affinity and Tolerations")
+            self.printDescription([
+                "Note that the same settings are applied to both the IoT and Manage 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:",
+                " - <u>https://docs.openshift.com/container-platform/4.12/nodes/scheduling/nodes-scheduler-node-affinity.html</u>",
+                " - <u>https://docs.openshift.com/container-platform/4.12/nodes/scheduling/nodes-scheduler-taints-tolerations.html</u>"
+            ])
+
+            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([
+                "Note that the same settings are applied to both the IoT and Manage 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([
+                "Note that the same settings are applied to both the IoT and Manage 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"))

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")
+
+                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")
+
+                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",
+                        ""
+                    ])
+                    self.promptForString("Install namespace", "kafka_namespace", default="strimzi")
+                    self.promptForString("Kafka version", "kafka_version", default="3.7.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.5.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: https://docs.aws.amazon.com/vpc/latest/userguide/subnet-sizing.html",
+                        ""
+                    ])
+                    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")