Exemplo n.º 1
0
    def main(self,argv):
        methodName = "main"
        self.rc = 0
        try:
            beginTime = Utilities.currentTimeMillis()
            cmdLineArgs = Utilities.getInputArgs(self.ArgsSignature,argv[1:])
            trace, logFile = self._configureTraceAndLogging(cmdLineArgs)
            self.region = cmdLineArgs.get('region')
            if (logFile):
                TR.appendTraceLog(logFile)   
            if (trace):
                TR.info(methodName,"Tracing with specification: '%s' to log file: '%s'" % (trace,logFile))

            logFilePath = os.path.join(self.logsHome,"icp4i_install.log")
    
            with open(logFilePath,"a+") as icp4iInstallLogFile:
                self.stackId = cmdLineArgs.get('stackid')
                self.stackName = cmdLineArgs.get('stack-name')
                self.amiID = environ.get('AMI_ID')
                self.cp4iSecret = environ.get('CP4I_SECRET')
                self.ocpSecret = environ.get('OCP_SECRET')
                self.pnSecret = environ.get('PN_SECRET')
                # self.cp4ibucketName = environ.get('ICP4IArchiveBucket')
                self.ICP4IInstallationCompletedURL = environ.get('ICP4IInstallationCompletedURL')
                TR.info(methodName, "amiID %s "% self.amiID)
                # TR.info(methodName, "cp4ibucketName %s "% self.cp4ibucketName)
                TR.info(methodName, "ICP4IInstallationCompletedURL %s "% self.ICP4IInstallationCompletedURL)
                TR.info(methodName, "cp4iSecret %s "% self.cp4iSecret)
                TR.info(methodName, "ocpSecret %s "% self.ocpSecret)
                TR.info(methodName, "pnSecret %s "% self.pnSecret)
                self.__init(self.stackId,self.stackName, icp4iInstallLogFile)
                self.zones = Utilities.splitString(self.AvailabilityZones)
                TR.info(methodName," AZ values %s" % self.zones)

                TR.info(methodName,"RedhatPullSecret %s" %self.RedhatPullSecret)
                secret = self.RedhatPullSecret.split('/',1)
                TR.info(methodName,"Pull secret  %s" %secret)  
                self.pullSecret = "/ibm/pull-secret"
                s3_cp_cmd = "aws s3 cp "+self.RedhatPullSecret+" "+self.pullSecret
                TR.info(methodName,"s3 cp cmd %s"%s3_cp_cmd)
                call(s3_cp_cmd, shell=True,stdout=icp4iInstallLogFile)
                self.getSecret(icp4iInstallLogFile)
                
                ocpstart = Utilities.currentTimeMillis()
                self.installOCP(icp4iInstallLogFile)
                ocpend = Utilities.currentTimeMillis()
                self.printTime(ocpstart, ocpend, "Installing OCP")

                storagestart = Utilities.currentTimeMillis()
                self.installDedicatedOCS = Utilities.toBoolean(self.DedicatedOCS)
                self.configureOCS(icp4iInstallLogFile)
                storageend = Utilities.currentTimeMillis()
                self.printTime(storagestart, storageend, "Installing storage")

                if(self.password=="NotProvided"):
                    install_cp4i = ("sudo ./cp4i-deployment/cp4i-install.sh  -n " +  self.Namespace + " -k " + self.apiKey +
                                " -1 " + self.APILM + " -2 " + self.AIDB + " -3 " + self.AIDE + " -4 " + self.OD + " -5 " + self.AR +
                                " -6 " + self.MQ + " -7 " + self.ES + " -8 " + self.GW + " -9 " + self.HST + " | tee -a cp4i-logs.txt")
                else:
                    install_cp4i = ("sudo ./cp4i-deployment/cp4i-install.sh  -n " +  self.Namespace + " -k " + self.apiKey +
                                    " -1 " + self.APILM + " -2 " + self.AIDB + " -3 " + self.AIDE + " -4 " + self.OD + " -5 " + self.AR +
                                    " -6 " + self.MQ + " -7 " + self.ES + " -8 " + self.GW + " -9 " + self.HST + " -p " + self.password + " | tee -a cp4i-logs.txt")
                
                try:
                    process = Popen(install_cp4i,shell=True,stdout=icp4iInstallLogFile,stderr=icp4iInstallLogFile,close_fds=True)
                    stdoutdata,stderrdata=process.communicate()
                except CalledProcessError as e:
                    TR.error(methodName, "ERROR return code: %s, Exception: %s" % (e.returncode, e), e)
                    raise e    
                TR.info(methodName,"Installation of CP4I %s %s" %(stdoutdata,stderrdata))
                time.sleep(30)

                self.exportResults(self.stackName+"-OpenshiftURL", "https://"+self.openshiftURL, icp4iInstallLogFile)

                get_cp4i_route_cmd = "oc get route -n " + self.Namespace + " | grep 'navigator-pn' | awk '{print $2}'"
                TR.info(methodName, "Get CP4I URL")
                try:
                    self.cp4iURL = check_output(['bash','-c', get_cp4i_route_cmd])
                    TR.info(methodName, "CP4I URL retrieved %s"%self.cp4iURL)
                except CalledProcessError as e:
                    TR.error(methodName,"command '{}' return with error (code {}): {}".format(e.cmd, e.returncode, e.output))

                self.exportResults(self.stackName+"-CP4IURL", "https://"+self.cp4iURL, icp4iInstallLogFile)

                if(self.password=="NotProvided"):
                    get_cp4i_password_cmd = "oc get secrets -n ibm-common-services platform-auth-idp-credentials -ojsonpath='{.data.admin_password}' | base64 --decode && echo """
                    TR.info(methodName, "Get CP4I Password")
                    try:
                        self.cp4iPassword = check_output(['bash','-c', get_cp4i_password_cmd])
                        TR.info(methodName, "CP4I Password retrieved %s"%self.cp4iPassword)
                    except CalledProcessError as e:
                        TR.error(methodName,"command '{}' return with error (code {}): {}".format(e.cmd, e.returncode, e.output))
                else:
                    self.cp4iPassword = self.password

                self.updateSecret(icp4iInstallLogFile)
            #endWith    
            
        except Exception as e:
            TR.error(methodName,"Exception with message %s" %e)
            self.rc = 1
        finally:
            try:
            # Copy icpHome/logs to the S3 bucket for logs.
                self.logExporter.exportLogs("/var/log/")
                self.logExporter.exportLogs("/ibm/cp4i-linux-workspace/Logs")
                self.logExporter.exportLogs("%s" % self.logsHome)
            except Exception as  e:
                TR.error(methodName,"ERROR: %s" % e, e)
                self.rc = 1
            #endTry          
        endTime = Utilities.currentTimeMillis()
        elapsedTime = (endTime - beginTime)/1000
        etm, ets = divmod(elapsedTime,60)
        eth, etm = divmod(etm,60) 

        if (self.rc == 0):
            success = 'true'
            status = 'SUCCESS'
            TR.info(methodName,"SUCCESS END CP4I Install AWS ICP4I Quickstart.  Elapsed time (hh:mm:ss): %d:%02d:%02d" % (eth,etm,ets))
            # TODO update this later
            self.updateStatus(status)
        else:
            success = 'false'
            status = 'FAILURE: Check logs in S3 log bucket or on the Boot node EC2 instance in /ibm/logs/icp4i_install.log and /ibm/logs/post_install.log'
            TR.info(methodName,"FAILED END CP4I Install AWS ICP4I Quickstart.  Elapsed time (hh:mm:ss): %d:%02d:%02d" % (eth,etm,ets))
            # # TODO update this later
            self.updateStatus(status)
           
        #endIf 
        try:
            data = "%s: IBM Cloud Pak installation elapsed time: %d:%02d:%02d" % (status,eth,etm,ets)    
            check_call(['cfn-signal', 
                            '--success', success, 
                            '--id', self.stackId, 
                            '--reason', status, 
                            '--data', data, 
                            self.ICP4IInstallationCompletedURL
                            ])     
        except CalledProcessError as e:
            TR.error(methodName, "ERROR return code: %s, Exception: %s" % (e.returncode, e), e)
            raise e                                                
