diff --git a/b2bmgr/b2bmgr.py b/b2bmgr/b2bmgr.py new file mode 100644 index 0000000..84be4e7 --- /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.imcldir = args.imcldir + 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() + else: + print("Invalid action. Please verify!") + return + +if __name__ == "__main__": + 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='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('-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") + 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.") diff --git a/b2bmgr/gm.py b/b2bmgr/gm.py new file mode 100644 index 0000000..01e1b12 --- /dev/null +++ b/b2bmgr/gm.py @@ -0,0 +1,124 @@ +#!/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.imcldir = args.imcldir + 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): + 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 process".format(self.swtype)) + + logging.info("About to start upgrade process of {}".format(self.swtype)) + self.upgrade() + 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 {} restore process".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"]) + + 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") + + 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) + 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"]: + 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): + os.chdir(self.imcldir) + 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") + + 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: ++ 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)) + + 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): + subprocess.call(["amf", "start", "gm"]) + diff --git a/b2bmgr/readme.txt b/b2bmgr/readme.txt new file mode 100644 index 0000000..b628054 --- /dev/null +++ b/b2bmgr/readme.txt @@ -0,0 +1,52 @@ +START/STOP + ./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 + + ./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 GM + + ./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 -imcldir -responsefilepath -appdatadir -jar -log + + ./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 + + 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 + +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 new file mode 100644 index 0000000..049bd59 --- /dev/null +++ b/b2bmgr/sfg.py @@ -0,0 +1,209 @@ +#!/usr/bin/python +import os +import sys +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.imcldir = args.imcldir + 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): + + 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 process".format(self.swtype)) + + logging.info("About to start upgrade process of {}".format(self.swtype)) + self.upgrade() + 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 {} restore process".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", "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 = [] + 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: + 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('/','_') + + 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) + + 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) + + 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") + 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: + logging.info("Removed {} from {}".format("JCE_DIST_FILE", sandbox_config)) + continue + + subprocess.call([ + self.imcldir+"/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") + 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) + 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]) + + def start(self): + subprocess.call(["amf", "start", "sfg"]) diff --git a/gm_01_py2.7.py b/gm_01_py2.7.py new file mode 100644 index 0000000..0750151 --- /dev/null +++ b/gm_01_py2.7.py @@ -0,0 +1,134 @@ +#!/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))) + + 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): + 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