def pre_upgrade(self, context): mount_point = self._app.get_working_dir() save_etc_dir = "%s/etc" % mount_point home_save = "%s/trove_user" % mount_point self._app.status.begin_restart() self._app.stop_db() operating_system.copy("%s/." % system.REDIS_CONF_DIR, save_etc_dir, preserve=True, as_root=True) operating_system.copy("%s/." % os.path.expanduser('~'), home_save, preserve=True, as_root=True) self.unmount_volume(context, mount_point=mount_point) return { 'mount_point': mount_point, 'save_etc_dir': save_etc_dir, 'home_save': home_save }
def _run_pre_backup(self): try: for cmd in self.pre_backup_commands: utils.execute_with_timeout(*cmd) root = service.CouchbaseRootAccess() pw = root.get_password() self._save_buckets_config(pw) with open(OUTFILE, "r") as f: out = f.read() if out != "[]": d = json.loads(out) all_memcached = True for i in range(len(d)): bucket_type = d[i]["bucketType"] if bucket_type != "memcached": all_memcached = False break if not all_memcached: self._backup(pw) else: LOG.info(_("All buckets are memcached. " "Skipping backup.")) operating_system.move(OUTFILE, system.COUCHBASE_DUMP_DIR) if pw != "password": # Not default password, backup generated root password operating_system.copy(system.pwd_file, system.COUCHBASE_DUMP_DIR, preserve=True, as_root=True) except exception.ProcessExecutionError as p: LOG.error(p) raise p
def enable_as_master(self, service, master_config, for_failover=False): # For a server to be a master in postgres, we need to enable # replication user in pg_hba and ensure that WAL logging is # the appropriate level (use the same settings as backups) self._get_or_create_replication_user() hba_entry = "host replication replicator 0.0.0.0/0 md5 \n" tmp_hba = '/tmp/pg_hba' operating_system.copy(self.pgsql_hba_config, tmp_hba, force=True, as_root=True) operating_system.chmod(tmp_hba, FileMode.SET_ALL_RWX(), as_root=True) with open(tmp_hba, 'a+') as hba_file: hba_file.write(hba_entry) operating_system.copy(tmp_hba, self.pgsql_hba_config, force=True, as_root=True) operating_system.chmod(self.pgsql_hba_config, FileMode.SET_USR_RWX(), as_root=True) operating_system.remove(tmp_hba, as_root=True) pgutil.psql("SELECT pg_reload_conf()")
def enable_as_master(self, service, master_config, for_failover=False): """For a server to be a master in postgres, we need to enable the replication user in pg_hba and ensure that WAL logging is at the appropriate level (use the same settings as backups) """ LOG.debug("Enabling as master, with cfg: %s " % master_config) self._get_or_create_replication_user(service) hba_entry = "host replication replicator 0.0.0.0/0 md5 \n" # TODO(atomic77) Remove this hack after adding cfg manager for pg_hba tmp_hba = '/tmp/pg_hba' operating_system.copy(service.pgsql_hba_config, tmp_hba, force=True, as_root=True) operating_system.chmod(tmp_hba, FileMode.OCTAL_MODE("0777"), as_root=True) with open(tmp_hba, 'a+') as hba_file: hba_file.write(hba_entry) operating_system.copy(tmp_hba, service.pgsql_hba_config, force=True, as_root=True) operating_system.chmod(service.pgsql_hba_config, FileMode.OCTAL_MODE("0600"), as_root=True) operating_system.remove(tmp_hba, as_root=True) service.reload_configuration()
def enable_as_master(self, service, master_config): """Primary postgredql settings. For a server to be a master in postgres, we need to enable the replication user in pg_hba.conf """ self._get_or_create_replication_user(service) hba_entry = f"host replication {REPL_USER} 0.0.0.0/0 md5\n" tmp_hba = '/tmp/pg_hba' operating_system.copy(pg_service.HBA_CONFIG_FILE, tmp_hba, force=True, as_root=True) operating_system.chmod(tmp_hba, FileMode.SET_ALL_RWX(), as_root=True) with open(tmp_hba, 'a+') as hba_file: hba_file.write(hba_entry) operating_system.copy(tmp_hba, pg_service.HBA_CONFIG_FILE, force=True, as_root=True) operating_system.chown(pg_service.HBA_CONFIG_FILE, user=CONF.database_service_uid, group=CONF.database_service_uid, as_root=True) operating_system.chmod(pg_service.HBA_CONFIG_FILE, FileMode.SET_USR_RWX(), as_root=True) operating_system.remove(tmp_hba, as_root=True) LOG.debug(f"{pg_service.HBA_CONFIG_FILE} changed") service.restart()
def _run_pre_backup(self): try: for cmd in self.pre_backup_commands: utils.execute_with_timeout(*cmd) root = service.CouchbaseRootAccess() pw = root.get_password() self._save_buckets_config(pw) with open(OUTFILE, "r") as f: out = f.read() if out != "[]": d = json.loads(out) all_memcached = True for i in range(len(d)): bucket_type = d[i]["bucketType"] if bucket_type != "memcached": all_memcached = False break if not all_memcached: self._backup(pw) else: LOG.info( _("All buckets are memcached. " "Skipping backup.")) operating_system.move(OUTFILE, system.COUCHBASE_DUMP_DIR) if pw != "password": # Not default password, backup generated root password operating_system.copy(system.pwd_file, system.COUCHBASE_DUMP_DIR, preserve=True, as_root=True) except exception.ProcessExecutionError as p: LOG.error(p) raise p
def pre_upgrade(self, context): data_dir = self.app.cassandra_data_dir mount_point, _data = os.path.split(data_dir) save_etc_dir = "%s/etc" % mount_point home_save = "%s/trove_user" % mount_point self.app.status.begin_restart() self.app.drain() self.app.stop_db() operating_system.copy("%s/." % self.app.cassandra_conf_dir, save_etc_dir, preserve=True, as_root=True) operating_system.copy("%s/." % os.path.expanduser('~'), home_save, preserve=True, as_root=True) self.unmount_volume(context, mount_point=mount_point) return { 'mount_point': mount_point, 'save_etc_dir': save_etc_dir, 'home_save': home_save }
def enable_as_master(self, service, master_config, for_failover=False): """For a server to be a master in postgres, we need to enable the replication user in pg_hba and ensure that WAL logging is at the appropriate level (use the same settings as backups) """ LOG.debug("Enabling as master, with cfg: %s " % master_config) self._get_or_create_replication_user() hba_entry = "host replication replicator 0.0.0.0/0 md5 \n" # TODO(atomic77) Remove this hack after adding cfg manager for pg_hba tmp_hba = '/tmp/pg_hba' operating_system.copy(self.PGSQL_HBA_CONFIG, tmp_hba, force=True, as_root=True) operating_system.chmod(tmp_hba, FileMode.OCTAL_MODE("0777"), as_root=True) with open(tmp_hba, 'a+') as hba_file: hba_file.write(hba_entry) operating_system.copy(tmp_hba, self.PGSQL_HBA_CONFIG, force=True, as_root=True) operating_system.chmod(self.PGSQL_HBA_CONFIG, FileMode.OCTAL_MODE("0600"), as_root=True) operating_system.remove(tmp_hba, as_root=True) pgutil.psql("SELECT pg_reload_conf()")
def store_key(self, key): """Store the cluster key.""" LOG.debug("Storing key for MongoDB cluster.") with tempfile.NamedTemporaryFile() as f: f.write(key) f.flush() operating_system.copy(f.name, system.MONGO_KEY_FILE, force=True, as_root=True) operating_system.chmod(system.MONGO_KEY_FILE, operating_system.FileMode.SET_USR_RO, as_root=True) operating_system.chown(system.MONGO_KEY_FILE, system.MONGO_USER, system.MONGO_USER, as_root=True)
def save_files_pre_upgrade(self, mount_point): LOG.debug('Saving files pre-upgrade.') mnt_etc_dir = os.path.join(mount_point, 'save_etc') if self.OS != operating_system.REDHAT: # No need to store the config files away for Redhat because # they are already stored in the data volume. operating_system.remove(mnt_etc_dir, force=True, as_root=True) operating_system.copy(self.pgsql_config_dir, mnt_etc_dir, preserve=True, recursive=True, as_root=True) return {'save_etc': mnt_etc_dir}
def save_files_pre_upgrade(self, mount_point): LOG.debug('Saving files pre-upgrade.') for save_dir, save_dir_info in self.upgrade_copy_info.items(): is_dir = save_dir_info['is_dir'] from_path = save_dir_info['path'] to_path = os.path.join(mount_point, save_dir) operating_system.remove(to_path, force=True, as_root=True) operating_system.copy(from_path, to_path, preserve=True, recursive=is_dir, as_root=True) return {'copy_info': self.upgrade_copy_info}
def restore_files_post_upgrade(self, upgrade_info): LOG.debug('Restoring files post-upgrade.') if self.OS != operating_system.REDHAT: # No need to restore the config files for Redhat because # they are already in the data volume. operating_system.copy('%s/.' % upgrade_info['save_etc'], self.pgsql_config_dir, preserve=True, recursive=True, force=True, as_root=True) operating_system.remove(upgrade_info['save_etc'], force=True, as_root=True)
def restore_files_post_upgrade(self, upgrade_info): LOG.debug('Restoring files post-upgrade.') operating_system.copy('%s/.' % upgrade_info['save_opt_etc'], self.couchbase_opt_etc_dir, preserve=True, recursive=True, force=True, as_root=True) operating_system.copy(upgrade_info['save_etc'], self.couchbase_conf_dir, preserve=True, force=True, as_root=True) for save_dir in [upgrade_info['save_opt_etc'], upgrade_info['save_etc']]: operating_system.remove(save_dir, force=True, as_root=True)
def restore_files_post_upgrade(self, upgrade_info): operating_system.copy('%s/.' % upgrade_info['save_confs'], system.CONFIG_DIR, preserve=True, recursive=True, force=True, as_root=True) operating_system.copy('%s/.' % upgrade_info['save_creds'], os.path.expanduser('~'), preserve=True, recursive=True, force=True, as_root=True) for save_dir in [upgrade_info['save_confs'], upgrade_info['save_creds']]: operating_system.remove(save_dir, force=True, as_root=True)
def _restore_directory(self, restore_dir, target_dir, owner=None): restore_path = os.path.join(restore_dir, ".") operating_system.copy(restore_path, target_dir, preserve=True, as_root=True) if owner is not None: operating_system.chown(path=target_dir, user=owner, group=owner, recursive=True, as_root=True)
def apply_next(self, options): revision_num = self.count_revisions() + 1 old_revision_backup = guestagent_utils.build_file_path( self._revision_backup_dir, self._base_config_name, str(revision_num), self._BACKUP_EXT ) operating_system.copy( self._base_config_path, old_revision_backup, force=True, preserve=True, as_root=self._requires_root ) current = operating_system.read_file(self._base_config_path, codec=self._codec) guestagent_utils.update_dict(options, current) operating_system.write_file(self._base_config_path, current, codec=self._codec, as_root=self._requires_root) operating_system.chown(self._base_config_path, self._owner, self._group, as_root=self._requires_root) operating_system.chmod(self._base_config_path, FileMode.ADD_READ_ALL, as_root=self._requires_root)
def save_files_pre_upgrade(self, mount_point): LOG.debug('Saving files pre-upgrade.') mnt_etc_dir = os.path.join(mount_point, 'save_etc') if self.OS not in [operating_system.REDHAT]: # No need to store the config files away for Redhat because # they are already stored in the data volume. operating_system.remove(mnt_etc_dir, force=True, as_root=True) operating_system.copy(self.pgsql_config_dir, mnt_etc_dir, preserve=True, recursive=True, as_root=True) return {'save_etc': mnt_etc_dir}
def save_files_pre_upgrade(self, mount_point): LOG.debug('Saving files pre-upgrade.') mnt_opt_etc = os.path.join(mount_point, 'save_opt_etc') mnt_etc = os.path.join(mount_point, 'save_etc') for save_dir in [mnt_opt_etc, mnt_etc]: operating_system.remove(save_dir, force=True, as_root=True) operating_system.copy(self.couchbase_opt_etc_dir, mnt_opt_etc, preserve=True, recursive=True, as_root=True) operating_system.copy(self.couchbase_conf_dir, mnt_etc, preserve=True, recursive=True, as_root=True) return {'save_opt_etc': mnt_opt_etc, 'save_etc': mnt_etc}
def restore_files_post_upgrade(self, upgrade_info): LOG.debug('Restoring files post-upgrade.') if self.OS not in [operating_system.REDHAT, operating_system.ORACLE]: # No need to restore the config files for Redhat because # they are already in the data volume. operating_system.copy('%s/.' % upgrade_info['save_etc'], self.pgsql_config_dir, preserve=True, recursive=True, force=True, as_root=True) operating_system.remove(upgrade_info['save_etc'], force=True, as_root=True) self.configuration_manager.refresh_cache() self.status.set_ready()
def restore_files_post_upgrade(self, upgrade_info): LOG.debug('Restoring files post-upgrade.') mount_point = upgrade_info['mount_point'] upgrade_copy_info = upgrade_info['copy_info'] for save_dir, save_dir_info in upgrade_copy_info.items(): is_dir = save_dir_info['is_dir'] from_path = os.path.join(mount_point, save_dir) files = os.path.join(from_path, '.') if is_dir else from_path operating_system.copy(files, save_dir_info['path'], preserve=True, recursive=is_dir, force=True, as_root=True) operating_system.remove(from_path, force=True, as_root=True) self.status.set_ready()
def restore_files_post_upgrade(self, upgrade_info): operating_system.copy('%s/.' % upgrade_info['save_confs'], system.CONFIG_DIR, preserve=True, recursive=True, force=True, as_root=True) operating_system.copy(os.path.join(upgrade_info['save_creds'], system.MONGO_ADMIN_CREDS_FILENAME), os.path.expanduser('~'), preserve=True) for save_dir in [upgrade_info['save_confs'], upgrade_info['save_creds']]: operating_system.remove(save_dir, force=True, as_root=True) self.status.set_ready() self.configuration_manager.refresh_cache()
def restore_files_post_upgrade(self, upgrade_info): LOG.debug('Restoring files post-upgrade.') if self.OS not in [operating_system.REDHAT]: # No need to restore the config files for Redhat because # they are already in the data volume. operating_system.copy('%s/.' % upgrade_info['save_etc'], self.pgsql_config_dir, preserve=True, recursive=True, force=True, as_root=True) operating_system.remove(upgrade_info['save_etc'], force=True, as_root=True)
def restore_files_post_upgrade(self, upgrade_info): operating_system.copy('%s/.' % upgrade_info['save_confs'], system.CONFIG_DIR, preserve=True, recursive=True, force=True, as_root=True) operating_system.copy('%s/.' % upgrade_info['save_creds'], os.path.expanduser('~'), preserve=True, recursive=True, force=True, as_root=True) for save_dir in [ upgrade_info['save_confs'], upgrade_info['save_creds'] ]: operating_system.remove(save_dir, force=True, as_root=True)
def restore_files_post_upgrade(self, upgrade_info): LOG.debug('Restoring files post-upgrade.') operating_system.copy('%s/.' % upgrade_info['save_opt_etc'], self.couchbase_opt_etc_dir, preserve=True, recursive=True, force=True, as_root=True) operating_system.copy(upgrade_info['save_etc'], self.couchbase_conf_dir, preserve=True, force=True, as_root=True) for save_dir in [ upgrade_info['save_opt_etc'], upgrade_info['save_etc'] ]: operating_system.remove(save_dir, force=True, as_root=True)
def save_files_pre_upgrade(self, mount_point): save_dir = path.join(mount_point, 'saves') saves = { 'oratab': self.paths.oratab_file, 'dbs': self.paths.dbs_dir, 'oranet': self.paths.oranet_dir, 'admin': self.paths.admin_dir, 'conf_file': CONF.get(MANAGER).conf_file } if not operating_system.exists(save_dir, is_directory=True, as_root=True): operating_system.create_directory(save_dir, force=True, as_root=True) for item in saves.keys(): operating_system.copy(saves[item], path.join(save_dir, item), recursive=True, preserve=True, as_root=True) return {'save_dir': save_dir, 'saves': saves}
def _run_restore(self): metadata = self.storage.load_metadata(self.location, self.checksum) self.db_name = metadata['db_name'] self.app.paths.update_db_name(self.db_name) new_dirs = [ self.app.paths.audit_dir, self.app.paths.db_fast_recovery_logs_dir, self.app.paths.db_fast_recovery_dir, self.app.paths.db_data_dir ] for new_dir in new_dirs: operating_system.create_directory( new_dir, user=self.app.instance_owner, group=self.app.instance_owner_group, force=True, as_root=True) # the backup set will restore directly to ORADATA/backupset_files self._unpack_backup_files(self.location, self.checksum) if operating_system.exists(self.app.paths.base_spfile, as_root=True): operating_system.copy(self.app.paths.base_spfile, self.app.paths.spfile, preserve=True, as_root=True) # the conf file was just restored by the unpack so sync now self.app.admin.delete_conf_cache() self.app.admin.ora_config.db_name = self.db_name chown_dirs = [ self.app.paths.backup_dir, self.app.paths.fast_recovery_area ] for chown_dir in chown_dirs: operating_system.chown(chown_dir, self.app.instance_owner, self.app.instance_owner_group, recursive=True, force=True, as_root=True) self._perform_restore() self._perform_recover() self._open_database()
def _regenerate_base_configuration(self): """Gather all configuration changes and apply them in order on the base revision. Write the results to the configuration file. """ if not os.path.exists(self._base_revision_file): # Initialize the file with the current configuration contents if it # does not exist. operating_system.copy( self._base_config_path, self._base_revision_file, force=True, preserve=True, as_root=self._requires_root) base_revision = operating_system.read_file( self._base_revision_file, codec=self._codec) changes = self._import_strategy.parse_updates() updated_revision = guestagent_utils.update_dict(changes, base_revision) operating_system.write_file( self._base_config_path, updated_revision, codec=self._codec, as_root=self._requires_root)
def _regenerate_base_configuration(self): """Gather all configuration changes and apply them in order on the base revision. Write the results to the configuration file. """ if not os.path.exists(self._base_revision_file): # Initialize the file with the current configuration contents if it # does not exist. operating_system.copy( self._base_config_path, self._base_revision_file, force=True, preserve=True, as_root=self._requires_root) base_revision = operating_system.read_file( self._base_revision_file, codec=self._codec, as_root=self._requires_root) changes = self._import_strategy.parse_updates() updated_revision = guestagent_utils.update_dict(changes, base_revision) operating_system.write_file( self._base_config_path, updated_revision, codec=self._codec, as_root=self._requires_root)
def _run_restore(self): metadata = self.storage.load_metadata(self.location, self.checksum) self.db_name = metadata["db_name"] self.app.paths.update_db_name(self.db_name) new_dirs = [ self.app.paths.audit_dir, self.app.paths.db_fast_recovery_logs_dir, self.app.paths.db_fast_recovery_dir, self.app.paths.db_data_dir, ] for new_dir in new_dirs: operating_system.create_directory( new_dir, user=self.app.instance_owner, group=self.app.instance_owner_group, force=True, as_root=True ) # the backup set will restore directly to ORADATA/backupset_files self._unpack_backup_files(self.location, self.checksum) if operating_system.exists(self.app.paths.base_spfile, as_root=True): operating_system.copy(self.app.paths.base_spfile, self.app.paths.spfile, preserve=True, as_root=True) # the conf file was just restored by the unpack so sync now self.app.admin.delete_conf_cache() self.app.admin.ora_config.db_name = self.db_name chown_dirs = [self.app.paths.backup_dir, self.app.paths.fast_recovery_area] for chown_dir in chown_dirs: operating_system.chown( chown_dir, self.app.instance_owner, self.app.instance_owner_group, recursive=True, force=True, as_root=True, ) self._perform_restore() self._perform_recover() self._open_database()
def pre_upgrade(self, context): app = self.mysql_app(self.mysql_app_status.get()) data_dir = app.get_data_dir() mount_point, _data = os.path.split(data_dir) save_dir = "%s/etc_mysql" % mount_point save_etc_dir = "%s/etc" % mount_point home_save = "%s/trove_user" % mount_point app.status.begin_restart() app.stop_db() if operating_system.exists("/etc/my.cnf", as_root=True): operating_system.create_directory(save_etc_dir, as_root=True) operating_system.copy("/etc/my.cnf", save_etc_dir, preserve=True, as_root=True) operating_system.copy("/etc/mysql/.", save_dir, preserve=True, as_root=True) operating_system.copy("%s/." % os.path.expanduser('~'), home_save, preserve=True, as_root=True) self.unmount_volume(context, mount_point=data_dir) return { 'mount_point': mount_point, 'save_dir': save_dir, 'save_etc_dir': save_etc_dir, 'home_save': home_save }
def post_upgrade(self, context, upgrade_info): app = self.mysql_app(self.mysql_app_status.get()) app.stop_db() if 'device' in upgrade_info: self.mount_volume(context, mount_point=upgrade_info['mount_point'], device_path=upgrade_info['device']) if operating_system.exists(upgrade_info['save_etc_dir'], is_directory=True, as_root=True): operating_system.copy("%s/." % upgrade_info['save_etc_dir'], "/etc", preserve=True, as_root=True) operating_system.copy("%s/." % upgrade_info['save_dir'], "/etc/mysql", preserve=True, as_root=True) operating_system.copy("%s/." % upgrade_info['home_save'], os.path.expanduser('~'), preserve=True, as_root=True) app.start_mysql()
def restore_files_post_upgrade(self, upgrade_info): saves = upgrade_info.get('saves') save_dir = upgrade_info.get('save_dir') if not (saves and save_dir): raise exception.GuestError(_( "Missing upgrade saves and/or save directory info: %s") % upgrade_info) for item in saves.keys(): if item == 'conf_file': operating_system.copy(path.join(save_dir, item), CONF.get(MANAGER).conf_file, force=True, preserve=True, as_root=True) continue if operating_system.exists(saves[item], is_directory=True, as_root=True): operating_system.remove(saves[item], force=True, recursive=True, as_root=True) operating_system.copy(path.join(save_dir, item), saves[item], recursive=True, preserve=True, as_root=True) operating_system.remove(save_dir, force=True, as_root=True) self._init_configuration_manager() self.configuration_manager.refresh_cache() self.status.set_ready()
def enable_as_master(self, service, master_config, for_failover=False): """For a server to be a master in postgres, we need to enable the replication user in pg_hba and ensure that WAL logging is at the appropriate level (use the same settings as backups) """ LOG.debug("Enabling as master, with cfg: %s " % master_config) self._get_or_create_replication_user(service) hba_entry = "host replication replicator 0.0.0.0/0 md5 \n" tmp_hba = '/tmp/pg_hba' operating_system.copy(service.pgsql_hba_config, tmp_hba, force=True, as_root=True) operating_system.chmod(tmp_hba, FileMode.SET_ALL_RWX(), as_root=True) with open(tmp_hba, 'a+') as hba_file: hba_file.write(hba_entry) operating_system.copy(tmp_hba, service.pgsql_hba_config, force=True, as_root=True) operating_system.chmod(service.pgsql_hba_config, FileMode.SET_USR_RWX(), as_root=True) operating_system.remove(tmp_hba, as_root=True) service.reload_configuration()
def apply_next(self, options): revision_num = self.count_revisions() + 1 old_revision_backup = guestagent_utils.build_file_path( self._revision_backup_dir, self._base_config_name, str(revision_num), self._BACKUP_EXT) operating_system.copy(self._base_config_path, old_revision_backup, force=True, preserve=True, as_root=self._requires_root) current = operating_system.read_file(self._base_config_path, codec=self._codec) guestagent_utils.update_dict(options, current) operating_system.write_file(self._base_config_path, current, codec=self._codec, as_root=self._requires_root) operating_system.chown(self._base_config_path, self._owner, self._group, as_root=self._requires_root) operating_system.chmod(self._base_config_path, FileMode.ADD_READ_ALL, as_root=self._requires_root)
def save_files_pre_upgrade(self, mount_point): mnt_confs_dir = os.path.join(mount_point, 'save_confs/') mnt_creds_dir = os.path.join(mount_point, 'save_creds/') for save_dir in [mnt_confs_dir, mnt_creds_dir]: if not operating_system.exists(save_dir, is_directory=True, as_root=True): operating_system.create_directory(save_dir, force=True, as_root=True) operating_system.copy(system.MONGOD_CONFIG_FILE, mnt_confs_dir, preserve=True, as_root=True) operating_system.copy(system.MONGOD_CONFIG_OVERRIDES_DIR, mnt_confs_dir, preserve=True, recursive=True, as_root=True) operating_system.copy(system.MONGO_ADMIN_CREDS_FILE, mnt_creds_dir, preserve=True, as_root=True) return {'save_confs': mnt_confs_dir, 'save_creds': mnt_creds_dir}
def save_files_pre_upgrade(self, mount_point): mnt_confs_dir = os.path.join(mount_point, 'save_confs/') mnt_creds_dir = os.path.join(mount_point, 'save_creds/') for save_dir in [mnt_confs_dir, mnt_creds_dir]: if not operating_system.exists( save_dir, is_directory=True, as_root=True): operating_system.create_directory(save_dir, force=True, as_root=True) operating_system.copy(system.MONGOD_CONFIG_FILE, mnt_confs_dir, preserve=True, as_root=True) operating_system.copy(system.MONGOD_CONFIG_OVERRIDES_DIR, mnt_confs_dir, preserve=True, recursive=True, as_root=True) operating_system.copy(system.MONGO_ADMIN_CREDS_FILE, mnt_creds_dir, preserve=True, as_root=True) return {'save_confs': mnt_confs_dir, 'save_creds': mnt_creds_dir}
def prepare_slave(self, service, snapshot): """Prepare the environment needed for starting the slave Oracle processes. """ master_info = snapshot['master'] db_name = master_info['db_name'] db_unique_name = ('%(db_name)s_%(replica_label)s' % {'db_name': db_name, 'replica_label': utils.generate_random_string(6)}) service.paths.update_db_name(db_name) # Create necessary directories and set necessary permissions new_dirs = [service.paths.db_data_dir, service.paths.db_fast_recovery_logs_dir, service.paths.db_fast_recovery_dir, service.paths.audit_dir] for directory in new_dirs: operating_system.create_directory(directory, service.instance_owner, service.instance_owner_group, as_root=True) chown_dirs = [service.paths.fast_recovery_area, service.paths.admin_dir] for directory in chown_dirs: operating_system.chown(directory, service.instance_owner, service.instance_owner_group, as_root=True) # Install on the slave files extracted from the master # (e.g. the control, pfile, password, oracle.cnf file ... etc) oradata_encoded = master_info['oradata'] tmp_data_path = path.join(TMP_DIR, 'oradata.tar.gz') operating_system.write_file(tmp_data_path, oradata_encoded, codec=stream_codecs.Base64Codec(), encode=False) utils.execute_with_timeout('tar', '-Pxzvf', tmp_data_path, run_as_root=True, root_helper='sudo') # Put the control file in place tmp_ctlfile_path = sorted( operating_system.list_files_in_directory(TMP_DIR, pattern='*.ctl.bak$', recursive=True, as_root=True))[0] ctlfile_name = path.basename(tmp_ctlfile_path)[:-4] ctlfile1_path = path.join(service.paths.ctlfile1_dir, ctlfile_name) operating_system.create_directory(service.paths.ctlfile1_dir, force=True, user='******', group='oinstall', as_root=True) operating_system.create_directory(service.paths.ctlfile2_dir, force=True, user='******', group='oinstall', as_root=True) operating_system.move( tmp_ctlfile_path, ctlfile1_path, as_root=True) operating_system.copy( ctlfile1_path, service.paths.ctlfile2_dir, preserve=True, as_root=True) # Set the db_name and db_unique_name via the PFILE which will be # removed later operating_system.write_file(service.paths.pfile, "*.db_unique_name='%s'\n" "*.db_name='%s'\n" % (db_unique_name, db_name), as_root=True) operating_system.chown(service.paths.pfile, service.instance_owner, service.instance_owner_group, as_root=True, force=True) service.admin.delete_conf_cache() service.admin.ora_config.db_name = db_name service.admin.ora_config.db_unique_name = db_unique_name # Set proper permissions on the oratab file operating_system.chown(service.paths.oratab_file, service.instance_owner, service.instance_owner_group, as_root=True, force=True) # Create the listener.ora file and restart service.configure_listener()
def prepare_slave(self, service, snapshot): """Prepare the environment needed for starting the slave Oracle processes. """ master_info = snapshot['master'] db_name = master_info['db_name'] db_unique_name = ('%(db_name)s_%(replica_label)s' % { 'db_name': db_name, 'replica_label': utils.generate_random_string(6) }) service.paths.update_db_name(db_name) # Create necessary directories and set necessary permissions new_dirs = [ service.paths.db_data_dir, service.paths.db_fast_recovery_logs_dir, service.paths.db_fast_recovery_dir, service.paths.audit_dir ] for directory in new_dirs: operating_system.create_directory(directory, service.instance_owner, service.instance_owner_group, as_root=True) chown_dirs = [ service.paths.fast_recovery_area, service.paths.admin_dir ] for directory in chown_dirs: operating_system.chown(directory, service.instance_owner, service.instance_owner_group, as_root=True) # Install on the slave files extracted from the master # (e.g. the control, pfile, password, oracle.cnf file ... etc) oradata_encoded = master_info['oradata'] tmp_data_path = path.join(TMP_DIR, 'oradata.tar.gz') operating_system.write_file(tmp_data_path, oradata_encoded, codec=stream_codecs.Base64Codec(), encode=False) utils.execute_with_timeout('tar', '-Pxzvf', tmp_data_path, run_as_root=True, root_helper='sudo') # Put the control file in place tmp_ctlfile_path = path.join(TMP_DIR, '%s_stby.ctl' % db_name) operating_system.move(tmp_ctlfile_path, service.paths.ctlfile1_file, as_root=True) operating_system.copy(service.paths.ctlfile1_file, service.paths.ctlfile2_file, preserve=True, as_root=True) # Set the db_name and db_unique_name via the PFILE which will be # removed later operating_system.write_file(service.paths.pfile, "*.db_unique_name='%s'\n" "*.db_name='%s'\n" % (db_unique_name, db_name), as_root=True) operating_system.chown(service.paths.pfile, service.instance_owner, service.instance_owner_group, as_root=True, force=True) service.admin.delete_conf_cache() service.admin.ora_config.db_name = db_name service.admin.ora_config.db_unique_name = db_unique_name # Set proper permissions on the oratab file operating_system.chown(service.paths.oratab_file, service.instance_owner, service.instance_owner_group, as_root=True, force=True) # Create the listener.ora file and restart service.configure_listener()
def prepare_slave(self, snapshot): """Prepare the environment needed for starting the slave Oracle processes. """ master_info = snapshot['master'] db_name = master_info['db_name'] tmp_dir = '/tmp' tmp_data_path = path.join(tmp_dir, 'oradata.tar.gz') orabase_path = CONF.get(MANAGER).oracle_base orahome_path = CONF.get(MANAGER).oracle_home db_data_path = path.join(orabase_path, 'oradata', db_name) fast_recovery_path = path.join(orabase_path, 'fast_recovery_area') db_fast_recovery_path = path.join(fast_recovery_path, db_name) audit_path = path.join(orabase_path, 'admin', db_name, 'adump') admin_path = path.join(orabase_path, 'admin') # Create necessary directories and set permissions directories = [db_data_path, db_fast_recovery_path, audit_path] for directory in directories: operating_system.create_directory(directory, system.ORACLE_INSTANCE_OWNER, system.ORACLE_GROUP_OWNER, as_root=True) operating_system.chown(fast_recovery_path, system.ORACLE_INSTANCE_OWNER, system.ORACLE_GROUP_OWNER, as_root=True) operating_system.chown(admin_path, system.ORACLE_INSTANCE_OWNER, system.ORACLE_GROUP_OWNER, as_root=True) # Install on the slave files extracted from the master # (e.g. the control, pfile, password, oracle.cnf file ... etc) oradata = master_info['oradata'] operating_system.write_file(tmp_data_path, oradata, codec=stream_codecs.Base64Codec()) utils.execute_with_timeout('tar', '-Pxzvf', tmp_data_path, run_as_root=True, root_helper='sudo') # Put the control file in place tmp_ctlfile_path = path.join(tmp_dir, '%s_stby.ctl' % db_name) ctlfile1_path = path.join(db_data_path, 'control01.ctl') ctlfile2_path = path.join(db_fast_recovery_path, 'control02.ctl') operating_system.move(tmp_ctlfile_path, ctlfile1_path, as_root=True) operating_system.copy(ctlfile1_path, ctlfile2_path, preserve=True, as_root=True) db_unique_name = ('%(db_name)s_%(replica_label)s' % { 'db_name': db_name, 'replica_label': utils.generate_random_string(6) }) # Customize the pfile for slave and put it in the right place. # The pfile that came from master is owned by the 'oracle' user, # so we need to change ownership first before editing it. tmp_pfile_path = path.join(tmp_dir, 'init%s_stby.ora' % db_name) pfile_path = path.join(orahome_path, 'dbs', 'init%s.ora' % db_name) operating_system.chown(tmp_pfile_path, getpass.getuser(), None, as_root=True) with open(tmp_pfile_path, 'a') as pfile: pfile.write("*.db_unique_name='%s'\n" % db_unique_name) # Finished editing pfile, put it in the proper directory and chown # back to oracle user and group operating_system.move(tmp_pfile_path, pfile_path, force=True, as_root=True) operating_system.chown(pfile_path, system.ORACLE_INSTANCE_OWNER, system.ORACLE_GROUP_OWNER, as_root=True) self.ORA_CONF.db_name = db_name self.ORA_CONF.db_unique_name = db_unique_name # Set proper permissions on the oratab file operating_system.chown('/etc/oratab', system.ORACLE_INSTANCE_OWNER, system.ORACLE_GROUP_OWNER, as_root=True) # Create the listener.ora file self._create_lsnr_file() # Restart the listener utils.execute_with_timeout("sudo", "su", "-", "oracle", "-c", "lsnrctl reload", timeout=CONF.usage_timeout)
def prepare_slave(self, snapshot): """Prepare the environment needed for starting the slave Oracle processes. """ master_info = snapshot['master'] db_name = master_info['db_name'] tmp_dir = '/tmp' tmp_data_path = path.join(tmp_dir, 'oradata.tar.gz') orabase_path = CONF.get(MANAGER).oracle_base orahome_path = CONF.get(MANAGER).oracle_home db_data_path = path.join(orabase_path, 'oradata', db_name) fast_recovery_path = path.join(orabase_path, 'fast_recovery_area') db_fast_recovery_path = path.join(fast_recovery_path, db_name) audit_path = path.join(orabase_path, 'admin', db_name, 'adump') admin_path = path.join(orabase_path, 'admin') # Create necessary directories and set permissions directories = [db_data_path, db_fast_recovery_path, audit_path] for directory in directories: operating_system.create_directory(directory, system.ORACLE_INSTANCE_OWNER, system.ORACLE_GROUP_OWNER, as_root=True) operating_system.chown(fast_recovery_path, system.ORACLE_INSTANCE_OWNER, system.ORACLE_GROUP_OWNER, as_root=True) operating_system.chown(admin_path, system.ORACLE_INSTANCE_OWNER, system.ORACLE_GROUP_OWNER, as_root=True) # Install on the slave files extracted from the master # (e.g. the control, pfile, password, oracle.cnf file ... etc) oradata = master_info['oradata'] operating_system.write_file(tmp_data_path, oradata, codec=stream_codecs.Base64Codec()) utils.execute_with_timeout('tar', '-Pxzvf', tmp_data_path, run_as_root=True, root_helper='sudo') # Put the control file in place tmp_ctlfile_path = path.join(tmp_dir, '%s_stby.ctl' % db_name) ctlfile1_path = path.join(db_data_path, 'control01.ctl') ctlfile2_path = path.join(db_fast_recovery_path, 'control02.ctl') operating_system.move(tmp_ctlfile_path, ctlfile1_path, as_root=True) operating_system.copy(ctlfile1_path, ctlfile2_path, preserve=True, as_root=True) db_unique_name = ('%(db_name)s_%(replica_label)s' % {'db_name': db_name, 'replica_label': utils.generate_random_string(6)}) # Customize the pfile for slave and put it in the right place. # The pfile that came from master is owned by the 'oracle' user, # so we need to change ownership first before editing it. tmp_pfile_path = path.join(tmp_dir, 'init%s_stby.ora' % db_name) pfile_path = path.join(orahome_path, 'dbs', 'init%s.ora' % db_name) operating_system.chown(tmp_pfile_path, getpass.getuser(), None, as_root=True) with open(tmp_pfile_path, 'a') as pfile: pfile.write("*.db_unique_name='%s'\n" % db_unique_name) # Finished editing pfile, put it in the proper directory and chown # back to oracle user and group operating_system.move(tmp_pfile_path, pfile_path, force=True, as_root=True) operating_system.chown(pfile_path, system.ORACLE_INSTANCE_OWNER, system.ORACLE_GROUP_OWNER, as_root=True) self.ORA_CONF.db_name = db_name self.ORA_CONF.db_unique_name = db_unique_name # Set proper permissions on the oratab file operating_system.chown('/etc/oratab', system.ORACLE_INSTANCE_OWNER, system.ORACLE_GROUP_OWNER, as_root=True) # Create the listener.ora file self._create_lsnr_file() # Restart the listener utils.execute_with_timeout("sudo", "su", "-", "oracle", "-c", "lsnrctl reload", timeout=CONF.usage_timeout)