Exemplo n.º 2
0
    def main(self, argv):
        methodName = "main"
        self.rc = 0

        try:
            beginTime = Utilities.currentTimeMillis()

            self._loadConf()

            if (self.overall_log_file):
                TR.appendTraceLog(self.overall_log_file)

            logFilePath = os.path.join(self.logsHome, "icpd_install.log")

            with open(logFilePath, "a+") as icpdInstallLogFile:
                ocpstart = Utilities.currentTimeMillis()
                TR.info("debug",
                        "change_node_settings= %s" % self.change_node_settings)
                if (self.change_node_settings == "True"):
                    self.changeNodeSettings(icpdInstallLogFile)
                    TR.info("debug", "Finishd the node settings")
                    ocpend = Utilities.currentTimeMillis()
                    self.printTime(ocpstart, ocpend, "Chaning node settings")

                TR.info("debug",
                        "config_image_pull= %s" % self.config_image_pull)
                ocpstart = Utilities.currentTimeMillis()
                if (self.config_image_pull == "True"):
                    self.configImagePull(icpdInstallLogFile)
                    TR.info("debug", "Finishd the image pull configuration")
                    ocpend = Utilities.currentTimeMillis()
                    self.printTime(ocpstart, ocpend, "Configuring image pull")

                if (self.installOSWML == "True"):
                    self.installWML = "True"

                self.installCPD(icpdInstallLogFile)

                self.installStatus = "CPD Installation completed"
                TR.info("debug",
                        "Installation status - %s" % self.installStatus)
            #endWith

        except Exception as e:
            TR.error(methodName, "Exception with message %s" % e)
            self.rc = 1

        endTime = Utilities.currentTimeMillis()
        elapsedTime = (endTime - beginTime) / 1000
        etm, ets = divmod(elapsedTime, 60)
        eth, etm = divmod(etm, 60)

        if (self.rc == 0):
            success = 'true'
            status = 'SUCCESS'
            TR.info(
                methodName,
                "SUCCESS END CPD Quickstart.  Elapsed time (hh:mm:ss): %d:%02d:%02d"
                % (eth, etm, ets))
        else:
            success = 'false'
            status = 'FAILURE: Check logs on the Boot node in /ibm/logs/icpd_install.log and /ibm/logs/post_install.log'
            TR.info(
                methodName,
                "FAILED END CPD Quickstart.  Elapsed time (hh:mm:ss): %d:%02d:%02d"
                % (eth, etm, ets))
