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
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))
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
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.")
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.")