From e174dfbaa0e00ea87d2f287aa24c1046e194512a Mon Sep 17 00:00:00 2001 From: Lokeswaranath Thota Date: Thu, 7 Mar 2024 22:44:14 +0530 Subject: [PATCH 01/10] GM upgradation script --- gm_01_py2.7.py | 130 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 130 insertions(+) create mode 100644 gm_01_py2.7.py diff --git a/gm_01_py2.7.py b/gm_01_py2.7.py new file mode 100644 index 0000000..597eadc --- /dev/null +++ b/gm_01_py2.7.py @@ -0,0 +1,130 @@ +#!/usr/bin/python +import os +import subprocess +from datetime import datetime +import time +import shutil +import logging +import argparse +import tarfile + +class GMSoftwareUpgrade: + def __init__(self,args): + self.now = datetime.now().strftime("%Y%m%d%H%M%S") + self.backupdir = args.backupdir + self.action = (args.action).lower() + self.backuptime = args.backuptime + self.imdir = args.imdir + self.responsefilepath = args.responsefilepath + self.appdatadir = args.appdatadir + self.ibmimsharedpath = args.ibmimsharedpath + self.installation_dir = args.installdir + self.log = args.log + swtype = "gm" + log_filename = os.path.join(self.backupdir, 'upgrade_sw_{}_{}.log'.format(swtype, self.now)) + logging.basicConfig(filename=log_filename, filemode='w', level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s') + + def run(self): + swtype = "gm" + + if self.action == 'stop': + logging.info('Stopping GM') + self.stop_gm() + elif self.action == 'backup': + logging.info('Backup Directory:{}'.format(self.backupdir)) + self.backup() + elif self.action == 'upgrade': + logging.info('Starting Upgrade of {} at:{}'.format(swtype, self.now)) + self.upgrade() + elif self.action == 'restore': + logging.info('Restoring files from {} to {}/properties at:{}'.format(self.backupdir, self.installation_dir, self.now)) + self.restore() + elif self.action == 'start': + logging.info('Starting GM') + self.start_gm() + else: + print("Missing/Invalid action parameter. Please verify!") + + + def stop_gm(self): + subprocess.call(["amf", "stop", "gm"]) + + + def tar_and_copy_folder(self, source_folder, destination_folder, tar_filename): + with tarfile.open('{}'.format(os.path.join(destination_folder,tar_filename+'.tar.gz')), "w:gz") as tar: + tar.add(source_folder, arcname=".") + + + + def backup(self): + reaper_conf_dir = os.path.join(self.installation_dir, "apache-cassandra", "reaper", "conf") + + shutil.copy2(os.path.join(reaper_conf_dir, "cassandra-reaper.yaml"), os.path.join(self.backupdir, "cassandra-reaper.yaml_{}.bkp".format(self.now))) # Use timestamp in backup file name + + + netstat_output = subprocess.check_output("netstat -an | grep 2181 | grep TIME_WAIT | wc -l", shell=True) + netstat_output = netstat_output.decode('utf-8') + + while netstat_output != "0\n": + zerocountflag = False + time.sleep(5) + netstat_output = subprocess.check_output("netstat -an | grep 2181 | grep TIME_WAIT | wc -l", shell=True) + netstat_output = netstat_output.decode('utf-8') + + if netstat_output == "0\n": + zerocountflag = True + + if zerocountflag: + for directory in ["ZOO", "CAS"]: + self.tar_and_copy_folder(os.path.join(self.installation_dir, directory), self.backupdir, '{}_{}'.format(directory, self.now)) + + self.tar_and_copy_folder(self.appdatadir, self.backupdir, '{}_{}'.format("appData", self.now)) + + self.tar_and_copy_folder(os.path.join(self.ibmimsharedpath,"IBMIMShared"), self.backupdir, '{}_{}'.format("IBMIMShared", self.now)) + + self.tar_and_copy_folder(self.installation_dir, self.backupdir, '{}_{}'.format("gm", self.now)) + + def upgrade(self): + + os.chdir(self.imdir) + + subprocess.call(["./imcl", "listInstalledPackages", "-verbose"]) + + subprocess.call([ + "./imcl", + "-input", self.responsefilepath, + "-dataLocation", self.appdatadir, + "-log", self.log, + "-acceptLicense" + ]) + + subprocess.call(["./imcl", "listInstalledPackages", "-verbose"]) + + + def restore(self): + reaper_conf_dir = os.path.join(self.installation_dir, "apache-cassandra", "reaper", "conf") + + shutil.copy2(os.path.join(reaper_conf_dir, "cassandra-reaper.yaml"), os.path.join(reaper_conf_dir, "cassandra-reaper.yaml_{}_patchfile.bkp".format(self.now))) + + shutil.copy2(os.path.join(self.backupdir, "cassandra-reaper.yaml_{}.bkp".format(self.backuptime)), os.path.join(reaper_conf_dir, "cassandra-reaper.yaml")) + + + def start_gm(self): + subprocess.call(["amf", "start", "gm"]) + + +if __name__ == "__main__": + + parser = argparse.ArgumentParser(description="Automation of Software Upgrade for GM") + parser.add_argument("-installdir", "-i", type=str, help="Installation Path") + parser.add_argument("-backupdir", "-b", type=str, help="Backup Path") + parser.add_argument("-action","-a", type=str,help="Type of action") + parser.add_argument("-imdir", "-im", type=str, help="Backup Path") + parser.add_argument("-responsefilepath", "-r", type=str, help="Response File Path") + parser.add_argument("-appdatadir", "-d", type=str, help="App Data Path") + parser.add_argument("-ibmimsharedpath", type=str, help="IBMIMSHARED Path") + parser.add_argument("-backuptime", help="Time of backup for restoring backup files") + parser.add_argument("-log", type=str, help="Log Path") + args = parser.parse_args() + swupgrade = GMSoftwareUpgrade(args) + swupgrade.run() \ No newline at end of file From 554086af5a1dd891eccc803a4315cafb27c8c26d Mon Sep 17 00:00:00 2001 From: Lokeswaranath Thota Date: Thu, 7 Mar 2024 23:53:03 +0530 Subject: [PATCH 02/10] GM upgradation script changes --- gm_01_py2.7.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/gm_01_py2.7.py b/gm_01_py2.7.py index 597eadc..0750151 100644 --- a/gm_01_py2.7.py +++ b/gm_01_py2.7.py @@ -106,7 +106,11 @@ def restore(self): shutil.copy2(os.path.join(reaper_conf_dir, "cassandra-reaper.yaml"), os.path.join(reaper_conf_dir, "cassandra-reaper.yaml_{}_patchfile.bkp".format(self.now))) - shutil.copy2(os.path.join(self.backupdir, "cassandra-reaper.yaml_{}.bkp".format(self.backuptime)), os.path.join(reaper_conf_dir, "cassandra-reaper.yaml")) + file = os.path.join(self.backupdir, "cassandra-reaper.yaml_{}.bkp".format(self.backuptime)) + pos1 = file_name.find('_') + pos2 = file_name.find('.',pos1) + source_file_name = file_name[:pos1] + file_name[pos2:] + shutil.copy2(source_file_name, os.path.join(reaper_conf_dir, "cassandra-reaper.yaml")) def start_gm(self): From dbdf020cab27c22b3807e280a68b0c0fd00910b1 Mon Sep 17 00:00:00 2001 From: Lokeswaranath Thota Date: Sat, 9 Mar 2024 16:46:03 +0530 Subject: [PATCH 03/10] sfg upgradation script --- b2bmgr/b2bmgr.py | 77 +++++++++++++++++++++++ b2bmgr/readme.txt | 28 +++++++++ b2bmgr/sfg.py | 153 ++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 258 insertions(+) create mode 100644 b2bmgr/b2bmgr.py create mode 100644 b2bmgr/readme.txt create mode 100644 b2bmgr/sfg.py diff --git a/b2bmgr/b2bmgr.py b/b2bmgr/b2bmgr.py new file mode 100644 index 0000000..d443cb9 --- /dev/null +++ b/b2bmgr/b2bmgr.py @@ -0,0 +1,77 @@ +#!/usr/bin/python +import argparse +import os +from datetime import datetime + + + +class B2BManager(object): + def __init__(self, args): + self.args = args + self.now = datetime.now().strftime("%Y%m%d%H%M%S") + self.action = args.action.lower() + self.installdir = args.installdir + self.backupdir = args.backupdir + self.imdir = args.imdir + self.responsefilepath = args.responsefilepath + self.appdatadir = args.appdatadir + self.ibmimsharedpath = args.ibmimsharedpath + self.IBM = args.IBM + self.ibm = args.ibm + self.uiupdatescript = args.uiupdatescript + self.jar = args.jar + self.log = args.log + self.backuptime = args.backuptime + self.hostname = os.environ.get('HOSTNAME') + self.homedir = os.environ.get('HOME') + self.swtype = args.swtype + + def run(self): + app = None + module = __import__(self.swtype, fromlist=[self.swtype]) + klass = getattr(module, self.swtype) + app = klass(self.now, self.args) + if app and self.action: + if self.action == 'start': + app.start() + elif self.action == 'stop': + app.stop() + elif self.action == 'backup': + app.backup() + elif self.action == 'upgrade': + app.upgrade() + elif self.action == 'restore': + app.restore_with_cleanup_timestamp() + elif self.action == 'run': + app.run(self.args) + else: + print("Invalid action. Please verify!") + return + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description='This is a script to automate the B2B upgrade process.') + parser.add_argument('-action', help='Action to be performed') + parser.add_argument('-swtype', help='Action to be performed') + + parser.add_argument('-installdir', help='The installation directory of the B2B product') + parser.add_argument('-backupdir', help='The directory where the backup files are located') + parser.add_argument('-imdir', help='The path to the Installation Manager') + parser.add_argument('-responsefilepath', help='The path to the response file') + parser.add_argument('-appdatadir', help='The path to the appData directory') + parser.add_argument("-ibmimsharedpath", type=str, help="IBMIMSHARED Path") + parser.add_argument("-IBM", type=str, help="IBM Path") + parser.add_argument("-ibm", type=str, help="ibm Path") + parser.add_argument("-uiupdatescript", help="SFG UI Update Script") + parser.add_argument('-backuptime', help='Time of backup for restoring backup files') + parser.add_argument('-log', help='The path to the log file') + parser.add_argument('-jar', help='The path to the jar file') + + print("B2B Manager started.") + args = parser.parse_args() + b2bmgr = B2BManager(args) + if b2bmgr.swtype and b2bmgr.action: + print('Running Service: {} with Action: {}'.format(b2bmgr.swtype.upper(), b2bmgr.action)) + b2bmgr.run() + else: + print('Invalid Service or Action. Please verify!') + print("B2B Manager stopped.") \ No newline at end of file diff --git a/b2bmgr/readme.txt b/b2bmgr/readme.txt new file mode 100644 index 0000000..7511a66 --- /dev/null +++ b/b2bmgr/readme.txt @@ -0,0 +1,28 @@ +START/STOP + ./b2bmgr.py -swtype sfg -action + +BACKUP + + FOR SFG + + ./b2bmgr.py -swtype sfg -action backup -installdir -backupdir -appdatadir -ibmimsharedpath -IBM -ibm + + ./b2bmgr.py -swtype sfg -action backup -installdir /apps/ibm/sfg -backupdir /apps/ibm/backup -appdatadir /apps/ibm/data -ibmimsharedpath /apps/ibm/im -IBM /home/mftadmin/IBM -ibm /home/mftadmin/var/ibm + + +UPGRADE + + FOR SFG + + ./b2bmgr.py -swtype sfg -action upgrade -installdir -imdir -responsefilepath -appdatadir -jar -log + + ./b2bmgr.py -swtype sfg -action upgrade -installdir /apps/ibm/sfg -imdir /apps/ibm/sw/sourcefiles/SFG/InstallationManager/IM_Linux/tools -responsefilepath /apps/ibm/sw/sourcefiles/SFG_RES.xml -appdatadir /apps/ibm/data -jar /apps/ibm/sw/SFG/packages/ -log /apps/ibm/backup + + +RESTORE, + + + FOR SFG + ./b2bmgr.py -swtype sfg -action restore -installdir -backupdir -backuptime -uiupdatescript + + ./b2bmgr.py -swtype sfg -action restore -installdir /apps/ibm/sfg -backupdir /apps/ibm/backup -backuptime 20240309160549 -uiupdatescript /opt/B2B_Shared/c7r7ff/IMA/modifySFG-UI.sh \ No newline at end of file diff --git a/b2bmgr/sfg.py b/b2bmgr/sfg.py new file mode 100644 index 0000000..361e5af --- /dev/null +++ b/b2bmgr/sfg.py @@ -0,0 +1,153 @@ +#!/usr/bin/python +import os +import subprocess +from datetime import datetime +import tarfile +import shutil +import logging +import argparse + +class sfg: + def __init__(self, now, args): + self.now = now + self.args = args + self.action = args.action.lower() + self.swtype = args.swtype + self.installation_dir = args.installdir + self.backupdir = args.backupdir + self.imdir = args.imdir + self.responsefilepath = args.responsefilepath + self.appdatadir = args.appdatadir + self.ibmimsharedpath = args.ibmimsharedpath + self.IBM = args.IBM + self.ibm = args.ibm + self.uiupdatescript = args.uiupdatescript + self.jar = args.jar + self.log = args.log + self.backuptime = args.backuptime + self.hostname = os.environ.get('HOSTNAME') + self.homedir = os.environ.get('HOME') + log_filename = os.path.join(self.backupdir, 'b2bmgr_{}_{}_{}.log'.format(self.swtype, self.action, self.now)) + logging.basicConfig(filename=log_filename, filemode='w', level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s') + + # def run(self, args): + # installation_dir = args.installdir + # backupdir = args.backupdir + # self.stop() + # self.backup(installation_dir, backupdir) + # self.upgrade(installation_dir, backupdir) + # self.start() + + # logging.info('Starting Upgrade of {} at:{}'.format(swtype, now)) + # logging.info('Backup Directory:{}'.format(backupdir)) + # logging.info('Installation Directory:{}'.format(installation_dir)) + + # self.stop_sfg() + # self.backup(installation_dir, backupdir) + # self.upgrade(installation_dir, backupdir) + # self.restore(installation_dir, backupdir) + # self.start_sfg() + + def stop(self): + subprocess.call(["amf", "stop", "sfg"]) + + def is_directory_empty(self,directory_path): + return len(os.listdir(directory_path)) == 0 + + def create_tar_archive(self, source_folder, destination_file, exclude_folders=None): + fileslist = [] + dirslist = [] + with tarfile.open(destination_file, "w:gz") as tar: + for root, dirs, files in os.walk(source_folder): + # Exclude top-level directories specified in exclude_dirs + if root == source_folder and exclude_folders: + dirs[:] = [d for d in dirs if d not in exclude_folders] + + nofiles = True + for file in files: + file_path = os.path.join(root, file) + if file_path not in fileslist: + tar.add(file_path, arcname=os.path.relpath(file_path, source_folder)) + fileslist.append(file_path) + nofiles = False + + # Add all directories to the tar archive, including empty ones + for dir_name in dirs: + dir_path = os.path.join(root, dir_name) + if self.is_directory_empty(dir_path): + tar.add(dir_path, arcname=os.path.relpath(dir_path, source_folder)) + + def backup(self): + properties_folder = os.path.join(self.installation_dir, "properties") + files_to_backup = [ + "cdinterop-spoe-auth.properties", + "cdinterop-spoe-policy.properties", + "cdinterop-spoe-policy.properties.in" + ] + backupfiles = [ + "cdinterop-spoe-auth_{}.properties".format(self.now), + "cdinterop-spoe-policy_{}.properties".format(self.now), + "cdinterop-spoe-policy_{}.properties.in".format(self.now) + ] + for file_name in files_to_backup: + shutil.copy2(os.path.join(properties_folder, file_name), os.path.join(self.backupdir, backupfiles[files_to_backup.index(file_name)])) + + home_dir = self.homedir + home_dir_formatted = home_dir.replace('/','_') + + self.create_tar_archive(self.installation_dir, "{}/{}_opt_B2B_sys_{}.tar.gz".format(self.backupdir, self.hostname, self.now), exclude_folders=['logs','backups']), + self.create_tar_archive(self.appdatadir, "{}/{}_opt_B2B_appData_{}.sys.tar.gz".format(self.backupdir, self.hostname, self.now)), + self.create_tar_archive(self.ibmimsharedpath, "{}/{}_opt_B2B_IBMIMShared_{}.sys.tar.gz".format(self.backupdir, self.hostname, self.now)), + + self.create_tar_archive(self.IBM, "{}/{}_opt_B2B_IBM_{}.sys.tar.gz".format(self.backupdir, self.hostname, self.now)), + self.create_tar_archive(self.ibm, "{}/{}_opt_B2B_ibm_{}.sys.tar.gz".format(self.backupdir, self.hostname, self.now)), + + self.create_tar_archive(os.path.join(home_dir, "etc"), "{}/{}_{}_etc_{}.sys.tar.gz".format(self.backupdir, self.hostname, home_dir_formatted, self.now)), + self.create_tar_archive(os.path.join(home_dir, "var"), "{}/{}_{}_var_{}.sys.tar.gz".format(self.backupdir, self.hostname, home_dir_formatted, self.now)) + + def upgrade(self): + sandbox_config = os.path.join(self.installation_dir, "properties", "sandbox.cfg") + with open(sandbox_config, "r") as file: + lines = file.readlines() + + with open(sandbox_config, "w") as file: + for line in lines: + if "JCE_DIST_FILE" not in line: + file.write(line) + else: + continue + + subprocess.call([ + + self.imdir+"/imcl", + "-input", self.responsefilepath, + "-dataLocation", self.appdatadir, + "-log", self.log, + "-acceptLicense" + ]) + os.chdir( os.path.join(self.installation_dir, "bin")) + subprocess.call([ + "./startCluster.sh", "1", "false" + ]) + + subprocess.call([ + "./InstallService.sh", self.jar + ]) + + def restore_with_cleanup_timestamp(self): + properties_folder = os.path.join(self.installation_dir, "properties") + files_to_restore = [ + "cdinterop-spoe-auth_{}.properties".format(self.backuptime), + "cdinterop-spoe-policy_{}.properties".format(self.backuptime), + "cdinterop-spoe-policy_{}.properties.in".format(self.backuptime) + ] + for file_name in files_to_restore: + pos1 = file_name.find('_') + pos2 = file_name.find('.',pos1) + source_file_name = file_name[:pos1] + file_name[pos2:] + shutil.copy2(os.path.join(self.backupdir, file_name), os.path.join(properties_folder, source_file_name)) + + subprocess.call(["sh", self.uiupdatescript]) + + def start(self): + subprocess.call(["amf", "start", "sfg"]) From 9ab3a24c9fbfc486d2cb0de507b4c3499b602382 Mon Sep 17 00:00:00 2001 From: Lokeswaranath Thota Date: Sat, 9 Mar 2024 18:43:23 +0530 Subject: [PATCH 04/10] gm updradation script in b2bmgr --- b2bmgr/gm.py | 97 +++++++++++++++++++++++++++++++++++++++++++++++ b2bmgr/readme.txt | 22 ++++++++++- 2 files changed, 117 insertions(+), 2 deletions(-) create mode 100644 b2bmgr/gm.py diff --git a/b2bmgr/gm.py b/b2bmgr/gm.py new file mode 100644 index 0000000..8f025e4 --- /dev/null +++ b/b2bmgr/gm.py @@ -0,0 +1,97 @@ +#!/usr/bin/python +import os +import subprocess +from datetime import datetime +import shutil +import logging +import argparse +import tarfile + +class gm: + def __init__(self, now, args): + self.now = now + self.args = args + self.action = args.action.lower() + self.swtype = args.swtype + self.backupdir = args.backupdir + self.imdir = args.imdir + self.backuptime = args.backuptime + self.responsefilepath = args.responsefilepath + self.appdatadir = args.appdatadir + self.ibmimsharedpath = args.ibmimsharedpath + self.installation_dir = args.installdir + self.log = args.log + self.hostname = os.environ.get('HOSTNAME') + self.homedir = os.environ.get('HOME') + log_filename = os.path.join(self.backupdir, 'b2bmgr_{}_{}_{}.log'.format(self.swtype, self.action, self.now)) + logging.basicConfig(filename=log_filename, filemode='w', level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s') + + # def run(self, args): + # installation_dir = args.installdir + # now = datetime.now() + # timestamp = now.strftime("%Y%m%d%H%M%S") + # logging.info('Starting Upgrade of {} at:{}'.format(swtype, self.now)) + # logging.info('Backup Directory:{}'.format(self.backupdir)) + # logging.info('Installation Directory:{}'.format(installation_dir)) + # self.stop_gm() + # self.backup() + # self.upgrade() + # self.start_gm() + + def stop(self): + subprocess.call(["amf", "stop", "gm"]) + + def tar_and_copy_folder(self, source_folder, destination_folder, tar_filename): + with tarfile.open('{}'.format(os.path.join(destination_folder,tar_filename+'.tar.gz')), "w:gz") as tar: + tar.add(source_folder, arcname=".") + + def backup(self): + reaper_conf_dir = os.path.join(self.installation_dir, "apache-cassandra", "reaper", "conf") + shutil.copy2(os.path.join(reaper_conf_dir, "cassandra-reaper.yaml"), os.path.join(self.backupdir, "cassandra-reaper.yaml_{}.bkp".format(self.now))) + + netstat_output = subprocess.check_output("netstat -an | grep 2181 | grep TIME_WAIT | wc -l", shell=True) + netstat_output = netstat_output.decode('utf-8') + + while netstat_output != "0\n": + zerocountflag = False + time.sleep(5) + netstat_output = subprocess.check_output("netstat -an | grep 2181 | grep TIME_WAIT | wc -l", shell=True) + netstat_output = netstat_output.decode('utf-8') + + if netstat_output == "0\n": + zerocountflag = True + + if zerocountflag: + for directory in ["ZOO", "CAS"]: + self.tar_and_copy_folder(os.path.join(self.installation_dir, directory), self.backupdir, '{}_{}'.format(directory, self.now)) + + self.tar_and_copy_folder(self.appdatadir, self.backupdir, '{}_{}'.format("appData", self.now)) + + self.tar_and_copy_folder(os.path.join(self.ibmimsharedpath,"IBMIMShared"), self.backupdir, '{}_{}'.format("IBMIMShared", self.now)) + + self.tar_and_copy_folder(self.installation_dir, self.backupdir, '{}_{}'.format("gm", self.now)) + + def upgrade(self): + os.chdir(self.imdir) + subprocess.call(["./imcl", "listInstalledPackages", "-verbose"]) + subprocess.call([ + "./imcl", + "-input", self.responsefilepath, + "-dataLocation", self.appdatadir, + "-log", self.log, + "-acceptLicense" + ]) + subprocess.call(["./imcl", "listInstalledPackages", "-verbose"]) + + + def restore_with_cleanup_timestamp(self): + reaper_conf_dir = os.path.join(self.installation_dir, "apache-cassandra", "reaper", "conf") + shutil.copy2(os.path.join(reaper_conf_dir, "cassandra-reaper.yaml"), os.path.join(reaper_conf_dir, "cassandra-reaper.yaml_{}_patchfile.bkp".format(self.now))) + + source_file_name = os.path.join(self.backupdir, "cassandra-reaper.yaml_{}.bkp".format(self.backuptime)) + + shutil.copy2(source_file_name, os.path.join(reaper_conf_dir, "cassandra-reaper.yaml")) + + def start(self): + subprocess.call(["amf", "start", "gm"]) + diff --git a/b2bmgr/readme.txt b/b2bmgr/readme.txt index 7511a66..1f10cc1 100644 --- a/b2bmgr/readme.txt +++ b/b2bmgr/readme.txt @@ -1,7 +1,13 @@ START/STOP - ./b2bmgr.py -swtype sfg -action + ./b2bmgr.py -swtype sfg/gm -action BACKUP + + FOR GM + + ./b2bmgr.py -swtype gm -action backup -installdir -backupdir -appdatadir -ibmimsharedpath + + ./b2bmgr.py -swtype gm -action backup -installdir /apps/ibm/gm -backupdir /apps/ibm/backup -appdatadir /apps/ibm/data -ibmimsharedpath /apps/ibm/im FOR SFG @@ -12,6 +18,12 @@ BACKUP UPGRADE + FOR GM + + ./b2bmgr.py -swtype gm -action upgrade -installdir -imdir -responsefilepath -appdatadir -log + + ./b2bmgr.py -swtype gm -action upgrade -installdir /apps/ibm/gm -imdir apps/ibm/sw/sourcefiles/SFG/InstallationManager/IM_Linux/tools -responsefilepath /apps/ibm/sw/sourcefiles/CASS_RES.xml -appdatadir /apps/ibm/data -log /apps/ibm/backup + FOR SFG ./b2bmgr.py -swtype sfg -action upgrade -installdir -imdir -responsefilepath -appdatadir -jar -log @@ -19,10 +31,16 @@ UPGRADE ./b2bmgr.py -swtype sfg -action upgrade -installdir /apps/ibm/sfg -imdir /apps/ibm/sw/sourcefiles/SFG/InstallationManager/IM_Linux/tools -responsefilepath /apps/ibm/sw/sourcefiles/SFG_RES.xml -appdatadir /apps/ibm/data -jar /apps/ibm/sw/SFG/packages/ -log /apps/ibm/backup -RESTORE, +RESTORE + + FOR GM + ./b2bmgr.py -swtype gm -action restore -installdir -backupdir -backuptime + + ./b2bmgr.py -swtype gm -action restore -installdir /apps/ibm/gm -backupdir /apps/ibm/backup -backuptime FOR SFG + ./b2bmgr.py -swtype sfg -action restore -installdir -backupdir -backuptime -uiupdatescript ./b2bmgr.py -swtype sfg -action restore -installdir /apps/ibm/sfg -backupdir /apps/ibm/backup -backuptime 20240309160549 -uiupdatescript /opt/B2B_Shared/c7r7ff/IMA/modifySFG-UI.sh \ No newline at end of file From 0c21f8a36cd539b6ab28e5332c5ef661056fff4a Mon Sep 17 00:00:00 2001 From: Venkateswara Rao Thota Date: Sun, 10 Mar 2024 02:03:21 +0530 Subject: [PATCH 05/10] Update gm.py --- b2bmgr/gm.py | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/b2bmgr/gm.py b/b2bmgr/gm.py index 8f025e4..db8c92d 100644 --- a/b2bmgr/gm.py +++ b/b2bmgr/gm.py @@ -26,17 +26,17 @@ def __init__(self, now, args): log_filename = os.path.join(self.backupdir, 'b2bmgr_{}_{}_{}.log'.format(self.swtype, self.action, self.now)) logging.basicConfig(filename=log_filename, filemode='w', level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s') - # def run(self, args): - # installation_dir = args.installdir - # now = datetime.now() - # timestamp = now.strftime("%Y%m%d%H%M%S") - # logging.info('Starting Upgrade of {} at:{}'.format(swtype, self.now)) - # logging.info('Backup Directory:{}'.format(self.backupdir)) - # logging.info('Installation Directory:{}'.format(installation_dir)) - # self.stop_gm() - # self.backup() - # self.upgrade() - # self.start_gm() + def run(self, args): + installation_dir = args.installdir + now = datetime.now() + timestamp = now.strftime("%Y%m%d%H%M%S") + logging.info('Starting Upgrade of {} at:{}'.format(swtype, self.now)) + logging.info('Backup Directory:{}'.format(self.backupdir)) + logging.info('Installation Directory:{}'.format(installation_dir)) + self.stop_gm() + self.backup() + self.upgrade() + self.start_gm() def stop(self): subprocess.call(["amf", "stop", "gm"]) From c63abd38f84b22e38cd33bed0c9f769444a6a519 Mon Sep 17 00:00:00 2001 From: Venkateswara Rao Thota Date: Sun, 10 Mar 2024 02:05:23 +0530 Subject: [PATCH 06/10] Update sfg.py --- b2bmgr/sfg.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/b2bmgr/sfg.py b/b2bmgr/sfg.py index 361e5af..e93dbd9 100644 --- a/b2bmgr/sfg.py +++ b/b2bmgr/sfg.py @@ -29,14 +29,14 @@ def __init__(self, now, args): self.homedir = os.environ.get('HOME') log_filename = os.path.join(self.backupdir, 'b2bmgr_{}_{}_{}.log'.format(self.swtype, self.action, self.now)) logging.basicConfig(filename=log_filename, filemode='w', level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s') - - # def run(self, args): - # installation_dir = args.installdir - # backupdir = args.backupdir - # self.stop() - # self.backup(installation_dir, backupdir) - # self.upgrade(installation_dir, backupdir) - # self.start() + + def run(self, args): + installation_dir = args.installdir + backupdir = args.backupdir + self.stop() + self.backup() + self.upgrade() + self.start() # logging.info('Starting Upgrade of {} at:{}'.format(swtype, now)) # logging.info('Backup Directory:{}'.format(backupdir)) From 801ce29d37ed92dcb6839579610ca4b6090db9dc Mon Sep 17 00:00:00 2001 From: Venkateswara Rao Thota Date: Sun, 10 Mar 2024 02:06:16 +0530 Subject: [PATCH 07/10] Update gm.py --- b2bmgr/gm.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/b2bmgr/gm.py b/b2bmgr/gm.py index db8c92d..a4aec12 100644 --- a/b2bmgr/gm.py +++ b/b2bmgr/gm.py @@ -33,10 +33,10 @@ def run(self, args): logging.info('Starting Upgrade of {} at:{}'.format(swtype, self.now)) logging.info('Backup Directory:{}'.format(self.backupdir)) logging.info('Installation Directory:{}'.format(installation_dir)) - self.stop_gm() + self.stop() self.backup() self.upgrade() - self.start_gm() + self.start() def stop(self): subprocess.call(["amf", "stop", "gm"]) From bcbf4ffd4786967d2426dbc61a49a92a576c3de4 Mon Sep 17 00:00:00 2001 From: Venkateswara Rao Thota Date: Sun, 10 Mar 2024 02:08:24 +0530 Subject: [PATCH 08/10] Update b2bmgr.py --- b2bmgr/b2bmgr.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/b2bmgr/b2bmgr.py b/b2bmgr/b2bmgr.py index d443cb9..7a4a78b 100644 --- a/b2bmgr/b2bmgr.py +++ b/b2bmgr/b2bmgr.py @@ -43,7 +43,7 @@ def run(self): elif self.action == 'restore': app.restore_with_cleanup_timestamp() elif self.action == 'run': - app.run(self.args) + app.run() else: print("Invalid action. Please verify!") return @@ -74,4 +74,4 @@ def run(self): b2bmgr.run() else: print('Invalid Service or Action. Please verify!') - print("B2B Manager stopped.") \ No newline at end of file + print("B2B Manager stopped.") From 6dbb97c5cd6774315805ea9bef8718a4bf3843e8 Mon Sep 17 00:00:00 2001 From: Lokeswaranath Date: Sun, 10 Mar 2024 19:33:47 +0530 Subject: [PATCH 09/10] script changes with run action and added log --- b2bmgr/b2bmgr.py | 8 +++---- b2bmgr/gm.py | 36 ++++++++++++++++++++++-------- b2bmgr/readme.txt | 18 ++++++++++----- b2bmgr/sfg.py | 56 +++++++++++++++++++++++++++++------------------ 4 files changed, 78 insertions(+), 40 deletions(-) diff --git a/b2bmgr/b2bmgr.py b/b2bmgr/b2bmgr.py index 7a4a78b..84be4e7 100644 --- a/b2bmgr/b2bmgr.py +++ b/b2bmgr/b2bmgr.py @@ -12,7 +12,7 @@ def __init__(self, args): self.action = args.action.lower() self.installdir = args.installdir self.backupdir = args.backupdir - self.imdir = args.imdir + self.imcldir = args.imcldir self.responsefilepath = args.responsefilepath self.appdatadir = args.appdatadir self.ibmimsharedpath = args.ibmimsharedpath @@ -49,13 +49,13 @@ def run(self): return if __name__ == "__main__": - parser = argparse.ArgumentParser(description='This is a script to automate the B2B upgrade process.') + parser = argparse.ArgumentParser(description='This is a script to upgrade GM/B2Bi.') parser.add_argument('-action', help='Action to be performed') - parser.add_argument('-swtype', help='Action to be performed') + parser.add_argument('-swtype', help='Software type') parser.add_argument('-installdir', help='The installation directory of the B2B product') parser.add_argument('-backupdir', help='The directory where the backup files are located') - parser.add_argument('-imdir', help='The path to the Installation Manager') + parser.add_argument('-imcldir', help='The path to the Installation Manager') parser.add_argument('-responsefilepath', help='The path to the response file') parser.add_argument('-appdatadir', help='The path to the appData directory') parser.add_argument("-ibmimsharedpath", type=str, help="IBMIMSHARED Path") diff --git a/b2bmgr/gm.py b/b2bmgr/gm.py index a4aec12..a267e8b 100644 --- a/b2bmgr/gm.py +++ b/b2bmgr/gm.py @@ -14,7 +14,7 @@ def __init__(self, now, args): self.action = args.action.lower() self.swtype = args.swtype self.backupdir = args.backupdir - self.imdir = args.imdir + self.imcldir = args.imcldir self.backuptime = args.backuptime self.responsefilepath = args.responsefilepath self.appdatadir = args.appdatadir @@ -27,16 +27,30 @@ def __init__(self, now, args): logging.basicConfig(filename=log_filename, filemode='w', level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s') def run(self, args): - installation_dir = args.installdir - now = datetime.now() - timestamp = now.strftime("%Y%m%d%H%M%S") - logging.info('Starting Upgrade of {} at:{}'.format(swtype, self.now)) + logging.info('Starting Upgrade of {} at:{}'.format(self.swtype, self.now)) + logging.info('Installation Directory:{}'.format(self.installation_dir)) logging.info('Backup Directory:{}'.format(self.backupdir)) - logging.info('Installation Directory:{}'.format(installation_dir)) + + + logging.info("About to stop {}".format(self.swtype)) self.stop() + logging.info("Completed {} stop".format(self.swtype)) + + logging.info("About to start backup process of {}".format(self.swtype)) self.backup() + logging.info("Completed {} backup".format(self.swtype)) + + logging.info("About to start upgrade process of {}".format(self.swtype)) self.upgrade() + logging.info("Completed {} upgrade".format(self.swtype)) + + logging.info("About to start restore process of {}".format(self.swtype)) + self.restore_with_cleanup_timestamp() + logging.info("Completed {} upgrade".format(self.swtype)) + + logging.info("About to start {}".format(self.swtype)) self.start() + logging.info("Completed {} start".format(self.swtype)) def stop(self): subprocess.call(["amf", "stop", "gm"]) @@ -67,12 +81,12 @@ def backup(self): self.tar_and_copy_folder(self.appdatadir, self.backupdir, '{}_{}'.format("appData", self.now)) - self.tar_and_copy_folder(os.path.join(self.ibmimsharedpath,"IBMIMShared"), self.backupdir, '{}_{}'.format("IBMIMShared", self.now)) + self.tar_and_copy_folder(self.ibmimsharedpath, self.backupdir, '{}_{}'.format("IBMIMShared", self.now)) self.tar_and_copy_folder(self.installation_dir, self.backupdir, '{}_{}'.format("gm", self.now)) def upgrade(self): - os.chdir(self.imdir) + os.chdir(self.imcldir) subprocess.call(["./imcl", "listInstalledPackages", "-verbose"]) subprocess.call([ "./imcl", @@ -88,7 +102,11 @@ def restore_with_cleanup_timestamp(self): reaper_conf_dir = os.path.join(self.installation_dir, "apache-cassandra", "reaper", "conf") shutil.copy2(os.path.join(reaper_conf_dir, "cassandra-reaper.yaml"), os.path.join(reaper_conf_dir, "cassandra-reaper.yaml_{}_patchfile.bkp".format(self.now))) - source_file_name = os.path.join(self.backupdir, "cassandra-reaper.yaml_{}.bkp".format(self.backuptime)) + if self.action == run: ++ source_file_name = os.path.join(self.backupdir, "cassandra-reaper.yaml_{}.bkp".format(self.now)) ++ ++ else: ++ source_file_name = os.path.join(self.backupdir, "cassandra-reaper.yaml_{}.bkp".format(self.backuptime)) shutil.copy2(source_file_name, os.path.join(reaper_conf_dir, "cassandra-reaper.yaml")) diff --git a/b2bmgr/readme.txt b/b2bmgr/readme.txt index 1f10cc1..b628054 100644 --- a/b2bmgr/readme.txt +++ b/b2bmgr/readme.txt @@ -19,16 +19,16 @@ BACKUP UPGRADE FOR GM - - ./b2bmgr.py -swtype gm -action upgrade -installdir -imdir -responsefilepath -appdatadir -log - ./b2bmgr.py -swtype gm -action upgrade -installdir /apps/ibm/gm -imdir apps/ibm/sw/sourcefiles/SFG/InstallationManager/IM_Linux/tools -responsefilepath /apps/ibm/sw/sourcefiles/CASS_RES.xml -appdatadir /apps/ibm/data -log /apps/ibm/backup + ./b2bmgr.py -swtype gm -action upgrade -installdir -imcldir -responsefilepath -appdatadir -log + + ./b2bmgr.py -swtype gm -action upgrade -installdir /apps/ibm/gm -imcldir apps/ibm/sw/sourcefiles/SFG/InstallationManager/IM_Linux/tools -responsefilepath /apps/ibm/sw/sourcefiles/CASS_RES.xml -appdatadir /apps/ibm/data -log /apps/ibm/backup FOR SFG - ./b2bmgr.py -swtype sfg -action upgrade -installdir -imdir -responsefilepath -appdatadir -jar -log + ./b2bmgr.py -swtype sfg -action upgrade -installdir -imcldir -responsefilepath -appdatadir -jar -log - ./b2bmgr.py -swtype sfg -action upgrade -installdir /apps/ibm/sfg -imdir /apps/ibm/sw/sourcefiles/SFG/InstallationManager/IM_Linux/tools -responsefilepath /apps/ibm/sw/sourcefiles/SFG_RES.xml -appdatadir /apps/ibm/data -jar /apps/ibm/sw/SFG/packages/ -log /apps/ibm/backup + ./b2bmgr.py -swtype sfg -action upgrade -installdir /apps/ibm/sfg -imcldir /apps/ibm/sw/sourcefiles/SFG/InstallationManager/IM_Linux/tools -responsefilepath /apps/ibm/sw/sourcefiles/SFG_RES.xml -appdatadir /apps/ibm/data -jar /apps/ibm/sw/SFG/packages/ -log /apps/ibm/backup RESTORE @@ -43,4 +43,10 @@ RESTORE ./b2bmgr.py -swtype sfg -action restore -installdir -backupdir -backuptime -uiupdatescript - ./b2bmgr.py -swtype sfg -action restore -installdir /apps/ibm/sfg -backupdir /apps/ibm/backup -backuptime 20240309160549 -uiupdatescript /opt/B2B_Shared/c7r7ff/IMA/modifySFG-UI.sh \ No newline at end of file + ./b2bmgr.py -swtype sfg -action restore -installdir /apps/ibm/sfg -backupdir /apps/ibm/backup -backuptime 20240309160549 -uiupdatescript /opt/B2B_Shared/c7r7ff/IMA/modifySFG-UI.sh + +RUN + + FOR GM + + ./b2bmgr.py -swtype gm -action run -installdir -backupdir -imcldir -responsefilepath -appdatadir -ibmimsharedpath -log \ No newline at end of file diff --git a/b2bmgr/sfg.py b/b2bmgr/sfg.py index e93dbd9..d201d5e 100644 --- a/b2bmgr/sfg.py +++ b/b2bmgr/sfg.py @@ -15,7 +15,7 @@ def __init__(self, now, args): self.swtype = args.swtype self.installation_dir = args.installdir self.backupdir = args.backupdir - self.imdir = args.imdir + self.imcldir = args.imcldir self.responsefilepath = args.responsefilepath self.appdatadir = args.appdatadir self.ibmimsharedpath = args.ibmimsharedpath @@ -31,22 +31,30 @@ def __init__(self, now, args): logging.basicConfig(filename=log_filename, filemode='w', level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s') def run(self, args): - installation_dir = args.installdir - backupdir = args.backupdir + + logging.info('Starting Upgrade of {} at:{}'.format(self.swtype, self.now)) + logging.info('Installation Directory:{}'.format(self.installation_dir)) + logging.info('Backup Directory:{}'.format(self.backupdir)) + + logging.info("About to stop {}".format(self.swtype)) self.stop() + logging.info("Completed {} stop".format(self.swtype)) + + logging.info("About to start backup process of {}".format(self.swtype)) self.backup() + logging.info("Completed {} backup".format(self.swtype)) + + logging.info("About to start upgrade process of {}".format(self.swtype)) self.upgrade() + logging.info("Completed {} upgrade".format(self.swtype)) + + logging.info("About to start restore process of {}".format(self.swtype)) + self.restore_with_cleanup_timestamp() + logging.info("Completed {} upgrade".format(self.swtype)) + + logging.info("About to start {}".format(self.swtype)) self.start() - - # logging.info('Starting Upgrade of {} at:{}'.format(swtype, now)) - # logging.info('Backup Directory:{}'.format(backupdir)) - # logging.info('Installation Directory:{}'.format(installation_dir)) - - # self.stop_sfg() - # self.backup(installation_dir, backupdir) - # self.upgrade(installation_dir, backupdir) - # self.restore(installation_dir, backupdir) - # self.start_sfg() + logging.info("Completed {} start".format(self.swtype)) def stop(self): subprocess.call(["amf", "stop", "sfg"]) @@ -55,8 +63,8 @@ def is_directory_empty(self,directory_path): return len(os.listdir(directory_path)) == 0 def create_tar_archive(self, source_folder, destination_file, exclude_folders=None): + fileslist = [] - dirslist = [] with tarfile.open(destination_file, "w:gz") as tar: for root, dirs, files in os.walk(source_folder): # Exclude top-level directories specified in exclude_dirs @@ -118,8 +126,7 @@ def upgrade(self): continue subprocess.call([ - - self.imdir+"/imcl", + self.imcldir+"/imcl", "-input", self.responsefilepath, "-dataLocation", self.appdatadir, "-log", self.log, @@ -136,11 +143,18 @@ def upgrade(self): def restore_with_cleanup_timestamp(self): properties_folder = os.path.join(self.installation_dir, "properties") - files_to_restore = [ - "cdinterop-spoe-auth_{}.properties".format(self.backuptime), - "cdinterop-spoe-policy_{}.properties".format(self.backuptime), - "cdinterop-spoe-policy_{}.properties.in".format(self.backuptime) - ] + if self.action == run: ++ files_to_restore = [ ++ "cdinterop-spoe-auth_{}.properties".format(self.now), ++ "cdinterop-spoe-policy_{}.properties".format(self.now), ++ "cdinterop-spoe-policy_{}.properties.in".format(self.now) ++ ] ++ else: ++ files_to_restore = [ ++ "cdinterop-spoe-auth_{}.properties".format(self.backuptime), ++ "cdinterop-spoe-policy_{}.properties".format(self.backuptime), ++ "cdinterop-spoe-policy_{}.properties.in".format(self.backuptime) ++ ] for file_name in files_to_restore: pos1 = file_name.find('_') pos2 = file_name.find('.',pos1) From 4e34201ee3ff7ed4805b4269e3f51b5d7fb4b260 Mon Sep 17 00:00:00 2001 From: Lokeswaranath Date: Sun, 10 Mar 2024 23:55:38 +0530 Subject: [PATCH 10/10] script changes with run action and added log --- b2bmgr/gm.py | 17 ++++++++++---- b2bmgr/sfg.py | 64 ++++++++++++++++++++++++++++++++++++++++++--------- 2 files changed, 66 insertions(+), 15 deletions(-) diff --git a/b2bmgr/gm.py b/b2bmgr/gm.py index a267e8b..01e1b12 100644 --- a/b2bmgr/gm.py +++ b/b2bmgr/gm.py @@ -38,15 +38,15 @@ def run(self, args): logging.info("About to start backup process of {}".format(self.swtype)) self.backup() - logging.info("Completed {} backup".format(self.swtype)) + logging.info("Completed {} backup process".format(self.swtype)) logging.info("About to start upgrade process of {}".format(self.swtype)) self.upgrade() - logging.info("Completed {} upgrade".format(self.swtype)) + logging.info("Completed {} upgrade process".format(self.swtype)) logging.info("About to start restore process of {}".format(self.swtype)) self.restore_with_cleanup_timestamp() - logging.info("Completed {} upgrade".format(self.swtype)) + logging.info("Completed {} restore process".format(self.swtype)) logging.info("About to start {}".format(self.swtype)) self.start() @@ -61,6 +61,8 @@ def tar_and_copy_folder(self, source_folder, destination_folder, tar_filename): def backup(self): reaper_conf_dir = os.path.join(self.installation_dir, "apache-cassandra", "reaper", "conf") + + logging.info("Backup of {} is getting created in {} as {}".format(os.path.join(reaper_conf_dir, "cassandra-reaper.yaml"), self.backupdir, "cassandra-reaper.yaml_{}.bkp".format(self.now))) shutil.copy2(os.path.join(reaper_conf_dir, "cassandra-reaper.yaml"), os.path.join(self.backupdir, "cassandra-reaper.yaml_{}.bkp".format(self.now))) netstat_output = subprocess.check_output("netstat -an | grep 2181 | grep TIME_WAIT | wc -l", shell=True) @@ -77,12 +79,16 @@ def backup(self): if zerocountflag: for directory in ["ZOO", "CAS"]: + logging.info("Backup of {} is getting created in {} as {}".format(os.path.join(self.installation_dir, directory), self.backupdir, '{}_{}'.format(directory, self.now))) self.tar_and_copy_folder(os.path.join(self.installation_dir, directory), self.backupdir, '{}_{}'.format(directory, self.now)) - + + logging.info("Backup of {} is getting created in {} as {}".format(self.appdatadir, self.backupdir, '{}_{}'.format("appData", self.now))) self.tar_and_copy_folder(self.appdatadir, self.backupdir, '{}_{}'.format("appData", self.now)) + logging.info("Backup of {} is getting created in {} as {}".format(self.ibmimsharedpath, self.backupdir, '{}_{}'.format("IBMIMShared", self.now))) self.tar_and_copy_folder(self.ibmimsharedpath, self.backupdir, '{}_{}'.format("IBMIMShared", self.now)) + logging.info("Backup of {} is getting created in {} as {}".format(self.installation_dir, self.backupdir, '{}_{}'.format("gm", self.now))) self.tar_and_copy_folder(self.installation_dir, self.backupdir, '{}_{}'.format("gm", self.now)) def upgrade(self): @@ -100,6 +106,8 @@ def upgrade(self): def restore_with_cleanup_timestamp(self): reaper_conf_dir = os.path.join(self.installation_dir, "apache-cassandra", "reaper", "conf") + + logging.info("Backup of {} is getting created in {} as patchfile {}".format(os.path.join(reaper_conf_dir, "cassandra-reaper.yaml"), reaper_conf_dir, "cassandra-reaper.yaml_{}_patchfile.bkp".format(self.now))) shutil.copy2(os.path.join(reaper_conf_dir, "cassandra-reaper.yaml"), os.path.join(reaper_conf_dir, "cassandra-reaper.yaml_{}_patchfile.bkp".format(self.now))) if self.action == run: @@ -108,6 +116,7 @@ def restore_with_cleanup_timestamp(self): + else: + source_file_name = os.path.join(self.backupdir, "cassandra-reaper.yaml_{}.bkp".format(self.backuptime)) + logging.info("Restoring {} to {} as {}".format(source_file_name, reaper_conf_dir, "cassandra-reaper.yaml")) shutil.copy2(source_file_name, os.path.join(reaper_conf_dir, "cassandra-reaper.yaml")) def start(self): diff --git a/b2bmgr/sfg.py b/b2bmgr/sfg.py index d201d5e..049bd59 100644 --- a/b2bmgr/sfg.py +++ b/b2bmgr/sfg.py @@ -1,5 +1,6 @@ #!/usr/bin/python import os +import sys import subprocess from datetime import datetime import tarfile @@ -35,22 +36,22 @@ def run(self, args): logging.info('Starting Upgrade of {} at:{}'.format(self.swtype, self.now)) logging.info('Installation Directory:{}'.format(self.installation_dir)) logging.info('Backup Directory:{}'.format(self.backupdir)) - + logging.info("About to stop {}".format(self.swtype)) self.stop() logging.info("Completed {} stop".format(self.swtype)) logging.info("About to start backup process of {}".format(self.swtype)) self.backup() - logging.info("Completed {} backup".format(self.swtype)) + logging.info("Completed {} backup process".format(self.swtype)) logging.info("About to start upgrade process of {}".format(self.swtype)) self.upgrade() - logging.info("Completed {} upgrade".format(self.swtype)) + logging.info("Completed {} upgrade process".format(self.swtype)) logging.info("About to start restore process of {}".format(self.swtype)) self.restore_with_cleanup_timestamp() - logging.info("Completed {} upgrade".format(self.swtype)) + logging.info("Completed {} restore process".format(self.swtype)) logging.info("About to start {}".format(self.swtype)) self.start() @@ -98,20 +99,59 @@ def backup(self): "cdinterop-spoe-policy_{}.properties.in".format(self.now) ] for file_name in files_to_backup: + logging.info("backup of {} is getting created in {} as {}".format(os.path.join(properties_folder, file_name), self.backupdir, backupfiles[files_to_backup.index(file_name)])) shutil.copy2(os.path.join(properties_folder, file_name), os.path.join(self.backupdir, backupfiles[files_to_backup.index(file_name)])) home_dir = self.homedir home_dir_formatted = home_dir.replace('/','_') - self.create_tar_archive(self.installation_dir, "{}/{}_opt_B2B_sys_{}.tar.gz".format(self.backupdir, self.hostname, self.now), exclude_folders=['logs','backups']), - self.create_tar_archive(self.appdatadir, "{}/{}_opt_B2B_appData_{}.sys.tar.gz".format(self.backupdir, self.hostname, self.now)), - self.create_tar_archive(self.ibmimsharedpath, "{}/{}_opt_B2B_IBMIMShared_{}.sys.tar.gz".format(self.backupdir, self.hostname, self.now)), + if self.installation_dir: + logging.info("backup of {} is getting created in {} as {}_opt_B2B_sys_{}.tar.gz".format(self.installation_dir, self.backupdir, self.hostname, self.now)) + self.create_tar_archive(self.installation_dir, "{}/{}_opt_B2B_sys_{}.tar.gz".format(self.backupdir, self.hostname, self.now), exclude_folders=['logs','backups']) + else: + logging.info("No installdir provided, aborting...") + print("No installdir provided, aborting...") + sys.exit(1) + + if self.appdatadir: + logging.info("backup of {} is getting created in {} as {}_opt_B2B_appData_{}.sys.tar.gz".format(self.appdatadir, self.backupdir, self.hostname, self.now)) + self.create_tar_archive(self.appdatadir, "{}/{}_opt_B2B_appData_{}.sys.tar.gz".format(self.backupdir, self.hostname, self.now)) + else: + logging.info("No appdatadir provided, aborting...") + print("No appdatadir provided, aborting...") + sys.exit(2) - self.create_tar_archive(self.IBM, "{}/{}_opt_B2B_IBM_{}.sys.tar.gz".format(self.backupdir, self.hostname, self.now)), - self.create_tar_archive(self.ibm, "{}/{}_opt_B2B_ibm_{}.sys.tar.gz".format(self.backupdir, self.hostname, self.now)), + if self.ibmimsharedpath: + logging.info("backup of {} is getting created in {} as {}_opt_B2B_IBMIMShared_{}.sys.tar.gz".format(self.ibmimsharedpath, self.backupdir, self.hostname, self.now)) + self.create_tar_archive(self.ibmimsharedpath, "{}/{}_opt_B2B_IBMIMShared_{}.sys.tar.gz".format(self.backupdir, self.hostname, self.now)) + else: + logging.info("No ibmimsharedpath provided, aborting...") + print("No ibmimsharedpath provided, aborting...") + sys.exit(3) - self.create_tar_archive(os.path.join(home_dir, "etc"), "{}/{}_{}_etc_{}.sys.tar.gz".format(self.backupdir, self.hostname, home_dir_formatted, self.now)), - self.create_tar_archive(os.path.join(home_dir, "var"), "{}/{}_{}_var_{}.sys.tar.gz".format(self.backupdir, self.hostname, home_dir_formatted, self.now)) + if self.IBM: + logging.info("Backup of {} is getting created in {} as {}_opt_B2B_IBM_{}.sys.tar.gz".format(self.IBM, self.backupdir, self.hostname, self.now)) + self.create_tar_archive(self.IBM, "{}/{}_opt_B2B_IBM_{}.sys.tar.gz".format(self.backupdir, self.hostname, self.now)) + else: + logging.info("No IBM provided, proceeding further without backup of IBM") + + if self.ibm: + logging.info("Backup of {} is getting created in {} as {}_opt_B2B_ibm_{}.sys.tar.gz".format(self.ibm, self.backupdir, self.hostname, self.now)) + self.create_tar_archive(self.ibm, "{}/{}_opt_B2B_ibm_{}.sys.tar.gz".format(self.backupdir, self.hostname, self.now)) + else: + logging.info("No ibm provided, proceeding further without backup of ibm") + + if "etc" in os.listdir(home_dir): + logging.info("Backup of {} is getting created in {} as {}_{}_etc_{}.sys.tar.gz".format(os.path.join(home_dir, "etc"), self.backupdir, self.hostname, home_dir_formatted, self.now)) + self.create_tar_archive(os.path.join(home_dir, "etc"), "{}/{}_{}_etc_{}.sys.tar.gz".format(self.backupdir, self.hostname, home_dir_formatted, self.now)) + else: + logging.info("etc not present in {}, proceeding further without backup of etc".format(home_dir)) + + if "var" in os.listdir(home_dir): + logging.info("Backup of {} is getting created in {} as {}_{}_var_{}.sys.tar.gz".format(os.path.join(home_dir, "var"), self.backupdir, self.hostname, home_dir_formatted, self.now)) + self.create_tar_archive(os.path.join(home_dir, "var"), "{}/{}_{}_var_{}.sys.tar.gz".format(self.backupdir, self.hostname, home_dir_formatted, self.now)) + else: + logging.info("var not present in {}, proceeding further without backup of var".format(home_dir)) def upgrade(self): sandbox_config = os.path.join(self.installation_dir, "properties", "sandbox.cfg") @@ -123,6 +163,7 @@ def upgrade(self): if "JCE_DIST_FILE" not in line: file.write(line) else: + logging.info("Removed {} from {}".format("JCE_DIST_FILE", sandbox_config)) continue subprocess.call([ @@ -159,6 +200,7 @@ def restore_with_cleanup_timestamp(self): pos1 = file_name.find('_') pos2 = file_name.find('.',pos1) source_file_name = file_name[:pos1] + file_name[pos2:] + logging.info("Restoring {} to {} as {}".format(os.path.join(self.backupdir, file_name), properties_folder, source_file_name)) shutil.copy2(os.path.join(self.backupdir, file_name), os.path.join(properties_folder, source_file_name)) subprocess.call(["sh", self.uiupdatescript])