Exemplo n.º 3
0
    def main(self, argv):
        methodName = "main"
        self.rc = 0
        params = {}
        try:
            beginTime = Utilities.currentTimeMillis()
            cmdLineArgs = Utilities.getInputArgs(self.ArgsSignature, argv[1:])
            trace, logFile = self._configureTraceAndLogging(cmdLineArgs)
            self.region = cmdLineArgs.get('region')
            if (logFile):
                TR.appendTraceLog(logFile)
            if (trace):
                TR.info(
                    methodName,
                    "Tracing with specification: '%s' to log file: '%s'" %
                    (trace, logFile))

            logFilePath = os.path.join(self.logsHome, "icpd_install.log")

            with open(logFilePath, "a+") as icpdInstallLogFile:
                self.stackId = cmdLineArgs.get('stackid')
                self.stackName = cmdLineArgs.get('stack-name')
                self.cfnResource = boto3.resource('cloudformation',
                                                  region_name=self.region)
                self.cf = boto3.client('cloudformation',
                                       region_name=self.region)
                self.ec2 = boto3.resource('ec2', region_name=self.region)
                self.s3 = boto3.client('s3', region_name=self.region)
                self.elb = boto3.client('elb', region_name=self.region)
                self.secretsmanager = boto3.client('secretsmanager',
                                                   region_name=self.region)
                self.autoScaling = boto3.client('autoscaling',
                                                region_name=self.region)
                self.stackParameters = self.getStackParameters(self.stackId)
                self.stackParameterNames = self.stackParameters.keys()

                list = self.stackParameters.get(
                    "AnsibleAdditionalEnvironmentVariables").split(",")
                params.update((dict(item.split("=", 1) for item in list)))
                self.namespace = params.get('Namespace')
                self.cpdbucketName = params.get('ICPDArchiveBucket')
                self.ICPDInstallationCompletedURL = params.get(
                    'ICPDInstallationCompletedURL')
                self.installWKC = Utilities.toBoolean(params.get('WKC'))
                self.installWSL = Utilities.toBoolean(params.get('WSL'))
                self.installDV = Utilities.toBoolean(params.get('DV'))
                self.installWML = Utilities.toBoolean(params.get('WML'))
                self.installOSWML = Utilities.toBoolean(params.get('OSWML'))
                if (self.installOSWML):
                    self.installWML = True
                #endIf
                self.apikey = params.get('APIKey')
                TR.info(
                    methodName,
                    "Retrieve namespace value from Env Variables %s" %
                    self.namespace)
                self.logExporter = LogExporter(region=self.region,
                                               bucket=self.getOutputBucket(),
                                               keyPrefix='logs/%s' %
                                               self.stackName,
                                               fqdn=socket.getfqdn())
                self.configureEFS()
                self.getS3Object(bucket=self.cpdbucketName,
                                 s3Path="2.5/cpd-linux",
                                 destPath="/ibm/cpd-linux")
                os.chmod("/ibm/cpd-linux", stat.S_IEXEC)
                if not self.apikey:
                    TR.info(methodName, "Downloading repo.yaml from S3 bucket")
                    os.remove("/ibm/repo.yaml")
                    self.getS3Object(bucket=self.cpdbucketName,
                                     s3Path="2.5/repo.yaml",
                                     destPath="/ibm/repo.yaml")
                else:
                    TR.info(methodName,
                            "updating repo.yaml with apikey value provided")
                    self.updateTemplateFile('/ibm/repo.yaml', '<APIKEY>',
                                            self.apikey)
                self.installCPD(icpdInstallLogFile)
                self.validateInstall(icpdInstallLogFile)
                self.manageUser(icpdInstallLogFile)
                if not self.apikey:
                    self.activateLicense(icpdInstallLogFile)
            #endWith

        except Exception as e:
            TR.error(methodName, "Exception with message %s" % e)
            self.rc = 1
        finally:
            try:
                # Copy icpHome/logs to the S3 bucket for logs.
                self.logExporter.exportLogs("/var/log/")
                self.logExporter.exportLogs("/ibm/cpd-linux-workspace/Logs")
                self.logExporter.exportLogs("%s" % self.logsHome)
            except Exception as e:
                TR.error(methodName, "ERROR: %s" % e, e)
                self.rc = 1
            #endTry
        endTime = Utilities.currentTimeMillis()
        elapsedTime = (endTime - beginTime) / 1000
        etm, ets = divmod(elapsedTime, 60)
        eth, etm = divmod(etm, 60)

        if (self.rc == 0):
            success = 'true'
            status = 'SUCCESS'
            TR.info(
                methodName,
                "SUCCESS END CPD Install AWS ICPD Quickstart.  Elapsed time (hh:mm:ss): %d:%02d:%02d"
                % (eth, etm, ets))
            self.updateStatus(status)
            os.remove("/ibm/trial.lic")
            #os.remove("/ibm/repo.yaml")
        else:
            success = 'false'
            status = 'FAILURE: Check logs in S3 log bucket or on the AnsibleConfigServer node EC2 instance in /ibm/logs/icpd_install.log and /ibm/logs/post_install.log'
            TR.info(
                methodName,
                "FAILED END CPD Install AWS ICPD Quickstart.  Elapsed time (hh:mm:ss): %d:%02d:%02d"
                % (eth, etm, ets))
            self.updateStatus(status)
            os.remove("/ibm/trial.lic")
            #os.remove("/ibm/repo.yaml")
            #endIf
        try:
            data = "%s: IBM Cloud Pak installation elapsed time: %d:%02d:%02d" % (
                status, eth, etm, ets)
            check_call([
                'cfn-signal', '--success', success, '--id', self.stackId,
                '--reason', status, '--data', data,
                self.ICPDInstallationCompletedURL
            ])
        except CalledProcessError as e:
            TR.error(
                methodName,
                "ERROR return code: %s, Exception: %s" % (e.returncode, e), e)
            raise e
