def __init__(self, module):
"""
Constructor
"""
ActionBundle.__init__(self, module)
previousVersionBackupPath = module.executionContext["previousVersionBackupPath"]
versionInfo = module.executionContext["versionInfo"]
revisionInfo = module.executionContext["revisionInfo"]
previousVersionInfo, previousRevisionInfo = getVersionAndRevisionInfo(
module.versionInformationRegex,
module.revisionInformationRegex,
previousVersionBackupPath,
module.relativeVersionInformationPath,
)
majorVersionInfo = versionInfo[versionInfo.find("-") + 1 : findNthSubstring(versionInfo, ".", 3)]
# Compare current and new versions
log.info("Version currently installed : " + previousVersionInfo)
log.info("Revision currently installed : " + previousRevisionInfo)
log.info("Version to be installed : " + versionInfo)
log.info("Revision to be installed : " + revisionInfo)
module.executionContext["majorVersionInfo"] = majorVersionInfo
module.executionContext["previousVersionInfo"] = previousVersionInfo
module.executionContext["previousRevisionInfo"] = previousRevisionInfo
def __init__(self, module):
'''
Constructor
'''
ActionBundle.__init__(self, module)
# Generate a unique ActionBundle execution id
guid = generateGUID()
log.info("Unique ActionBundle execution ID generated: " + guid)
# Configure marketing-suite-admin.properties using envprops
# Configure mgage.properties using envprops
for k, v in module.relativeConfigurationFiles.items():
exactExtractedLocation = module.subModule.unzippedPackagePath + scriptGlobals.osDirSeparator + k
ConfigureTemplateFile(module.name, lib.OptParser.options.envprops, exactExtractedLocation)
CheckFileConfigurationIsComplete(exactExtractedLocation)
# Copy marketing-suite-admin.properties to conf
# Copy mgage.properties to conf
# Copy jboss-log4j.xml to conf
for k, v in module.relativeConfigurationFiles.items():
exactExtractedLocation = module.subModule.unzippedPackagePath + scriptGlobals.osDirSeparator + k
exactTargetLocation = module.targetDeploymentPath + scriptGlobals.osDirSeparator + v
CopyDirOrFile(exactExtractedLocation, exactTargetLocation)
def __init__(self, module):
"""
Constructor
"""
ActionBundle.__init__(self, module)
# Generate a unique ActionBundle execution id
guid = generateGUID()
log.info("Unique ActionBundle execution ID generated: " + guid)
# Prepare directory to unpack package
unzippedPackagePath = createDirectoriesRecursively(
scriptGlobals.workingDir + scriptGlobals.osDirSeparator + "unzippedPackage"
)
# Extract CRM package into tmp dir
ExtractZipToDir(module.moduleFilename, unzippedPackagePath)
# Get Version, Revision information
versionInfo, revisionInfo = getVersionAndRevisionInfo(
module.versionInformationRegex,
module.revisionInformationRegex,
unzippedPackagePath,
module.relativeVersionInformationPath,
)
module.executionContext["unzippedPackagePath"] = unzippedPackagePath
module.executionContext["versionInfo"] = versionInfo
module.executionContext["revisionInfo"] = revisionInfo
module.executionContext["guid"] = guid
def __init__(self, module):
"""
Constructor
"""
ActionBundle.__init__(self, module)
unzippedPackagePath = module.executionContext["unzippedPackagePath"]
versionInfo = module.executionContext["versionInfo"]
revisionInfo = module.executionContext["revisionInfo"]
guid = module.executionContext["guid"]
# Compose Oracle DB Connection String
oracleConnectionString = "%s/%s@%s" % (
extractOracleDatabaseCredentials(
module.name,
lib.OptParser.options.envprops,
"VNA_CRM_USERNAMEBASE",
"VNA_CRM_PASSWORDBASE",
"DBConnectionString",
)
)
# Run DB init script(s)
for dbInitScript in module.relativeDatabaseInitFiles:
appendRequiredStringsToOracleSQLFile(unzippedPackagePath + scriptGlobals.osDirSeparator + dbInitScript)
RunOracleScriptFromFile(
unzippedPackagePath + scriptGlobals.osDirSeparator + dbInitScript, oracleConnectionString
)
# Add LOG table
RunOracleScriptFromFile(scriptGlobals.oracleLogTemplateFile, oracleConnectionString)
# Log DB init script(s)
for dbInitScript in module.relativeDatabaseInitFiles:
logOracleScriptInDBLog(
dbInitScript,
guid,
lib.OptParser.options.action,
module.name,
versionInfo,
revisionInfo,
oracleConnectionString,
)
# Already existing upgrade scripts must be logged because in the upcoming upgrade we need to run from there on
log.info(
"Existing SQL patches will be logged in the log table so that the script will not run them again if you decise to update this version to latest"
)
ls = os.listdir(unzippedPackagePath + scriptGlobals.osDirSeparator + module.relativeDatabaseUpgradeFilePath)
ls.sort()
for patch in ls:
logOracleScriptInDBLog(
patch,
guid,
lib.OptParser.options.action,
module.name,
versionInfo,
revisionInfo,
oracleConnectionString,
)
def __init__(self, module):
'''
Constructor
'''
ActionBundle.__init__(self, module)
# Check if JBOSS is running
if getProcessPIDByPath(module.targetDeploymentPath):die("The JBOSS server at '" + module.targetDeploymentPath + "' is up. Installation will not continue")
# Generate a unique ActionBundle execution id
guid = generateGUID()
log.info("Unique ActionBundle execution ID generated: " + guid)
# Prepare directory to unpack package
module.subModule.unzippedPackagePath = createDirectoriesRecursively(scriptGlobals.workingDir + scriptGlobals.osDirSeparator + "unzippedPackage")
# Extract MS Admin package into tmp dir
ExtractZipToDir(module.moduleFilename, module.subModule.unzippedPackagePath)
# Prepare directory to unpack package
module.subModule.previousVersionBackupPath = createDirectoriesRecursively(scriptGlobals.workingDir + scriptGlobals.osDirSeparator + "previousVersionBackup")
# Extract new MANIFEST.MF
ExtractFileFromZipToDir(module.subModule.unzippedPackagePath + scriptGlobals.osDirSeparator + module.subModule.relativeWarPath, module.relativeVersionInformationPath, module.subModule.unzippedPackagePath)
# Prepare directory to keep backups
# Since MS is deployed on JBOSS some paths have an %s to allow a configurable
# profile, so do a little sprintf to fix them
sprintfOnDictionaryValues(module.relativeConfigurationFiles, module.targetDeploymentProfile)
sprintfOnDictionaryValues(module.relativeCopyableFilesOrFolders, module.targetDeploymentProfile)
def __init__(self, module):
'''
Constructor
'''
ActionBundle.__init__(self, module)
# Check if JBOSS is running
if getProcessPIDByPath(module.targetDeploymentPath):die("The JBOSS server at '" + module.targetDeploymentPath + "' is up. Installation will not continue")
# Generate a unique ActionBundle execution id
guid = generateGUID()
log.info("Unique ActionBundle execution ID generated: " + guid)
unzippedPackagePath = module.subModule.unzippedPackagePath
# Import Clean DB script to Postgres DB
dbUsername = readPropertyFromPropertiesFile("TARGET_POSTGRES_SRV_DB_OWNER", module.name, lib.OptParser.options.envprops)
dbPassword = readPropertyFromPropertiesFile("TARGET_POSTGRES_SRV_DB_PASSWORD", module.name, lib.OptParser.options.envprops)
dbHostName = readPropertyFromPropertiesFile("TARGET_POSTGRES_SRV_HOSTNAME", module.name, lib.OptParser.options.envprops)
dbName = readPropertyFromPropertiesFile("TARGET_POSTGRES_SRV_DB_NAME", module.name, lib.OptParser.options.envprops)
dbPort = readPropertyFromPropertiesFile("TARGET_POSTGRES_SRV_PORT", module.name, lib.OptParser.options.envprops)
tmpC = "jdbc:postgresql://" + dbHostName + ":" + dbPort + "/" + dbName
# Find version/revision info
versionInfo = grepFile(module.versionInformationRegex, unzippedPackagePath + scriptGlobals.osDirSeparator + "MANIFEST.MF")
revisionInfo = grepFile(module.revisionInformationRegex, unzippedPackagePath + scriptGlobals.osDirSeparator + "MANIFEST.MF")
versionInfo = (versionInfo.replace(module.versionInformationRegex, "")).strip()
revisionInfo = (revisionInfo.replace(module.revisionInformationRegex, "")).strip()
# Determine last executed script in DB
dbUsername = readPropertyFromPropertiesFile("TARGET_POSTGRES_SRV_DB_OWNER", module.name, lib.OptParser.options.envprops)
dbPassword = readPropertyFromPropertiesFile("TARGET_POSTGRES_SRV_DB_PASSWORD", module.name, lib.OptParser.options.envprops)
dbHostName = readPropertyFromPropertiesFile("TARGET_POSTGRES_SRV_HOSTNAME", module.name, lib.OptParser.options.envprops)
dbName = readPropertyFromPropertiesFile("TARGET_POSTGRES_SRV_DB_NAME", module.name, lib.OptParser.options.envprops)
dbPort = readPropertyFromPropertiesFile("TARGET_POSTGRES_SRV_PORT", module.name, lib.OptParser.options.envprops)
tmpC = "jdbc:postgresql://" + dbHostName + ":" + dbPort + "/" + dbName
result = runPostgresScript("SELECT EXECUTED_SCRIPT FROM FIREWORKS_SCRIPT_LOG WHERE EXECUTED_ON IN (SELECT MAX(EXECUTED_ON) FROM FIREWORKS_SCRIPT_LOG);", dbUsername, dbPassword, tmpC)
lastExecutedPath, lastExecutedFilename = os.path.split(result.strip());
log.info("According to log table, the last script executed on '" + tmpC + "' was '" + lastExecutedFilename + "'")
# Run scripts on DB
ls = os.listdir(unzippedPackagePath + scriptGlobals.osDirSeparator + module.relativeDatabaseUpgradeFilePath)
ls.sort()
found = False
for patch in ls:
if found:
#Replace Owner
exactExtractedLocation = unzippedPackagePath + scriptGlobals.osDirSeparator + module.relativeDatabaseUpgradeFilePath + scriptGlobals.osDirSeparator + patch
ConfigureTemplateFile(module.name, lib.OptParser.options.envprops, exactExtractedLocation)
CheckFileConfigurationIsComplete(exactExtractedLocation)
#Run Script
RunPostgresScriptFromFile(unzippedPackagePath + scriptGlobals.osDirSeparator + module.relativeDatabaseUpgradeFilePath + scriptGlobals.osDirSeparator + patch, dbUsername, dbPassword, tmpC)
# Log executed scripts
RunPostgresScript("INSERT INTO FIREWORKS_SCRIPT_LOG (INSTALLATION_ID, ACTION, MODULE_NAME, MODULE_VERSION, MODULE_REVISION, EXECUTED_SCRIPT, EXECUTED_ON) VALUES ('" + guid + "', '" + lib.OptParser.options.action + "', '" + module.name + "', '" + versionInfo + "', '" + revisionInfo + "', '" + patch + "', CURRENT_TIMESTAMP);", dbUsername, dbPassword, tmpC)
if lastExecutedFilename.find(patch) > -1: found = True
def __init__(self, module):
'''
Constructor
'''
ActionBundle.__init__(self, module)
# Initialize application server object
# appServer = ApplicationServer(module, scriptGlobals.appsrvProperties)
# Generate a unique ActionBundle execution id
guid = generateGUID()
log.info("Unique ActionBundle execution ID generated: " + guid)
# Check if Server is running
if getProcessPIDByPathAndIdentifier(module.targetDeploymentPath, module.subModule.processIdentifier): die("\n\nThe " + module.subModule.name + " server at '" + module.targetDeploymentPath + "' is up. Installation will not continue\n")
# Run script
moduleDeployPath = module.targetDeploymentPath + "/" + module.subModule.name
path2 = moduleDeployPath + "/" + module.subModule.installUpdateScript
ChangePathPermissions(path2, 0744)
path2=path2 + " CREATE YES "
ExecuteOSCommand(path2, None)
# Find version/revision info
manifestFilePath=moduleDeployPath + "/META-INF/MANIFEST.MF"
versionInfo = grepFile(module.versionInformationRegex, manifestFilePath)
buildInfo = grepFile(module.buildInformationRegex, manifestFilePath)
revisionInfo = grepFile(module.revisionInformationRegex, manifestFilePath)
versionInfo = (versionInfo.replace(module.versionInformationRegex, "")).strip()
if buildInfo != None:
buildInfo = (buildInfo.replace(module.buildInformationRegex, "")).strip()
revisionInfo = (revisionInfo.replace(module.revisionInformationRegex, "")).strip()
# Construct the email notification
emailSender = readPropertyFromPropertiesFileWithFallback("emailNotificationSenderAddress", scriptGlobals.scriptVarSectionName, lib.OptParser.options.envprops, scriptGlobals.emailNotificationSenderAddress)
emailRecipients = scriptGlobals.globalNotificationEmailList
emailSubject = "MSM Installation: " + module.name + "@"+ getCurrentHostname() + " (" + module.friendlyServerName + ")"
emailText = detailedCleanInstallationReportTemplate(module.subModule.name,
versionInfo,
lib.OptParser.options.action,
getCurrentHostname(),
os.getcwd(),
guid,
" ".join(platform.uname()),
getpass.getuser(),
buildInfo,
revisionInfo,
lib.OptParser.options.envprops,
scriptGlobals.workingDir)
# Email all required parties
SendEmail(emailSender,
emailRecipients,
emailSubject,
emailText,
scriptGlobals.smtpHost,
scriptGlobals.smtpPort)
def __init__(self, module):
"""
Constructor
"""
ActionBundle.__init__(self, module)
# Dont continue if application server is up
if getApplicationServerPID(module):
die("The JBOSS server at '" + module.targetDeploymentPath + "' is up. Action will not continue")
def __init__(self, module):
"""
Constructor
"""
ActionBundle.__init__(self, module)
# CRM is a JBOSS webapp. Some paths have an %s to allow a configurable profile, so do a little sprintf to fix them
sprintfOnDictionaryValues(module.relativeConfigurationFiles, module.targetDeploymentProfile)
sprintfOnDictionaryValues(module.relativeCopyableFilesOrFolders, module.targetDeploymentProfile)
sprintfOnDictionaryValues(module.relativeBackupOnlyFilesOrFolders, module.targetDeploymentProfile)
def __init__(self, module):
'''
Constructor
'''
ActionBundle.__init__(self, module)
# Generate a unique ActionBundle execution id
guid = generateGUID()
log.info("Unique ActionBundle execution ID generated: " + guid)
# Check if JBOSS is running
if getProcessPIDByPath(module.targetDeploymentPath): die("The JBOSS server at '" + module.targetDeploymentPath + "' is up. Installation will not continue")
# Prepare directory to unpack package
unzippedPackagePath = createDirectoriesRecursively(scriptGlobals.workingDir + scriptGlobals.osDirSeparator + "unzippedPackage")
# Since Builder is deployed on JBOSS some paths have an %s to allow a configurable
# profile, so do a little sprintf to fix them
sprintfOnDictionaryValues(module.relativeConfigurationFiles, module.targetDeploymentProfile)
sprintfOnDictionaryValues(module.relativeCopyableFilesOrFolders, module.targetDeploymentProfile)
sprintfOnListValues(module.subModule.relativeCleanUpFiles, module.targetDeploymentProfile)
# Extract Builder package into tmp dir
ExtractZipToDir(module.moduleFilename, unzippedPackagePath)
# Do this again in case new settings have been added
# Configure m-web-builder.properties using envprops
# Configure mgage.properties using envprops
for k, v in module.relativeConfigurationFiles.items():
exactExtractedLocation = unzippedPackagePath + scriptGlobals.osDirSeparator + k
ConfigureTemplateFile(module.name, lib.OptParser.options.envprops, exactExtractedLocation)
CheckFileConfigurationIsComplete(exactExtractedLocation)
# Copy m-web-builder.properties to conf
# Copy mgage.properties to conf
# Copy jboss-log4j.xml to conf
for k, v in module.relativeConfigurationFiles.items():
exactExtractedLocation = unzippedPackagePath + scriptGlobals.osDirSeparator + k
exactTargetLocation = module.targetDeploymentPath + scriptGlobals.osDirSeparator + v
CopyDirOrFile(exactExtractedLocation, exactTargetLocation)
# Clean up files that might have been left over from previous manuall installations
cleanUp(module)
# Copy artifacts to profile
for k, v in module.relativeCopyableFilesOrFolders.items():
exactExtractedLocation = unzippedPackagePath + scriptGlobals.osDirSeparator + k
exactTargetLocation = module.targetDeploymentPath + scriptGlobals.osDirSeparator + v
CopyDirOrFile(exactExtractedLocation, exactTargetLocation)
# Install Plugins
staticFolder = readPropertyFromPropertiesFile("STATIC_FOLDER", module.name, lib.OptParser.options.envprops)
installDefaultPlugins(staticFolder, unzippedPackagePath, module)
def __init__(self, module):
'''
Constructor
'''
ActionBundle.__init__(self, module)
# Generate a unique ActionBundle execution id
guid = generateGUID()
log.info("Unique ActionBundle execution ID generated: " + guid)
# Check if standalone is running
if getProcessPIDByPathAndIdentifier(module.targetDeploymentPath, module.subModule.processIdentifier): die("\n\nThe " + module.subModule.name + " server at '" + module.targetDeploymentPath + "' is up. Configuration will not continue\n")
# Check if module is already installed
for k, v in module.relativeCopyableFilesOrFolders.items():
exactLocation = module.targetDeploymentPath + scriptGlobals.osDirSeparator + v
if not os.path.isdir(exactLocation):
die(module.subModule.name + " is Not already installed to:" + module.targetDeploymentPath + ". Maybe you want to make a clean Installation !!")
# Get Previous Hudson data
previousManifilePath = module.targetDeploymentPath + scriptGlobals.osDirSeparator + module.subModule.name + scriptGlobals.osDirSeparator + "META-INF" + scriptGlobals.osDirSeparator + "MANIFEST.MF"
previousVersionInfo = grepFile(module.versionInformationRegex, previousManifilePath)
previousBuildInfo = grepFile(module.buildInformationRegex, previousManifilePath)
previousRevisionInfo = grepFile(module.revisionInformationRegex, previousManifilePath)
previousRevisionInfo = (previousRevisionInfo.replace(module.revisionInformationRegex, "")).strip()
previousVersionInfo = (previousVersionInfo.replace(module.versionInformationRegex, "")).strip()
if previousBuildInfo != None:
previousBuildInfo = (previousBuildInfo.replace(module.buildInformationRegex, "")).strip()
# Construct the email notification
emailSender = readPropertyFromPropertiesFileWithFallback("emailNotificationSenderAddress", scriptGlobals.scriptVarSectionName, lib.OptParser.options.envprops, scriptGlobals.emailNotificationSenderAddress)
emailRecipients = scriptGlobals.globalNotificationEmailList
emailSubject = "MSM Installation: " + module.name + "@"+ getCurrentHostname() + " (" + module.friendlyServerName + ")"
emailText = detailedCleanInstallationReportTemplate(module.subModule.name,
previousVersionInfo,
lib.OptParser.options.action,
getCurrentHostname(),
os.getcwd(),
guid,
" ".join(platform.uname()),
getpass.getuser(),
previousBuildInfo,
previousRevisionInfo,
lib.OptParser.options.envprops,
scriptGlobals.workingDir)
# Email all required parties
SendEmail(emailSender,
emailRecipients,
emailSubject,
emailText,
scriptGlobals.smtpHost,
scriptGlobals.smtpPort)
# end
def __init__(self, module):
'''
Constructor
'''
ActionBundle.__init__(self, module)
# Check if JBOSS is running
if getProcessPIDByPath(module.targetDeploymentPath):die("The JBOSS server at '" + module.targetDeploymentPath + "' is up. Installation will not continue")
# Generate a unique ActionBundle execution id
guid = generateGUID()
log.info("Unique ActionBundle execution ID generated: " + guid)
unzippedPackagePath = module.subModule.unzippedPackagePath
# Import Clean DB script to Postgres DB
dbUsername = readPropertyFromPropertiesFile("TARGET_POSTGRES_SRV_DB_OWNER", module.name, lib.OptParser.options.envprops)
dbPassword = readPropertyFromPropertiesFile("TARGET_POSTGRES_SRV_DB_PASSWORD", module.name, lib.OptParser.options.envprops)
dbHostName = readPropertyFromPropertiesFile("TARGET_POSTGRES_SRV_HOSTNAME", module.name, lib.OptParser.options.envprops)
dbName = readPropertyFromPropertiesFile("TARGET_POSTGRES_SRV_DB_NAME", module.name, lib.OptParser.options.envprops)
dbPort = readPropertyFromPropertiesFile("TARGET_POSTGRES_SRV_PORT", module.name, lib.OptParser.options.envprops)
tmpC = "jdbc:postgresql://" + dbHostName + ":" + dbPort + "/" + dbName
# Run DB init script(s)
for dbInitScript in module.relativeDatabaseInitFiles:
# Replace Owner on init scripts
exactExtractedLocation = unzippedPackagePath + scriptGlobals.osDirSeparator + dbInitScript
ConfigureTemplateFile(module.name, lib.OptParser.options.envprops, exactExtractedLocation)
CheckFileConfigurationIsComplete(exactExtractedLocation)
RunPostgresScriptFromFile(unzippedPackagePath + scriptGlobals.osDirSeparator + dbInitScript, dbUsername, dbPassword, tmpC)
# Replace Owner on postgresLogTemplate
ConfigureTemplateFile(module.name, lib.OptParser.options.envprops, scriptGlobals.postgresLogTemplateFile)
# Add LOG table
RunPostgresScriptFromFile(scriptGlobals.postgresLogTemplateFile, dbUsername, dbPassword, tmpC)
# Find version/revision info
versionInfo = grepFile(module.versionInformationRegex, unzippedPackagePath + scriptGlobals.osDirSeparator + "MANIFEST.MF")
revisionInfo = grepFile(module.revisionInformationRegex, unzippedPackagePath + scriptGlobals.osDirSeparator + "MANIFEST.MF")
versionInfo = (versionInfo.replace(module.versionInformationRegex, "")).strip()
revisionInfo = (revisionInfo.replace(module.revisionInformationRegex, "")).strip()
# Add one row per script executed in LOG table
for dbInitScript in module.relativeDatabaseInitFiles:
lastExecutedPath, lastExecutedFilename = os.path.split(dbInitScript)
RunPostgresScript("INSERT INTO FIREWORKS_SCRIPT_LOG (INSTALLATION_ID, ACTION, MODULE_NAME, MODULE_VERSION, MODULE_REVISION, EXECUTED_SCRIPT, EXECUTED_ON) VALUES ('" + guid + "', '" + lib.OptParser.options.action + "', '" + module.name + "', '" + versionInfo + "', '" + revisionInfo + "', '" + lastExecutedFilename + "', CURRENT_TIMESTAMP);", dbUsername, dbPassword, tmpC)
# Already existing upgrade scripts must be logged because in the upcoming upgrade we need to run from there on
log.info("Existing SQL patches will be logged in the log table so that the script will not run them again if you decise to update this version to latest")
ls = os.listdir(unzippedPackagePath + scriptGlobals.osDirSeparator + module.relativeDatabaseUpgradeFilePath)
ls.sort()
for patch in ls:
RunPostgresScript("INSERT INTO FIREWORKS_SCRIPT_LOG (INSTALLATION_ID, ACTION, MODULE_NAME, MODULE_VERSION, MODULE_REVISION, EXECUTED_SCRIPT, EXECUTED_ON) VALUES ('" + guid + "', '" + lib.OptParser.options.action + "', '" + module.name + "', '" + versionInfo + "', '" + revisionInfo + "', '" + patch + "', CURRENT_TIMESTAMP);", dbUsername, dbPassword, tmpC)
def __init__(self, module):
"""
Constructor
"""
ActionBundle.__init__(self, module)
# Prepare directory to keep backups
previousVersionBackupPath = createDirectoriesRecursively(
scriptGlobals.workingDir + scriptGlobals.osDirSeparator + "previousVersionBackup"
)
module.executionContext["previousVersionBackupPath"] = previousVersionBackupPath
def __init__(self, module):
"""
Constructor
"""
ActionBundle.__init__(self, module)
previousVersionBackupPath = module.executionContext["previousVersionBackupPath"]
# Backup Configuration Files to Target Location
copyApplicationFilesFromTargetLocation(
module.targetDeploymentPath, module.relativeConfigurationFiles, previousVersionBackupPath
)
def __init__(self, module):
"""
Constructor
"""
ActionBundle.__init__(self, module)
unzippedPackagePath = module.executionContext["unzippedPackagePath"]
# Copy Binary Files to Target Location
copyApplicationFilesToTargetLocation(
unzippedPackagePath, module.relativeCopyableFilesOrFolders, module.targetDeploymentPath
)
copyApplicationFilesToTargetLocation(
unzippedPackagePath, module.relativeBackupOnlyFilesOrFolders, module.targetDeploymentPath
)
def __init__(self, module):
"""
Constructor
"""
ActionBundle.__init__(self, module)
# Import CMS Structure
importCMSStructure(
os.getcwd(),
scriptGlobals.cmsStructureImportToolLocation,
module.subModule.CMSHost,
module.subModule.CMSPort,
module.subModule.CMSUser,
module.subModule.CMSStructureFilename,
)
def __init__(self, module):
"""
Constructor
"""
ActionBundle.__init__(self, module)
unzippedPackagePath = module.executionContext["unzippedPackagePath"]
# Populate Application Configuration files
populateApplicationConfigurationFiles(module.name, module.relativeConfigurationFiles, unzippedPackagePath)
# Copy Configuration Files to Target Location
copyApplicationFilesToTargetLocation(
unzippedPackagePath, module.relativeConfigurationFiles, module.targetDeploymentPath
)
def __init__(self, module):
'''
Constructor
'''
ActionBundle.__init__(self, module)
# Generate a unique ActionBundle execution id
guid = generateGUID()
log.info("Unique ActionBundle execution ID generated: " + guid)
# Copy marketing-suite-admin.war to deploy
for k, v in module.relativeCopyableFilesOrFolders.items():
exactExtractedLocation = module.subModule.unzippedPackagePath + scriptGlobals.osDirSeparator + k
exactTargetLocation = module.targetDeploymentPath + scriptGlobals.osDirSeparator + v
CopyDirOrFile(exactExtractedLocation, exactTargetLocation)
def __init__(self, module):
"""
Constructor
"""
ActionBundle.__init__(self, module)
previousVersionBackupPath = module.executionContext["previousVersionBackupPath"]
# Backup old runtime data
copyApplicationFilesFromTargetLocation(
module.targetDeploymentPath, module.relativeBackupOnlyFilesOrFolders, previousVersionBackupPath
)
# Backup Binary Files to Target Location
copyApplicationFilesFromTargetLocation(
module.targetDeploymentPath, module.relativeCopyableFilesOrFolders, previousVersionBackupPath
)
def __init__(self, module):
'''
Constructor
'''
ActionBundle.__init__(self, module)
euclidModule = module.subModule
guid = generateGUID()
log.info("Unique ActionBundle execution ID generated: " + guid)
unzippedPackagePath = createDirectoriesRecursively(scriptGlobals.workingDir + scriptGlobals.osDirSeparator + "unzippedPackage")
ExtractZipToDir(module.moduleFilename, unzippedPackagePath)
versionTmpPath = createDirectoriesRecursively(scriptGlobals.workingDir + scriptGlobals.osDirSeparator + "tmp")
installedWarPath = module.targetDeploymentPath + scriptGlobals.osDirSeparator + "server" + scriptGlobals.osDirSeparator + module.targetDeploymentProfile + scriptGlobals.osDirSeparator + "deploy" + scriptGlobals.osDirSeparator + module.name + ".war"
installedVersionInfo = getVersionInfoFromWar(installedWarPath, module.relativeVersionInformationPath, module.versionInformationRegex, module.revisionInformationRegex, versionTmpPath)
newWarPath = unzippedPackagePath + scriptGlobals.osDirSeparator + "bin" + scriptGlobals.osDirSeparator + module.name + ".war"
newVersionInfo = getVersionInfoFromWar(newWarPath, module.relativeVersionInformationPath, module.versionInformationRegex, module.revisionInformationRegex, versionTmpPath)
print "\n------ UPDATE VERSION INFO ------"
print "Currently installed: " + installedVersionInfo[0] + " (" + installedVersionInfo[1] + ")"
print " To be installed: " + newVersionInfo[0] + " (" + newVersionInfo[1] + ")\n"
def __init__(self, module):
'''
Constructor
'''
ActionBundle.__init__(self, module)
# Generate a unique ActionBundle execution id
guid = generateGUID()
log.info("Unique ActionBundle execution ID generated: " + guid)
previousVersionBackupPath = module.subModule.previousVersionBackupPath
unzippedPackagePath = module.subModule.unzippedPackagePath
# Backup marketing-admin-webapp.war from deploy/
# Backup esb.jar from deploy/
# Backup ROOT.WAR/crossdmain.xml from deploy/ROOT.WAR
log.info("######################## COPY ALL COPYABLE FILES ########################")
for k, v in module.relativeCopyableFilesOrFolders.items():
exactLocation = module.targetDeploymentPath + scriptGlobals.osDirSeparator + v
exactBackupLocation = module.subModule.previousVersionBackupPath + scriptGlobals.osDirSeparator + k
CopyDirOrFile2(exactLocation, exactBackupLocation)
# Backup marketing-suite-deployment.properties from conf
# Backup mgage.properties from conf
# Backup jboss-log4j.xml from conf
# Backup web.xml from marketing-admin-webapp.war/WEB-INF
log.info("######################## COPY ALL COPYABLE FILES ########################")
for k, v in module.relativeConfigurationFiles.items():
exactLocation = module.targetDeploymentPath + scriptGlobals.osDirSeparator + v
exactBackupLocation = previousVersionBackupPath + scriptGlobals.osDirSeparator + k
CopyDirOrFile2(exactLocation, exactBackupLocation)
log.info("######################## END OF COPY ########################")
# Extract old MANIFEST.MF
ExtractFileFromZipToDir(previousVersionBackupPath + scriptGlobals.osDirSeparator + module.subModule.relativeWarPath, module.relativeVersionInformationPath, previousVersionBackupPath)
# Compare current and new versions
log.info("Version currently installed : " + grepFile(module.versionInformationRegex, previousVersionBackupPath + scriptGlobals.osDirSeparator + "MANIFEST.MF"))
log.info("Revision currently installed : " + grepFile(module.revisionInformationRegex, previousVersionBackupPath + scriptGlobals.osDirSeparator + "MANIFEST.MF"))
log.info("Version to be installed : " + grepFile(module.versionInformationRegex, unzippedPackagePath + scriptGlobals.osDirSeparator + "MANIFEST.MF"))
log.info("Revision to be installed : " + grepFile(module.revisionInformationRegex, unzippedPackagePath + scriptGlobals.osDirSeparator + "MANIFEST.MF"))
def __init__(self, module):
"""
Constructor
"""
ActionBundle.__init__(self, module)
versionInfo = module.executionContext["versionInfo"]
revisionInfo = module.executionContext["revisionInfo"]
# previousVersionInfo = module.executionContext['previousVersionInfo']
# previousRevisionInfo = module.executionContext['previousRevisionInfo']
guid = module.executionContext["guid"]
# Construct the email notification
emailSender = readPropertyFromPropertiesFileWithFallback(
"emailNotificationSenderAddress",
scriptGlobals.scriptVarSectionName,
lib.OptParser.options.envprops,
scriptGlobals.emailNotificationSenderAddress,
)
emailRecipients = scriptGlobals.globalNotificationEmailList
emailSubject = (
"CRM Installation: " + module.name + "@" + getCurrentHostname() + " (" + module.friendlyServerName + ")"
)
emailText = detailedInstallationReportTemplate(
module.name,
lib.OptParser.options.action,
getCurrentHostname(),
os.getcwd(),
guid,
" ".join(platform.uname()),
getpass.getuser(),
versionInfo,
revisionInfo,
lib.OptParser.options.envprops,
)
# Email all required parties
SendEmail(emailSender, emailRecipients, emailSubject, emailText, scriptGlobals.smtpHost, scriptGlobals.smtpPort)
def __init__(self, module):
'''
Constructor
'''
ActionBundle.__init__(self, module)
unzippedPackagePath = module.subModule.unzippedPackagePath
propertiesFileName = "upgrade-configuration.properties"
# Run migration jars
ls = os.listdir(unzippedPackagePath + scriptGlobals.osDirSeparator + module.subModule.relativeJarFilesPath)
ls.sort()
for zipFile in ls:
# Extract MS Admin package into tmp dir
ExtractZipToDir(unzippedPackagePath + scriptGlobals.osDirSeparator + module.subModule.relativeJarFilesPath + scriptGlobals.osDirSeparator + zipFile, unzippedPackagePath + scriptGlobals.osDirSeparator + module.subModule.relativeJarFilesPath)
#Get jar name from zip name
jarFile = zipFile[:-4] + ".jar"
# extract properties to current dir
ExtractFileFromZipToDir(unzippedPackagePath + scriptGlobals.osDirSeparator + module.subModule.relativeJarFilesPath + scriptGlobals.osDirSeparator + jarFile, propertiesFileName, ".")
# configure properties
ConfigureTemplateFile(module.name, lib.OptParser.options.envprops, propertiesFileName)
CheckFileConfigurationIsComplete(propertiesFileName)
# add configured properties to zip
ExecuteOSCommand("zip -r " + unzippedPackagePath + scriptGlobals.osDirSeparator + module.subModule.relativeJarFilesPath + scriptGlobals.osDirSeparator + jarFile + " " + propertiesFileName, '')
# delete properties from current dir
DeleteDirOrFile(propertiesFileName);
# run migration jar
jarCommand = "java -jar " + unzippedPackagePath + scriptGlobals.osDirSeparator + module.subModule.relativeJarFilesPath + scriptGlobals.osDirSeparator + jarFile
log.info("Jar file " + jarFile + "will be executed with the following command \n" + jarCommand)
ExecuteOSCommand(jarCommand, '')
def __init__(self, module):
'''
Constructor
'''
ActionBundle.__init__(self, module)
# Initialize application server object
# appServer = ApplicationServer(module, scriptGlobals.appsrvProperties)
# Generate a unique ActionBundle execution id
guid = generateGUID()
log.info("Unique ActionBundle execution ID generated: " + guid)
# Check if standalone is running
if getProcessPIDByPathAndIdentifier(module.targetDeploymentPath, module.subModule.processIdentifier): die("\n\nThe " + module.subModule.name + " server at '" + module.targetDeploymentPath + "' is up. Installation will not continue\n")
exists="true"
# Check if module is already installed
for k, v in module.relativeCopyableFilesOrFolders.items():
exactLocation = module.targetDeploymentPath + scriptGlobals.osDirSeparator + v
if not os.path.isdir(exactLocation):
exists = "false"
#die(module.subModule.name + " is Not already installed to:" + module.targetDeploymentPath + ". Maybe you want to make a clean Installation !!")
previousVersionInfo=""
previousBuildInfo=""
previousRevisionInfo=""
if (exists == "true"):
# Get Previous Hudson data
previousManifilePath = module.targetDeploymentPath + scriptGlobals.osDirSeparator + module.subModule.name + scriptGlobals.osDirSeparator + "META-INF" + scriptGlobals.osDirSeparator + "MANIFEST.MF"
previousVersionInfo = grepFile(module.versionInformationRegex, previousManifilePath)
previousBuildInfo = grepFile(module.buildInformationRegex, previousManifilePath)
previousRevisionInfo = grepFile(module.revisionInformationRegex, previousManifilePath)
previousVersionInfo = (previousVersionInfo.replace(module.versionInformationRegex, "")).strip()
previousRevisionInfo = (previousRevisionInfo.replace(module.revisionInformationRegex, "")).strip()
if previousBuildInfo != None:
previousBuildInfo = (previousBuildInfo.replace(module.buildInformationRegex, "")).strip()
# Prepare directory to keep backups
previousVersionBackupPath = createDirectoriesRecursively(scriptGlobals.workingDir + scriptGlobals.osDirSeparator + "previousVersionBackup")
# Backup standalone
if (lib.OptParser.action !="install-nodb-nobackup" and exists == "true"):
for k, v in module.relativeCopyableFilesOrFolders.items():
exactLocation = module.targetDeploymentPath + scriptGlobals.osDirSeparator + v
exactBackupLocation = previousVersionBackupPath + scriptGlobals.osDirSeparator + k
CopyDirOrFile3(exactLocation, exactBackupLocation)
if exactLocation.find(module.subModule.name) != -1 :
DeleteDirOrFile(exactLocation)
# Prepare directory to unpack package
unzippedPackagePath = createDirectoriesRecursively(scriptGlobals.workingDir + scriptGlobals.osDirSeparator + "unzippedPackage")
# Extract MSM package into tmp dir
ExtractZipToDir(module.moduleFilename, unzippedPackagePath)
# CreateDirectory(unzippedPackagePath + "/bin/" + module.subModule.name)
# ExtractZipToDir(unzippedPackagePath + "/bin/" + module.subModule.name + ".war", unzippedPackagePath + "/bin/" + module.subModule.name)
filenameToExtract = "META-INF/MANIFEST.MF"
zipFilename = unzippedPackagePath + "/bin/" + module.subModule.name + "/lib/" + module.subModule.name +".jar"
location = unzippedPackagePath + "/bin/" + module.subModule.name + "/META-INF"
ExtractFileFromZipToDir(zipFilename, filenameToExtract, location)
# Configure xxx.properties in tmp/../conf using envprops
for k, v in module.relativeConfigurationFiles.items():
exactExtractedLocation = unzippedPackagePath + scriptGlobals.osDirSeparator + k
ConfigureTemplateFile(module.name, lib.OptParser.options.envprops, exactExtractedLocation)
CheckFileConfigurationIsComplete(exactExtractedLocation)
# Copy relativeCopyableFilesOrFolders to specified locations on Server (values)
for k, v in module.relativeCopyableFilesOrFolders.items():
exactExtractedLocation = unzippedPackagePath + scriptGlobals.osDirSeparator + k
exactTargetLocation = module.targetDeploymentPath + scriptGlobals.osDirSeparator + v
CopyDirOrFile(exactExtractedLocation, exactTargetLocation)
# Copy tmp/../conf/xxx.properties to to specified locations on Server (values)
for k, v in module.relativeConfigurationFiles.items():
exactExtractedLocation = unzippedPackagePath + scriptGlobals.osDirSeparator + k
exactTargetLocation = module.targetDeploymentPath + scriptGlobals.osDirSeparator + v
CopyDirOrFile(exactExtractedLocation, exactTargetLocation)
if (module.subModule.name == "mrouter"):
exactExtractedLocation = unzippedPackagePath + scriptGlobals.osDirSeparator + module._locations['relativeStartupScript']
ChangePathPermissions(exactExtractedLocation, 0777)
CopyDirOrFile2(exactExtractedLocation, module.targetDeploymentPath)
path1 = module.targetDeploymentPath + "/" + module.subModule.name + "/bin"
ChangePathPermissions(path1, 0744)
# Find version/revision info
versionInfo = grepFile(module.versionInformationRegex, unzippedPackagePath + scriptGlobals.osDirSeparator + module.relativeVersionInformationPath)
versionInfo = (versionInfo.replace(module.versionInformationRegex, "")).strip()
revisionInfo = grepFile(module.revisionInformationRegex, unzippedPackagePath + scriptGlobals.osDirSeparator + module.relativeVersionInformationPath)
revisionInfo = (revisionInfo.replace(module.revisionInformationRegex, "")).strip()
buildInfo = grepFile(module.buildInformationRegex, unzippedPackagePath + scriptGlobals.osDirSeparator + module.relativeVersionInformationPath)
if buildInfo != None:
buildInfo = (buildInfo.replace(module.buildInformationRegex, "")).strip()
if (lib.OptParser.action == "install-update" or lib.OptParser.action == "_customUpgrade"):
moduleDeployPath = module.targetDeploymentPath + "/" + module.subModule.name
path1 = moduleDeployPath + "/bin"
ChangePathPermissions(path1, 0744)
path2 = moduleDeployPath + "/" + module.subModule.installUpdateScript
if (lib.OptParser.action == "_customUpgrade"):
path2=path2 + " UPGRADE YES "
else:
path2=path2 + " UPDATE YES "
ExecuteOSCommand(path2, None)
# Construct the email notification
emailSender = readPropertyFromPropertiesFileWithFallback("emailNotificationSenderAddress", scriptGlobals.scriptVarSectionName, lib.OptParser.options.envprops, scriptGlobals.emailNotificationSenderAddress)
emailRecipients = scriptGlobals.globalNotificationEmailList
emailSubject = "MSM Installation: " + module.name + "@"+ getCurrentHostname() + " (" + module.friendlyServerName + ")"
emailText = detailedUpdateInstallationReportTemplate(module.subModule.name,
versionInfo,
lib.OptParser.options.action,
getCurrentHostname(),
os.getcwd(),
guid,
" ".join(platform.uname()),
getpass.getuser(),
buildInfo,
revisionInfo,
lib.OptParser.options.envprops,
previousVersionInfo,
previousBuildInfo,
previousRevisionInfo,
scriptGlobals.workingDir)
# Email all required parties
SendEmail(emailSender,
emailRecipients,
emailSubject,
emailText,
scriptGlobals.smtpHost,
scriptGlobals.smtpPort)
def __init__(self, module):
'''
Constructor
'''
ActionBundle.__init__(self, module)
# Initialize application server object
# appServer = ApplicationServer(module, scriptGlobals.appsrvProperties)
# Generate a unique ActionBundle execution id
guid = generateGUID()
log.info("Unique ActionBundle execution ID generated: " + guid)
# Check if Server is running
if getProcessPIDByPathAndIdentifier(module.targetDeploymentPath, module.subModule.processIdentifier): die("\n\nThe " + module.subModule.name + " server at '" + module.targetDeploymentPath + "' is up. Installation will not continue\n")
# Check if module exists.
for k, v in module.relativeCopyableFilesOrFolders.items():
exactTargetLocation = module.targetDeploymentPath + scriptGlobals.osDirSeparator + v
if os.path.isdir(exactTargetLocation):
log.info("\n###############################################################################################\n" + module.subModule.name
+ " is already installed under:" + module.targetDeploymentPath
+ ". Please manually backup and remove to run a clean installation (unless you want to update)\n###############################################################################################")
die()
# Prepare directory to unpack package
unzippedPackagePath = createDirectoriesRecursively(scriptGlobals.workingDir + scriptGlobals.osDirSeparator + "unzippedPackage")
# Extract MSM package into tmp dir
ExtractZipToDir(module.moduleFilename, unzippedPackagePath)
filenameToExtract = "META-INF/MANIFEST.MF"
zipFilename = unzippedPackagePath + "/bin/" + module.subModule.name + "/lib/" + module.subModule.name +".jar"
location = unzippedPackagePath + "/bin/" + module.subModule.name + "/META-INF"
ExtractFileFromZipToDir(zipFilename, filenameToExtract, location)
# Configure xxx.properties in tmp/../conf using envprops
for k, v in module.relativeConfigurationFiles.items():
exactExtractedLocation = unzippedPackagePath + scriptGlobals.osDirSeparator + k
ConfigureTemplateFile(module.name, lib.OptParser.options.envprops, exactExtractedLocation)
CheckFileConfigurationIsComplete(exactExtractedLocation)
# Copy relativeCopyableFilesOrFolders to specified locations on Server (values)
for k, v in module.relativeCopyableFilesOrFolders.items():
exactExtractedLocation = unzippedPackagePath + scriptGlobals.osDirSeparator + k
exactTargetLocation = module.targetDeploymentPath + scriptGlobals.osDirSeparator + v
CopyDirOrFile(exactExtractedLocation, exactTargetLocation)
# Copy tmp/../conf/xxx.properties to to specified locations on Server (values)
for k, v in module.relativeConfigurationFiles.items():
exactExtractedLocation = unzippedPackagePath + scriptGlobals.osDirSeparator + k
exactTargetLocation = module.targetDeploymentPath + scriptGlobals.osDirSeparator + v
CopyDirOrFile(exactExtractedLocation, exactTargetLocation)
if (module.subModule.name == "mrouter"):
exactExtractedLocation = unzippedPackagePath + scriptGlobals.osDirSeparator + module._locations['relativeStartupScript']
ChangePathPermissions(exactExtractedLocation, 0777)
CopyDirOrFile2(exactExtractedLocation, module.targetDeploymentPath)
# Find version/revision info
versionInfo = grepFile(module.versionInformationRegex, unzippedPackagePath + scriptGlobals.osDirSeparator + module.relativeVersionInformationPath)
versionInfo = (versionInfo.replace(module.versionInformationRegex, "")).strip()
revisionInfo = grepFile(module.revisionInformationRegex, unzippedPackagePath + scriptGlobals.osDirSeparator + module.relativeVersionInformationPath)
revisionInfo = (revisionInfo.replace(module.revisionInformationRegex, "")).strip()
buildInfo = grepFile(module.buildInformationRegex, unzippedPackagePath + scriptGlobals.osDirSeparator + module.relativeVersionInformationPath)
if buildInfo != None:
buildInfo = (buildInfo.replace(module.buildInformationRegex, "")).strip()
moduleDeployPath = module.targetDeploymentPath + "/" + module.subModule.name
path1 = moduleDeployPath + "/bin"
ChangePathPermissions(path1, 0744)
path2 = moduleDeployPath + "/" + module.subModule.installUpdateScript
path2=path2 + " CREATE YES "
ExecuteOSCommand(path2, None)
##ExecuteOSCommandAndCaptureOutput(path1,"ERROR", None, None)
##THIS ExecuteOSCommand(path1, None)
##ExecuteOSCommandAndCaptureOutput("cd " + path1, None, None)
# Construct the email notification
emailSender = readPropertyFromPropertiesFileWithFallback("emailNotificationSenderAddress", scriptGlobals.scriptVarSectionName, lib.OptParser.options.envprops, scriptGlobals.emailNotificationSenderAddress)
emailRecipients = scriptGlobals.globalNotificationEmailList
emailSubject = "MSM Installation: " + module.name + "@"+ getCurrentHostname() + " (" + module.friendlyServerName + ")"
emailText = detailedCleanInstallationReportTemplate(module.subModule.name,
versionInfo,
lib.OptParser.options.action,
getCurrentHostname(),
os.getcwd(),
guid,
" ".join(platform.uname()),
getpass.getuser(),
buildInfo,
revisionInfo,
lib.OptParser.options.envprops,
scriptGlobals.workingDir)
# Email all required parties
SendEmail(emailSender,
emailRecipients,
emailSubject,
emailText,
scriptGlobals.smtpHost,
scriptGlobals.smtpPort)
def __init__(self, module):
"""
Constructor
"""
ActionBundle.__init__(self, module)
# Initialize application server object
appServer = ApplicationServer(module, scriptGlobals.appsrvProperties)
# Generate a unique ActionBundle execution id
guid = generateGUID()
log.info("Unique ActionBundle execution ID generated: " + guid)
# Check if Tomcat is running
if getProcessPIDByPathAndIdentifier(module.targetDeploymentPath, appServer.processIdentifier):
die("\n\nThe Jboss server at '" + module.targetDeploymentPath + "' is up. Installation will not continue")
# Since MSM is deployed on JBOSS some paths have an %s to allow a configurable
# profile, so do a little sprintf to fix them
sprintfOnDictionaryValues(module.relativeConfigurationFiles, module.targetDeploymentProfile)
sprintfOnDictionaryValues(module.relativeCopyableFilesOrFolders, module.targetDeploymentProfile)
# For JbosswebappPath = "/server/" + module.targetDeploymentProfile + "/deploy/" + module.subModule.name + ".war"
# for Tomcat webappPath = "/webapps/" + module.subModule.name
webappPath = "/webapps/" + module.subModule.name
# Check if module exists.
for k, v in module.relativeCopyableFilesOrFolders.items():
exactTargetLocation = module.targetDeploymentPath + scriptGlobals.osDirSeparator + v
if exactTargetLocation.find(webappPath) != -1:
if not os.path.isdir(exactTargetLocation):
die(
"\n\n"
+ module.subModule.name
+ " is not installed under:"
+ module.targetDeploymentPath
+ ". Please first run a clean installation"
)
# Get Previous Hudson data
previousManifilePath = module.targetDeploymentPath + webappPath + "/META-INF/MANIFEST.MF"
previousVersionInfo = grepFile(module.versionInformationRegex, previousManifilePath)
previousBuildInfo = grepFile(module.buildInformationRegex, previousManifilePath)
previousRevisionInfo = grepFile(module.revisionInformationRegex, previousManifilePath)
previousVersionInfo = (previousVersionInfo.replace(module.versionInformationRegex, "")).strip()
if previousBuildInfo != None:
previousBuildInfo = (previousBuildInfo.replace(module.buildInformationRegex, "")).strip()
previousRevisionInfo = (previousRevisionInfo.replace(module.revisionInformationRegex, "")).strip()
# Prepare directory to keep backups
previousVersionBackupPath = createDirectoriesRecursively(
scriptGlobals.workingDir + scriptGlobals.osDirSeparator + "previousVersionBackup"
)
# Backup webapps
if lib.OptParser.action != "install-nodb-nobackup":
for k, v in module.relativeCopyableFilesOrFolders.items():
exactLocation = module.targetDeploymentPath + scriptGlobals.osDirSeparator + v
exactBackupLocation = previousVersionBackupPath + scriptGlobals.osDirSeparator + k
CopyDirOrFile3(exactLocation, exactBackupLocation)
# Prepare directory to unpack package
unzippedPackagePath = createDirectoriesRecursively(
scriptGlobals.workingDir + scriptGlobals.osDirSeparator + "unzippedPackage"
)
# Extract MSM package into tmp dir
ExtractZipToDir(module.moduleFilename, unzippedPackagePath)
CreateDirectory(unzippedPackagePath + "/bin/" + module.subModule.name)
ExtractZipToDir(
unzippedPackagePath + "/bin/" + module.subModule.name + ".war",
unzippedPackagePath + "/bin/" + module.subModule.name,
)
# Configure xxx.properties in tmp/../conf using envprops
for k, v in module.relativeConfigurationFiles.items():
exactExtractedLocation = unzippedPackagePath + scriptGlobals.osDirSeparator + k
ConfigureTemplateFile(module.name, lib.OptParser.options.envprops, exactExtractedLocation)
CheckFileConfigurationIsComplete(exactExtractedLocation)
# Copy tmp/../conf/xxx.properties to to specified locations on Server (values)
for k, v in module.relativeConfigurationFiles.items():
exactExtractedLocation = unzippedPackagePath + scriptGlobals.osDirSeparator + k
exactTargetLocation = module.targetDeploymentPath + scriptGlobals.osDirSeparator + v
CopyDirOrFile(exactExtractedLocation, exactTargetLocation)
# Construct the email notification
emailSender = readPropertyFromPropertiesFileWithFallback(
"emailNotificationSenderAddress",
scriptGlobals.scriptVarSectionName,
lib.OptParser.options.envprops,
scriptGlobals.emailNotificationSenderAddress,
)
emailRecipients = scriptGlobals.globalNotificationEmailList
emailSubject = (
"MSM Installation: "
+ module.subModule.name
+ "@"
+ getCurrentHostname()
+ " ("
+ module.friendlyServerName
+ ")"
)
emailText = detailedUpdateInstallationReportTemplate(
module.subModule.name,
previousVersionInfo,
lib.OptParser.options.action,
getCurrentHostname(),
os.getcwd(),
guid,
" ".join(platform.uname()),
getpass.getuser(),
previousBuildInfo,
previousRevisionInfo,
lib.OptParser.options.envprops,
previousVersionInfo,
previousBuildInfo,
previousRevisionInfo,
scriptGlobals.workingDir,
)
# Email all required parties
SendEmail(emailSender, emailRecipients, emailSubject, emailText, scriptGlobals.smtpHost, scriptGlobals.smtpPort)
def __init__(self, module):
"""
Constructor
"""
ActionBundle.__init__(self, module)
# Initialize application server object
appServer = ApplicationServer(module, scriptGlobals.appsrvProperties)
# Generate a unique ActionBundle execution id
guid = generateGUID()
log.info("Unique ActionBundle execution ID generated: " + guid)
# Check if Tomcat is running
if getProcessPIDByPathAndIdentifier(module.targetDeploymentPath, appServer.processIdentifier):
die("\n\nThe Jboss server at '" + module.targetDeploymentPath + "' is up. Installation will not continue")
# Since MSM is deployed on JBOSS some paths have an %s to allow a configurable
# profile, so do a little sprintf to fix them
sprintfOnDictionaryValues(module.relativeConfigurationFiles, module.targetDeploymentProfile)
sprintfOnDictionaryValues(module.relativeCopyableFilesOrFolders, module.targetDeploymentProfile)
# For JbosswebappPath = "/server/" + module.targetDeploymentProfile + "/deploy/" + module.subModule.name + ".war"
# for Tomcat webappPath = "/webapps/" + module.subModule.name
webappPath = "/webapps/" + module.subModule.name
# Check if module exists.
for k, v in module.relativeCopyableFilesOrFolders.items():
exactTargetLocation = module.targetDeploymentPath + scriptGlobals.osDirSeparator + v
if exactTargetLocation.find(webappPath) != -1:
if os.path.isdir(exactTargetLocation):
log.info(
"\n##############################################################\n"
+ module.subModule.name
+ " is already installed under:"
+ module.targetDeploymentPath
+ ". Please manually backup and remove to run a clean installation (unless you want to update)\n##############################################################"
)
die()
# Prepare directory to unpack package
unzippedPackagePath = createDirectoriesRecursively(
scriptGlobals.workingDir + scriptGlobals.osDirSeparator + "unzippedPackage"
)
# Extract MSM package into tmp dir
ExtractZipToDir(module.moduleFilename, unzippedPackagePath)
CreateDirectory(unzippedPackagePath + "/bin/" + module.subModule.name)
ExtractZipToDir(
unzippedPackagePath + "/bin/" + module.subModule.name + ".war",
unzippedPackagePath + "/bin/" + module.subModule.name,
)
# Configure xxx.properties in tmp/../conf using envprops
for k, v in module.relativeConfigurationFiles.items():
exactExtractedLocation = unzippedPackagePath + scriptGlobals.osDirSeparator + k
ConfigureTemplateFile(module.name, lib.OptParser.options.envprops, exactExtractedLocation)
CheckFileConfigurationIsComplete(exactExtractedLocation)
# Copy relativeCopyableFilesOrFolders to specified locations on Server (values)
for k, v in module.relativeCopyableFilesOrFolders.items():
exactExtractedLocation = unzippedPackagePath + scriptGlobals.osDirSeparator + k
exactTargetLocation = module.targetDeploymentPath + scriptGlobals.osDirSeparator + v
CopyDirOrFile(exactExtractedLocation, exactTargetLocation)
# Copy tmp/../conf/xxx.properties to to specified locations on Server (values)
for k, v in module.relativeConfigurationFiles.items():
exactExtractedLocation = unzippedPackagePath + scriptGlobals.osDirSeparator + k
exactTargetLocation = module.targetDeploymentPath + scriptGlobals.osDirSeparator + v
CopyDirOrFile(exactExtractedLocation, exactTargetLocation)
# Find version/revision info
revisionInfo = grepFile(
module.revisionInformationRegex,
unzippedPackagePath + scriptGlobals.osDirSeparator + module.relativeVersionInformationPath,
)
revisionInfo = (revisionInfo.replace(module.revisionInformationRegex, "")).strip()
versionInfo = grepFile(
module.versionInformationRegex,
unzippedPackagePath + scriptGlobals.osDirSeparator + module.relativeVersionInformationPath,
)
versionInfo = (versionInfo.replace(module.versionInformationRegex, "")).strip()
buildInfo = grepFile(
module.buildInformationRegex,
unzippedPackagePath + scriptGlobals.osDirSeparator + module.relativeVersionInformationPath,
)
if buildInfo != None:
buildInfo = (buildInfo.replace(module.buildInformationRegex, "")).strip()
# Run CREATE/UPDATE/UPGRADE script
if module.subModule.installUpdateScript != "":
path1 = module.targetDeploymentPath + webappPath + "/" + module.subModule.installUpdateScript
ChangePathPermissions(path1, 0744)
path1 = path1 + " CREATE YES "
ExecuteOSCommand(path1, None)
# Construct the email notification
emailSender = readPropertyFromPropertiesFileWithFallback(
"emailNotificationSenderAddress",
scriptGlobals.scriptVarSectionName,
lib.OptParser.options.envprops,
scriptGlobals.emailNotificationSenderAddress,
)
emailRecipients = scriptGlobals.globalNotificationEmailList
emailSubject = (
"MSM Installation: "
+ module.subModule.name
+ "@"
+ getCurrentHostname()
+ " ("
+ module.friendlyServerName
+ ")"
)
emailText = detailedCleanInstallationReportTemplate(
module.subModule.name,
versionInfo,
lib.OptParser.options.action,
getCurrentHostname(),
os.getcwd(),
guid,
" ".join(platform.uname()),
getpass.getuser(),
buildInfo,
revisionInfo,
lib.OptParser.options.envprops,
scriptGlobals.workingDir,
)
# Email all required parties
SendEmail(emailSender, emailRecipients, emailSubject, emailText, scriptGlobals.smtpHost, scriptGlobals.smtpPort)
def __init__(self, module):
"""
Constructor
"""
ActionBundle.__init__(self, module)
unzippedPackagePath = module.executionContext["unzippedPackagePath"]
versionInfo = module.executionContext["versionInfo"]
revisionInfo = module.executionContext["revisionInfo"]
majorVersionInfo = module.executionContext["majorVersionInfo"]
guid = module.executionContext["guid"]
# Compose Oracle DB Connection String
oracleConnectionString = "%s/%s@%s" % (
extractOracleDatabaseCredentials(
module.name,
lib.OptParser.options.envprops,
"VNA_CRM_USERNAMEBASE",
"VNA_CRM_PASSWORDBASE",
"DBConnectionString",
)
)
# Determine last executed script
result = getLatestExecutedScript(versionInfo, majorVersionInfo, oracleConnectionString)
lastExecutedPath, lastExecutedFilename = os.path.split(result.strip())
if "no rows selected" in lastExecutedFilename:
answer = getAnswerFromUser(
"Unable to determine last executed script on '"
+ oracleConnectionString
+ "'. There is a possibility that the scripts in the log table are of an older major version than '"
+ majorVersionInfo
+ "'. (In this case you may want to run all the scripts in your upgrade folder '"
+ unzippedPackagePath
+ scriptGlobals.osDirSeparator
+ module.relativeDatabaseUpgradeFilePath
+ "'). \n\nSelect your actions: \n(E) Execute all scripts in the upgrade folder in alphabetical order \n(<any other key>) Don't run any scripts and continue installation: "
)
if (re.compile("^e$", re.I)).match(answer):
log.info(
"Running ALL scripts contained in '"
+ unzippedPackagePath
+ scriptGlobals.osDirSeparator
+ module.relativeDatabaseUpgradeFilePath
+ "' in alphabetical order."
)
# Run scripts on DB
ls = os.listdir(
unzippedPackagePath + scriptGlobals.osDirSeparator + module.relativeDatabaseUpgradeFilePath
)
ls.sort()
for patch in ls:
appendRequiredStringsToOracleSQLFile(
unzippedPackagePath
+ scriptGlobals.osDirSeparator
+ module.relativeDatabaseUpgradeFilePath
+ scriptGlobals.osDirSeparator
+ patch
)
RunOracleScriptFromFile(
unzippedPackagePath
+ scriptGlobals.osDirSeparator
+ module.relativeDatabaseUpgradeFilePath
+ scriptGlobals.osDirSeparator
+ patch,
oracleConnectionString,
)
# Log executed scripts
logOracleScriptInDBLog(
patch,
guid,
lib.OptParser.options.action,
module.name,
versionInfo,
revisionInfo,
oracleConnectionString,
)
else:
log.info(
"According to log table, the last script executed on '"
+ oracleConnectionString
+ "' was '"
+ lastExecutedFilename
+ "'"
)
# Run scripts on DB
ls = os.listdir(unzippedPackagePath + scriptGlobals.osDirSeparator + module.relativeDatabaseUpgradeFilePath)
ls.sort()
found = False
for patch in ls:
if found:
appendRequiredStringsToOracleSQLFile(
unzippedPackagePath
+ scriptGlobals.osDirSeparator
+ module.relativeDatabaseUpgradeFilePath
+ scriptGlobals.osDirSeparator
+ patch
)
RunOracleScriptFromFile(
unzippedPackagePath
+ scriptGlobals.osDirSeparator
+ module.relativeDatabaseUpgradeFilePath
+ scriptGlobals.osDirSeparator
+ patch,
oracleConnectionString,
)
# Log executed scripts
logOracleScriptInDBLog(
patch,
guid,
lib.OptParser.options.action,
module.name,
versionInfo,
revisionInfo,
oracleConnectionString,
)
if patch == lastExecutedFilename:
found = True
def __init__(self, module):
"""
Constructor
"""
ActionBundle.__init__(self, module)
# Initialize application server object
appServer = ApplicationServer(module, scriptGlobals.appsrvProperties)
# Generate a unique ActionBundle execution id
guid = generateGUID()
log.info("Unique ActionBundle execution ID generated: " + guid)
# Since MSM is deployed on JBOSS some paths have an %s to allow a configurable
# profile, so do a little sprintf to fix them
sprintfOnDictionaryValues(module.relativeConfigurationFiles, module.targetDeploymentProfile)
sprintfOnDictionaryValues(module.relativeCopyableFilesOrFolders, module.targetDeploymentProfile)
# For JbosswebappPath = "/server/" + module.targetDeploymentProfile + "/deploy/" + module.subModule.name + ".war"
# for Tomcat webappPath = "/webapps/" + module.subModule.name
webappPath = "/webapps/" + module.subModule.name
# Check if module exists.
for k, v in module.relativeCopyableFilesOrFolders.items():
exactTargetLocation = module.targetDeploymentPath + scriptGlobals.osDirSeparator + v
if exactTargetLocation.find(webappPath) != -1:
if not os.path.isdir(exactTargetLocation):
die(
"\n\n"
+ module.subModule.name
+ " is not installed under:"
+ module.targetDeploymentPath
+ ". Please first run a clean installation"
)
# Get Previous Hudson data
previousManifilePath = module.targetDeploymentPath + webappPath + "/META-INF/MANIFEST.MF"
previousVersionInfo = grepFile(module.versionInformationRegex, previousManifilePath)
previousBuildInfo = grepFile(module.buildInformationRegex, previousManifilePath)
previousRevisionInfo = grepFile(module.revisionInformationRegex, previousManifilePath)
previousRevisionInfo = (previousRevisionInfo.replace(module.revisionInformationRegex, "")).strip()
previousVersionInfo = (previousVersionInfo.replace(module.versionInformationRegex, "")).strip()
if previousBuildInfo != None:
previousBuildInfo = (previousBuildInfo.replace(module.buildInformationRegex, "")).strip()
# Construct the email notification
emailSender = readPropertyFromPropertiesFileWithFallback(
"emailNotificationSenderAddress",
scriptGlobals.scriptVarSectionName,
lib.OptParser.options.envprops,
scriptGlobals.emailNotificationSenderAddress,
)
emailRecipients = scriptGlobals.globalNotificationEmailList
emailSubject = (
"MSM Installation: "
+ module.subModule.name
+ "@"
+ getCurrentHostname()
+ " ("
+ module.friendlyServerName
+ ")"
)
emailText = detailedCleanInstallationReportTemplate(
module.subModule.name,
previousVersionInfo,
lib.OptParser.options.action,
getCurrentHostname(),
os.getcwd(),
guid,
" ".join(platform.uname()),
getpass.getuser(),
previousBuildInfo,
previousRevisionInfo,
lib.OptParser.options.envprops,
scriptGlobals.workingDir,
)
# Email all required parties
SendEmail(emailSender, emailRecipients, emailSubject, emailText, scriptGlobals.smtpHost, scriptGlobals.smtpPort)
def __init__(self, module):
'''
Constructor
'''
ActionBundle.__init__(self, module)
# Generate a unique ActionBundle execution id
guid = generateGUID()
log.info("Unique ActionBundle execution ID generated: " + guid)
# Check if standalone is running
if getProcessPIDByPathAndIdentifier(module.targetDeploymentPath, module.subModule.processIdentifier): die("\n\nThe " + module.subModule.name + " server at '" + module.targetDeploymentPath + "' is up. Configuration will not continue\n")
# Check if module is already installed
for k, v in module.relativeCopyableFilesOrFolders.items():
exactLocation = module.targetDeploymentPath + scriptGlobals.osDirSeparator + v
if not os.path.isdir(exactLocation):
die(module.subModule.name + " is Not already installed to:" + module.targetDeploymentPath + ". Maybe you want to make a clean Installation !!")
# Get Previous Hudson data
previousManifilePath = module.targetDeploymentPath + scriptGlobals.osDirSeparator + module.subModule.name + scriptGlobals.osDirSeparator + "META-INF" + scriptGlobals.osDirSeparator + "MANIFEST.MF"
previousVersionInfo = grepFile(module.versionInformationRegex, previousManifilePath)
previousBuildInfo = grepFile(module.buildInformationRegex, previousManifilePath)
previousRevisionInfo = grepFile(module.revisionInformationRegex, previousManifilePath)
previousVersionInfo = (previousVersionInfo.replace(module.versionInformationRegex, "")).strip()
if previousBuildInfo != None:
previousBuildInfo = (previousBuildInfo.replace(module.buildInformationRegex, "")).strip()
previousRevisionInfo = (previousRevisionInfo.replace(module.revisionInformationRegex, "")).strip()
# Prepare directory to keep backups
previousVersionBackupPath = createDirectoriesRecursively(scriptGlobals.workingDir + scriptGlobals.osDirSeparator + "previousVersionBackup")
# Backup standalone
for k, v in module.relativeCopyableFilesOrFolders.items():
exactLocation = module.targetDeploymentPath + scriptGlobals.osDirSeparator + v
exactBackupLocation = previousVersionBackupPath + scriptGlobals.osDirSeparator + k
CopyDirOrFile3(exactLocation, exactBackupLocation)
# if exactLocation.find(module.subModule.name) != -1 :
# DeleteDirOrFile(exactLocation)
# Prepare directory to unpack package
unzippedPackagePath = createDirectoriesRecursively(scriptGlobals.workingDir + scriptGlobals.osDirSeparator + "unzippedPackage")
# Extract MSM package into tmp dir
ExtractZipToDir(module.moduleFilename, unzippedPackagePath)
filenameToExtract = "META-INF/MANIFEST.MF"
zipFilename = unzippedPackagePath + "/bin/" + module.subModule.name + "/lib/" + module.subModule.name +".jar"
location = unzippedPackagePath + "/bin/" + module.subModule.name + "/META-INF"
ExtractFileFromZipToDir(zipFilename, filenameToExtract, location)
# Configure xxx.properties in tmp/../conf using envprops
for k, v in module.relativeConfigurationFiles.items():
exactExtractedLocation = unzippedPackagePath + scriptGlobals.osDirSeparator + k
ConfigureTemplateFile(module.name, lib.OptParser.options.envprops, exactExtractedLocation)
CheckFileConfigurationIsComplete(exactExtractedLocation)
# Copy tmp/../conf/xxx.properties to to specified locations on Server (values)
for k, v in module.relativeConfigurationFiles.items():
exactExtractedLocation = unzippedPackagePath + scriptGlobals.osDirSeparator + k
exactTargetLocation = module.targetDeploymentPath + scriptGlobals.osDirSeparator + v
CopyDirOrFile(exactExtractedLocation, exactTargetLocation)
# Construct the email notification
emailSender = readPropertyFromPropertiesFileWithFallback("emailNotificationSenderAddress", scriptGlobals.scriptVarSectionName, lib.OptParser.options.envprops, scriptGlobals.emailNotificationSenderAddress)
emailRecipients = scriptGlobals.globalNotificationEmailList
emailSubject = "MSM Installation: " + module.name + "@"+ getCurrentHostname() + " (" + module.friendlyServerName + ")"
emailText = detailedUpdateInstallationReportTemplate(module.subModule.name,
previousVersionInfo,
lib.OptParser.options.action,
getCurrentHostname(),
os.getcwd(),
guid,
" ".join(platform.uname()),
getpass.getuser(),
previousBuildInfo,
previousRevisionInfo,
lib.OptParser.options.envprops,
previousVersionInfo,
previousBuildInfo,
previousRevisionInfo,
scriptGlobals.workingDir)
# Email all required parties
SendEmail(emailSender,
emailRecipients,
emailSubject,
emailText,
scriptGlobals.smtpHost,
scriptGlobals.smtpPort)
