def _getArg(self, synonyms, args, default=None):
"""
Return the value from the args dictionary that may be specified with any of the
argument names in the list of synonyms.
The synonyms argument may be a Jython list of strings or it may be a string representation
of a list of names with a comma or space separating each name.
The args is a dictionary with the keyword value pairs that are the arguments
that may have one of the names in the synonyms list.
If the args dictionary does not include the option that may be named by any
of the given synonyms then the given default value is returned.
NOTE: This method has to be careful to make explicit checks for value being None
rather than something that is just logically false. If value gets assigned 0 from
the get on the args (command line args) dictionary, that appears as false in a
condition expression. However 0 may be a legitimate value for an input parameter
in the args dictionary. We need to break out of the loop that is checking synonyms
as well as avoid assigning the default value if 0 is the value provided in the
args dictionary.
"""
value = None
if (type(synonyms) != type([])):
synonyms = Utilities.splitString(synonyms)
#endIf
for name in synonyms:
value = args.get(name)
if (value != None):
break
#endIf
#endFor
if (value == None and default != None):
value = default
#endIf
return value
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 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 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):
"""
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.")