Exemplo n.º 4
0
    def installCPD(self, icpdInstallLogFile):
        """
        """

        methodName = "installCPD"

        #private_registry = self.image_registry_url
        offline_installation_dir = self.offline_dir_path

        self.logincmd = "oc login -u " + self.ocp_admin_user + " -p " + self.ocp_admin_password
        try:
            call(self.logincmd, shell=True, stdout=icpdInstallLogFile)
        except CalledProcessError as e:
            TR.error(
                methodName,
                "command '{}' return with error (code {}): {}".format(
                    e.cmd, e.returncode, e.output))

        TR.info(methodName, "oc login successfully")

        #Install Cloud Pak Foundation Service
        if (self.installFoundationalService == "True"):
            TR.info(methodName, "Start installing Foundational Service")

            bedrock_start = Utilities.currentTimeMillis()

            install_foundational_service_command = "./install_bedrock.sh " + offline_installation_dir + " " + self.FoundationalService_Case_Name + " " + self.image_registry_url + " " + self.foundation_service_namespace

            TR.info(
                methodName, "Install Foundational Service with command %s" %
                install_foundational_service_command)

            try:
                install_foundational_service_retcode = check_output(
                    ['bash', '-c', install_foundational_service_command])
            except CalledProcessError as e:
                TR.error(
                    methodName,
                    "command '{}' return with error (code {}): {}".format(
                        e.cmd, e.returncode, e.output))
                return
            TR.info(
                methodName,
                "Install Foundational Service with command %s returned %s" %
                (install_foundational_service_command,
                 install_foundational_service_retcode))

            bedrock_end = Utilities.currentTimeMillis()
            TR.info(methodName, "Install Foundational Service completed")
            self.printTime(bedrock_start, bedrock_end,
                           "Install Foundational Service")

        #Install Cloud Pak for Data Control Plane
        if (self.installCPDControlPlane == "True"):
            TR.info(methodName,
                    "Start installing Cloud Pak for Data Control Plane (Zen)")

            zen_core_metadb_storage_class = self.storage_class

            if (self.storage_type == "ocs"):
                zen_core_metadb_storage_class = "ocs-storagecluster-ceph-rbd"

            zen_start = Utilities.currentTimeMillis()

            install_control_plane_command = "./install_zen.sh " + offline_installation_dir + " " + self.CPDControlPlane_Case_Name + " " + self.image_registry_url + " " + self.foundation_service_namespace + " " + self.cpd_operator_namespace + " " + self.cpd_instance_namespace + " " + self.cpd_license + " " + self.storage_class + " " + self.storage_type

            TR.info(
                methodName, "Install Control Plane with command %s" %
                install_control_plane_command)

            try:
                install_control_plane_retcode = check_output(
                    ['bash', '-c', install_control_plane_command])
            except CalledProcessError as e:
                TR.error(
                    methodName,
                    "command '{}' return with error (code {}): {}".format(
                        e.cmd, e.returncode, e.output))
                return
            TR.info(
                methodName,
                "Install Control Plane with command %s returned %s" %
                (install_control_plane_command, install_control_plane_retcode))

            zen_end = Utilities.currentTimeMillis()
            TR.info(methodName, "Install Control Plane completed")
            self.printTime(zen_start, zen_end, "Install Control Plane")

            get_cpd_route_cmd = "oc get route -n " + self.cpd_instance_namespace + " | grep '" + self.cpd_instance_namespace + "' | awk '{print $2}'"
            TR.info(methodName, "Get CPD URL")
            try:
                self.cpdURL = check_output(['bash', '-c', get_cpd_route_cmd])
                TR.info(methodName, "CPD URL retrieved %s" % self.cpdURL)
            except CalledProcessError as e:
                TR.error(
                    methodName,
                    "command '{}' return with error (code {}): {}".format(
                        e.cmd, e.returncode, e.output))
                return

        if (self.installWSL == "True"):
            TR.info(methodName, "Start installing Watson Studio Local")

            wsl_start = Utilities.currentTimeMillis()

            install_wsl_command = "./install_wsl.sh " + offline_installation_dir + " " + self.WSL_Case_Name + " " + self.image_registry_url + " " + self.cpd_operator_namespace + " " + self.cpd_instance_namespace + " " + self.cpd_license + " " + self.storage_type + " " + self.storage_class

            TR.info(
                methodName,
                "Install Watson Studio with command %s" % install_wsl_command)

            try:
                install_wsl_retcode = check_output(
                    ['bash', '-c', install_wsl_command])
            except CalledProcessError as e:
                TR.error(
                    methodName,
                    "command '{}' return with error (code {}): {}".format(
                        e.cmd, e.returncode, e.output))

            TR.info(
                methodName,
                "Install Watson Studio with command %s returned %s" %
                (install_wsl_command, install_wsl_retcode))

            wsl_end = Utilities.currentTimeMillis()
            TR.info(methodName, "Install Watson Studio completed")
            self.printTime(wsl_start, wsl_end, "Install Watson Studio")

        if (self.installWML == "True"):
            TR.info(methodName, "Start installing Watson Machine Learning")
            wml_start = Utilities.currentTimeMillis()
            self.installCCSCatSrc(icpdInstallLogFile)

            install_wml_command = "./install_wml.sh " + offline_installation_dir + " " + self.WML_Case_Name + " " + self.image_registry_url + " " + self.cpd_operator_namespace + " " + self.cpd_instance_namespace + " " + self.cpd_license + " " + self.storage_type + " " + self.storage_class

            TR.info(
                methodName, "Install Watson Machine Learning with command %s" %
                install_wml_command)

            try:
                install_wml_retcode = check_output(
                    ['bash', '-c', install_wml_command])
            except CalledProcessError as e:
                TR.error(
                    methodName,
                    "command '{}' return with error (code {}): {}".format(
                        e.cmd, e.returncode, e.output))

            TR.info(
                methodName,
                "Install Watson Machine Learning with command %s returned %s" %
                (install_wml_command, install_wml_retcode))

            wml_end = Utilities.currentTimeMillis()
            TR.info(methodName, "Install Watson Machine Learning completed")
            self.printTime(wml_start, wml_end,
                           "Install Watson Machine Learning")

        if (self.installOSWML == "True"):
            TR.info(methodName, "Start installing Watson OpenScale")
            wos_start = Utilities.currentTimeMillis()

            install_wos_command = "./install_aiopenscale.sh " + offline_installation_dir + " " + self.WOS_Case_Name + " " + self.image_registry_url + " " + self.cpd_operator_namespace + " " + self.cpd_instance_namespace + " " + self.cpd_license + " " + self.storage_type + " " + self.storage_class

            TR.info(
                methodName, "Install Watson OpenScale with command %s" %
                install_wos_command)

            try:
                install_wos_retcode = check_output(
                    ['bash', '-c', install_wos_command])
            except CalledProcessError as e:
                TR.error(
                    methodName,
                    "command '{}' return with error (code {}): {}".format(
                        e.cmd, e.returncode, e.output))

            TR.info(
                methodName,
                "Install Watson OpenScale with command %s returned %s" %
                (install_wos_command, install_wos_retcode))

            wos_end = Utilities.currentTimeMillis()
            TR.info(methodName, "Install Watson OpenScale completed")
            self.printTime(wos_start, wos_end, "Install Watson OpenScale")

        if (self.installCDE == "True"):
            TR.info(methodName, "Start installing Cognos Dashboards")
            cde_start = Utilities.currentTimeMillis()
            self.installCCSCatSrc(icpdInstallLogFile)

            install_cde_command = "./install_cde.sh " + offline_installation_dir + " " + self.CDE_Case_Name + " " + self.image_registry_url + " " + self.cpd_operator_namespace + " " + self.cpd_instance_namespace + " " + self.cpd_license + " " + self.storage_type + " " + self.storage_class

            TR.info(
                methodName, "Install Cognos Dashboards with command %s" %
                install_cde_command)

            try:
                install_cde_retcode = check_output(
                    ['bash', '-c', install_cde_command])
            except CalledProcessError as e:
                TR.error(
                    methodName,
                    "command '{}' return with error (code {}): {}".format(
                        e.cmd, e.returncode, e.output))

            TR.info(
                methodName,
                "Install Cognos Dashboards with command %s returned %s" %
                (install_cde_command, install_cde_retcode))

            cde_end = Utilities.currentTimeMillis()
            TR.info(methodName, "Install Cognos Dashboards completed")
            self.printTime(cde_start, cde_end, "Install Cognos Dashboards")

        if (self.installRStudio == "True"):
            TR.info(methodName, "Start installing RStudio package")
            rstudiostart = Utilities.currentTimeMillis()
            if (self.installRStudio_load_from == "NA"):
                self.installAssembliesAirgap("rstudio", self.default_load_from,
                                             icpdInstallLogFile)
            else:
                self.installAssembliesAirgap("rstudio",
                                             self.installRStudio_load_from,
                                             icpdInstallLogFile)
            rstudioend = Utilities.currentTimeMillis()
            TR.info(methodName, "RStudio package installation completed")
            self.printTime(rstudiostart, rstudioend, "Installing RStudio")

        if (self.installSPSS == "True"):
            TR.info(methodName, "Start installing SPSS package")
            spssstart = Utilities.currentTimeMillis()
            if (self.installSPSS_load_from == "NA"):
                self.installAssembliesAirgap("spss-modeler",
                                             self.default_load_from,
                                             icpdInstallLogFile)
            else:
                self.installAssembliesAirgap("spss-modeler",
                                             self.installSPSS_load_from,
                                             icpdInstallLogFile)
            spssend = Utilities.currentTimeMillis()
            TR.info(methodName, "SPSS package installation completed")
            self.printTime(spssstart, spssend, "Installing SPSS")

        if (self.installSpark == "True"):
            TR.info(methodName, "Start installing Spark AE package")
            sparkstart = Utilities.currentTimeMillis()
            if (self.installSpark_load_from == "NA"):
                self.installAssembliesAirgap("spark", self.default_load_from,
                                             icpdInstallLogFile)
            else:
                self.installAssembliesAirgap("spark",
                                             self.installSpark_load_from,
                                             icpdInstallLogFile)
            sparkend = Utilities.currentTimeMillis()
            TR.info(methodName, "Spark AE  package installation completed")
            self.printTime(sparkstart, sparkend, "Installing Spark AE")

        if (self.installRuntimeGPUPy37 == "True"):
            TR.info(methodName, "Start installing GPUPy37 package")
            gpupy36start = Utilities.currentTimeMillis()
            if (self.installRuntimeGPUPy37_load_from == "NA"):
                self.installAssembliesAirgap("runtime-addon-py37gpu",
                                             self.default_load_from,
                                             icpdInstallLogFile)
            else:
                self.installAssembliesAirgap(
                    "runtime-addon-py37gpu",
                    self.installRuntimeGPUPy37_load_from, icpdInstallLogFile)
            gpupy36end = Utilities.currentTimeMillis()
            TR.info(methodName, "GPUPy36 package installation completed")
            self.printTime(gpupy36start, gpupy36end, "Installing GPUPy36")

        if (self.installDb2WH == "True"):
            TR.info(methodName, "Start installing Db2WH")
            self.installDb2UOperator(icpdInstallLogFile)
            db2wh_start = Utilities.currentTimeMillis()

            install_db2wh_command = "./install_db2wh.sh " + offline_installation_dir + " " + self.Db2WH_Case_Name + " " + self.image_registry_url + " " + self.foundation_service_namespace + " " + self.cpd_operator_namespace + " " + self.cpd_instance_namespace + " " + self.cpd_license + " " + self.storage_type + " " + self.storage_class

            TR.info(methodName,
                    "Install Db2WH with command %s" % install_db2wh_command)

            try:
                install_db2wh_retcode = check_output(
                    ['bash', '-c', install_db2wh_command])
            except CalledProcessError as e:
                TR.error(
                    methodName,
                    "command '{}' return with error (code {}): {}".format(
                        e.cmd, e.returncode, e.output))

            TR.info(
                methodName, "Install Db2WH with command %s returned %s" %
                (install_db2wh_command, install_db2wh_retcode))

            db2wh_end = Utilities.currentTimeMillis()
            TR.info(methodName, "Install Db2WH completed")
            self.printTime(db2wh_start, db2wh_end, "Install Db2WH")

        if (self.installHEE == "True"):
            TR.info(methodName, "Start installing HEE package")
            heestart = Utilities.currentTimeMillis()
            if (self.installHEE_load_from == "NA"):
                self.installAssembliesAirgap("hadoop-addon",
                                             self.default_load_from,
                                             icpdInstallLogFile)
            else:
                self.installAssembliesAirgap("hadoop-addon",
                                             self.installHEE_load_from,
                                             icpdInstallLogFile)
            heeend = Utilities.currentTimeMillis()
            TR.info(methodName, "HEE package installation completed")
            self.printTime(heestart, heeend, "Installing HEE")

        if (self.installDODS == "True"):
            TR.info(methodName, "Start installing DODS package")
            dodsstart = Utilities.currentTimeMillis()
            if (self.installDODS_load_from == "NA"):
                self.installAssembliesAirgap("dods", self.default_load_from,
                                             icpdInstallLogFile)
            else:
                self.installAssembliesAirgap("dods",
                                             self.installDODS_load_from,
                                             icpdInstallLogFile)
            dodsend = Utilities.currentTimeMillis()
            TR.info(methodName, "DODS package installation completed")
            self.printTime(dodsstart, dodsend, "Installing DODS")

        if (self.installWKC == "True"):

            self.installDb2UOperator(icpdInstallLogFile)

            TR.info(methodName, "Start installing Watson Knowledge Catalog")

            wkcstart = Utilities.currentTimeMillis()

            install_wkc_command = "./install_wkc.sh " + offline_installation_dir + " " + self.WKC_Case_Name + " " + self.image_registry_url + " " + self.foundation_service_namespace + " " + self.cpd_operator_namespace + " " + self.cpd_instance_namespace + " " + self.cpd_license + " " + self.storage_type + " " + self.storage_class
            TR.info(
                methodName,
                "Install Watson Knowledge Catalog with command %s" %
                install_wkc_command)

            install_wkc_retcode = ""
            try:
                install_wkc_retcode = check_output(
                    ['bash', '-c', install_wkc_command])
            except CalledProcessError as e:
                TR.error(
                    methodName,
                    "command '{}' return with error (code {}): {}".format(
                        e.cmd, e.returncode, e.output))

            TR.info(
                methodName,
                "Install Watson Knowledge Catalog with command %s returned %s"
                % (install_wkc_command, install_wkc_retcode))

            wkcend = Utilities.currentTimeMillis()
            TR.info(methodName, "Install Watson Knowledge Catalog completed")
            self.printTime(wkcstart, wkcend,
                           "Install Watson Knowledge Catalog")

        if (self.installDV == "True"):

            self.installDb2UOperator(icpdInstallLogFile)

            TR.info(methodName, "Start installing Data Virtualization")

            dvstart = Utilities.currentTimeMillis()

            install_dv_command = "./install_dv.sh " + offline_installation_dir + " " + self.DV_Case_Name + " " + self.image_registry_url + " " + self.foundation_service_namespace + " " + self.cpd_operator_namespace + " " + self.cpd_instance_namespace + " " + self.cpd_license
            TR.info(
                methodName, "Install Data Virtualization with command %s" %
                install_dv_command)

            install_dv_retcode = ""
            try:
                install_dv_retcode = check_output(
                    ['bash', '-c', install_dv_command])
            except CalledProcessError as e:
                TR.error(
                    methodName,
                    "command '{}' return with error (code {}): {}".format(
                        e.cmd, e.returncode, e.output))

            TR.info(
                methodName,
                "Install Data Virtualization with command %s returned %s" %
                (install_dv_command, install_dv_retcode))

            dvend = Utilities.currentTimeMillis()
            TR.info(methodName, "Install Data Virtualization completed")
            self.printTime(dvstart, dvend, "Install Data Virtualization")

        TR.info(methodName, "Installed all packages.")
Exemplo n.º 5
0
    def installCPD(self, icpdInstallLogFile):
        """
        Installs pre-requsites for cpd installation by running mkfifo and install-sem playbooks
        prepares oc cluster with required user and roles
        copies certificates from node instance to ansible server and configures internal docker registry to push images
        creates a OC project with user defined name
        Downloads binary file from S3 and extracts it to /ibm folder
        installs wkc wml and wsl package by pushing images to local registry and using local registry.

        """

        methodName = "installCPD"
        check_cmd = "checkmodule -M -m -o mkfifo.mod mkfifo.te"
        call(check_cmd, shell=True, stdout=icpdInstallLogFile)

        package_cmd = "semodule_package -o mkfifo.pp -m mkfifo.mod"
        call(package_cmd, shell=True, stdout=icpdInstallLogFile)
        TR.info(
            methodName,
            "ansible-playbook: install-mkfifo.yaml started, find log here %s" %
            (os.path.join(self.logsHome, "install-mkfifo.log")))

        retcode = call(
            'ansible-playbook /ibm/playbooks/install-mkfifo.yaml >> %s 2>&1' %
            (os.path.join(self.logsHome, "install-mkfifo.log")),
            shell=True,
            stdout=icpdInstallLogFile)
        if (retcode != 0):
            TR.error(
                methodName,
                "Error calling ansible-playbook install-mkfifo.yaml. Return code: %s"
                % retcode)
            raise Exception(
                "Error calling ansible-playbook install-mkfifo.yaml. Return code: %s"
                % retcode)
        else:
            TR.info(methodName,
                    "ansible-playbook: install-mkfifo.yaml completed.")

        retcode = call(
            'ansible-playbook /ibm/playbooks/install-sem.yaml >> %s 2>&1' %
            (os.path.join(self.logsHome, "install-sem.log")),
            shell=True,
            stdout=icpdInstallLogFile)
        if (retcode != 0):
            TR.error(
                methodName,
                "Error calling ansible-playbook install-sem.yaml. Return code: %s"
                % retcode)
            raise Exception(
                "Error calling ansible-playbook install-sem.yaml. Return code: %s"
                % retcode)
        else:
            TR.info(methodName, "ansible-playbook:install-sem.yaml completed.")

        retlogin = check_output(['bash', '-c', 'oc login -u system:admin'])
        TR.info(methodName,
                "Logged in as system:admin with retcode %s" % retlogin)

        retproj = check_output(['bash', '-c', 'oc project default'])
        TR.info(methodName, "Switched to default project %s" % retproj)

        registry_cmd = "oc get route | grep 'docker-registry'| awk {'print $2'}"
        registry_url = check_output(['bash', '-c',
                                     registry_cmd]).rstrip("\n\r")
        TR.info(methodName,
                "Get url from docker-registry route %s" % registry_url)

        self.docker_registry = registry_url + ":443/" + self.namespace
        TR.info(methodName, " registry url %s" % self.docker_registry)

        retcode = call(
            'oc adm policy add-cluster-role-to-user cluster-admin admin',
            shell=True,
            stdout=icpdInstallLogFile)
        TR.info(methodName,
                "Added cluster admin role to admin user %s" % retcode)

        oc_login = "******" + self.getPassword()
        retcode = call(oc_login, shell=True, stdout=icpdInstallLogFile)
        TR.info(methodName, "Log in to OC with admin user %s" % retcode)

        oc_new_project = "oc new-project " + self.namespace
        retcode = call(oc_new_project, shell=True, stdout=icpdInstallLogFile)
        TR.info(
            methodName,
            "Create new project with user defined project name %s,retcode=%s" %
            (self.namespace, retcode))

        nodeIP = self.getNodeIP()
        add_to_hosts = "echo " + nodeIP + " " + registry_url + " >> /etc/hosts"
        retcode = call(add_to_hosts, shell=True, stdout=icpdInstallLogFile)
        TR.info(methodName, "add entry to host file %s" % add_to_hosts)

        copycerts = "scp -r root@" + nodeIP + ":/etc/docker/certs.d/docker-registry.default.svc:5000 /etc/docker/certs.d/" + registry_url + ":443"
        retcode = call(copycerts, shell=True, stdout=icpdInstallLogFile)
        TR.info(methodName, "Copy certs from compute node %s" % retcode)

        self.token = self.getToken(icpdInstallLogFile)
        # self.updateTemplateFile('/ibm/local_repo.yaml', '<REGISTRYURL>', self.docker_registry)
        # self.updateTemplateFile('/ibm/local_repo.yaml', '<PASSWORD>', self.token)
        # TR.info(methodName,"Update local repo file with sa token")

        # TR.info(methodName,"Download install package from S3 bucket %s" %self.cpdbucketName)
        # s3start =Utilities.currentTimeMillis()
        # self.getS3Object(bucket=self.cpdbucketName, s3Path="2.5/cpd.tar", destPath='/tmp/cpd.tar')
        # s3end = Utilities.currentTimeMillis()
        # TR.info(methodName,"Downloaded install package from S3 bucket %s" %self.cpdbucketName)
        # self.printTime(s3start,s3end, "S3 download of cpd tar")

        # TR.info(methodName,"Extract install package")
        # call('tar -xvf /tmp/cpd.tar -C /ibm/',shell=True, stdout=icpdInstallLogFile)
        # extractend = Utilities.currentTimeMillis()
        # TR.info(methodName,"Extracted install package")
        # self.printTime(s3end, extractend, "Extracting cpd tar")
        litestart = Utilities.currentTimeMillis()
        TR.info(methodName, "Start installing Lite package")
        self.installAssemblies("lite", "v2.5.0.0", icpdInstallLogFile)
        liteend = Utilities.currentTimeMillis()
        self.printTime(litestart, liteend, "Installing Lite")
        self.configureCPDRoute(icpdInstallLogFile)

        if (self.installWSL):
            TR.info(methodName, "Start installing WSL package")
            wslstart = Utilities.currentTimeMillis()
            self.installAssemblies("wsl", "2.1.0", icpdInstallLogFile)
            wslend = Utilities.currentTimeMillis()
            TR.info(methodName, "WSL package installation completed")
            self.printTime(wslstart, wslend, "Installing WSL")

        if (self.installDV):
            TR.info(methodName, "Start installing DV package")
            TR.info(methodName, "Delete configmap node-config-compute-infra")
            delete_cm = "oc delete configmap -n openshift-node node-config-compute-infra"
            retcode = check_output(['bash', '-c', delete_cm])
            TR.info(methodName,
                    "Deleted configmap node-config-compute-infra %s" % retcode)
            TR.info(methodName, "Create configmap node-config-compute-infra")
            create_cm = "oc create -f /ibm/node-config-compute-infra.yaml"
            retcode = check_output(['bash', '-c', create_cm])
            TR.info(methodName,
                    "Created configmap node-config-compute-infra %s" % retcode)
            dvstart = Utilities.currentTimeMillis()
            self.installAssemblies("dv", "v1.3.0.0", icpdInstallLogFile)
            dvend = Utilities.currentTimeMillis()
            TR.info(methodName, "DV package installation completed")
            self.printTime(dvstart, dvend, "Installing DV")

        if (self.installWML):
            TR.info(methodName, "Start installing WML package")
            wmlstart = Utilities.currentTimeMillis()
            self.installAssemblies("wml", "2.1.0.0", icpdInstallLogFile)
            wmlend = Utilities.currentTimeMillis()
            TR.info(methodName, "WML package installation completed")
            self.printTime(wmlstart, wmlend, "Installing WML")

        if (self.installWKC):
            TR.info(methodName, "Start installing WKC package")
            wkcstart = Utilities.currentTimeMillis()
            self.installAssemblies("wkc", "3.0.333", icpdInstallLogFile)
            wkcend = Utilities.currentTimeMillis()
            TR.info(methodName, "WKC package installation completed")
            self.printTime(wkcstart, wkcend, "Installing WKC")

        if (self.installOSWML):
            TR.info(methodName, "Start installing AI Openscale package")
            aiostart = Utilities.currentTimeMillis()
            self.installAssemblies("aiopenscale", "v2.5.0.0",
                                   icpdInstallLogFile)
            aioend = Utilities.currentTimeMillis()
            TR.info(methodName, "AI Openscale package installation completed")
            self.printTime(aiostart, aioend, "Installing AI Openscale")

        TR.info(methodName, "Installed all packages.")