Java tutorial
/* * Copyright (C) 2009 eXo Platform SAS. * * This is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as * published by the Free Software Foundation; either version 2.1 of * the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this software; if not, write to the Free * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA * 02110-1301 USA, or see the FSF site: http://www.fsf.org. */ package org.exoplatform.services.jcr.ext.backup.impl; import org.apache.commons.collections.map.HashedMap; import org.exoplatform.commons.utils.ClassLoading; import org.exoplatform.commons.utils.PrivilegedFileHelper; import org.exoplatform.commons.utils.PrivilegedSystemHelper; import org.exoplatform.commons.utils.SecurityHelper; import org.exoplatform.container.ExoContainerContext; import org.exoplatform.container.xml.InitParams; import org.exoplatform.container.xml.PropertiesParam; import org.exoplatform.services.jcr.RepositoryService; import org.exoplatform.services.jcr.config.RepositoryConfigurationException; import org.exoplatform.services.jcr.config.RepositoryEntry; import org.exoplatform.services.jcr.config.SimpleParameterEntry; import org.exoplatform.services.jcr.config.WorkspaceEntry; import org.exoplatform.services.jcr.config.WorkspaceInitializerEntry; import org.exoplatform.services.jcr.core.WorkspaceContainerFacade; import org.exoplatform.services.jcr.ext.backup.BackupChain; import org.exoplatform.services.jcr.ext.backup.BackupChainLog; import org.exoplatform.services.jcr.ext.backup.BackupConfig; import org.exoplatform.services.jcr.ext.backup.BackupConfigurationException; import org.exoplatform.services.jcr.ext.backup.BackupJob; import org.exoplatform.services.jcr.ext.backup.BackupJobListener; import org.exoplatform.services.jcr.ext.backup.BackupManager; import org.exoplatform.services.jcr.ext.backup.BackupOperationException; import org.exoplatform.services.jcr.ext.backup.ExtendedBackupManager; import org.exoplatform.services.jcr.ext.backup.JobEntryInfo; import org.exoplatform.services.jcr.ext.backup.RepositoryBackupChain; import org.exoplatform.services.jcr.ext.backup.RepositoryBackupChainLog; import org.exoplatform.services.jcr.ext.backup.RepositoryBackupConfig; import org.exoplatform.services.jcr.ext.backup.RepositoryRestoreExeption; import org.exoplatform.services.jcr.ext.backup.WorkspaceRestoreException; import org.exoplatform.services.jcr.ext.backup.impl.fs.FullBackupJob; import org.exoplatform.services.jcr.ext.backup.impl.rdbms.RdbmsWorkspaceInitializer; import org.exoplatform.services.jcr.ext.common.SessionProvider; import org.exoplatform.services.jcr.ext.registry.RegistryEntry; import org.exoplatform.services.jcr.ext.registry.RegistryService; import org.exoplatform.services.jcr.impl.backup.JCRRestore; import org.exoplatform.services.jcr.impl.core.RepositoryImpl; import org.exoplatform.services.jcr.impl.core.SysViewWorkspaceInitializer; import org.exoplatform.services.jcr.impl.dataflow.persistent.WorkspacePersistentDataManager; import org.exoplatform.services.jcr.impl.util.io.FileCleanerHolder; import org.exoplatform.services.jcr.util.IdGenerator; import org.exoplatform.services.log.ExoLogger; import org.exoplatform.services.log.Log; import org.exoplatform.ws.frameworks.json.impl.JsonException; import org.exoplatform.ws.frameworks.json.impl.JsonGeneratorImpl; import org.picocontainer.Startable; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.xml.sax.SAXException; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileFilter; import java.io.FileNotFoundException; import java.io.IOException; import java.io.PrintWriter; import java.security.PrivilegedExceptionAction; import java.util.ArrayList; import java.util.Calendar; import java.util.Collections; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; import java.util.concurrent.CopyOnWriteArrayList; import javax.jcr.PathNotFoundException; import javax.jcr.RepositoryException; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.parsers.ParserConfigurationException; /** * Created by The eXo Platform SAS .<br/> * * @author Gennady Azarenkov * @version $Id: $ */ public class BackupManagerImpl implements ExtendedBackupManager, Startable { protected static final Log LOG = ExoLogger.getLogger("exo.jcr.component.ext.BackupManagerImpl"); /** * Name of default incremental job period parameter in configuration. */ public final static String DEFAULT_INCREMENTAL_JOB_PERIOD = "default-incremental-job-period"; /** * Name of backup properties parameter in configuration. */ public final static String BACKUP_PROPERTIES = "backup-properties"; /** * Name of full backup type parameter in configuration. */ public final static String FULL_BACKUP_TYPE = "full-backup-type"; /** * Name of incremental backup type parameter in configuration. */ public final static String INCREMENTAL_BACKUP_TYPE = "incremental-backup-type"; /** * Default value of incremental job period parameter in configuration. */ public final static String DEFAULT_VALUE_INCREMENTAL_JOB_PERIOD = "3600"; /** * Default value of incremental backup type parameter in configuration. */ public final static String DEFAULT_VALUE_INCREMENTAL_BACKUP_TYPE = org.exoplatform.services.jcr.ext.backup.impl.fs.IncrementalBackupJob.class .getName(); /** * Default value of incremental backup type parameter in configuration. */ public final static String DEFAULT_VALUE_FULL_BACKUP_TYPE = org.exoplatform.services.jcr.ext.backup.impl.rdbms.FullBackupJob.class .getName(); /** * Name of backup dir parameter in configuration. */ public final static String BACKUP_DIR = "backup-dir"; /** * Backup messages log max. size. */ private static final int MESSAGES_MAXSIZE = 5; private static final String SERVICE_NAME = "BackupManager"; /** * The timeout to checking finish of backup. */ private static final long AUTO_STOPPER_TIMEOUT = 5000; /** * Value of default incremental job period. */ private long defaultIncrementalJobPeriod; /** * Value of default incremental period. */ private String defIncrPeriod; /** * Path to backup folder. */ private String backupDir; /** * Value of full backup type. */ private String fullBackupType; /** * Value of incremental backup type. */ private String incrementalBackupType; /** * Set of current workspace backups. */ private final Set<BackupChain> currentBackups; /** * Set of current repository backups. */ private final Set<RepositoryBackupChain> currentRepositoryBackups; /** * The list of workspace restore job. */ private List<JobWorkspaceRestore> restoreJobs; /** * The list of repository restore job. */ protected CopyOnWriteArrayList<JobRepositoryRestore> restoreRepositoryJobs; /** * Initialization parameters of service. */ private InitParams initParams; /** * Directory to log. */ private File logsDirectory; private final RepositoryService repoService; private final RegistryService registryService; private final BackupMessagesLog messages; private final MessagesListener messagesListener; private final WorkspaceBackupAutoStopper workspaceBackupStopper; private final RepositoryBackupAutoStopper repositoryBackupStopper; /** * Temporary directory; */ private final File tempDir; class MessagesListener implements BackupJobListener { public void onError(BackupJob job, String message, Throwable error) { messages.addError(makeJobInfo(job, error) + message, error); LOG.error(makeJobInfo(job, error) + message, error); } public void onStateChanged(BackupJob job) { messages.addMessage(makeJobInfo(job, null)); if (LOG.isDebugEnabled()) { LOG.debug(makeJobInfo(job, null)); } } private String makeJobInfo(BackupJob job, Throwable error) { StringBuilder jobInfo = new StringBuilder(); if (job != null) { switch (job.getType()) { case BackupJob.FULL: { jobInfo.append("FULL BACKUP"); break; } case BackupJob.INCREMENTAL: { jobInfo.append("INCREMENTAL BACKUP"); break; } } jobInfo.append(" ["); switch (job.getState()) { case BackupJob.FINISHED: { jobInfo.append("FINISHED"); break; } case BackupJob.STARTING: { jobInfo.append("STARTING"); break; } case BackupJob.WAITING: { jobInfo.append("WAITING"); break; } case BackupJob.WORKING: { jobInfo.append("WORKING"); break; } } jobInfo.append("]"); if (error != null) { jobInfo.append(" Error: ").append(error.getMessage()); } try { jobInfo.append(" log: ").append(job.getStorageURL().getPath()); } catch (BackupOperationException e) { if (LOG.isTraceEnabled()) { LOG.trace("An exception occurred: " + e.getMessage()); } } finally { jobInfo.append(" "); } } return jobInfo.toString(); } public String printStackTrace(Throwable error) { ByteArrayOutputStream out = new ByteArrayOutputStream(); PrintWriter writer = new PrintWriter(out); error.printStackTrace(writer); return new String(out.toByteArray()); } } class TaskFilter implements FileFilter { public boolean accept(File pathname) { return pathname.getName().endsWith(".task"); } } class WorkspaceBackupAutoStopper extends Thread { private boolean isToBeStopped = false; WorkspaceBackupAutoStopper(ExoContainerContext ctx) { super("WorkspaceBackupAutoStopper" + (ctx == null ? "" : " " + ctx.getName())); } /** * {@inheritDoc} */ @Override public void run() { while (!isToBeStopped) { try { Thread.sleep(AUTO_STOPPER_TIMEOUT); Iterator<BackupChain> it = currentBackups.iterator(); List<BackupChain> stopedList = new ArrayList<BackupChain>(); while (it.hasNext()) { BackupChain chain = it.next(); boolean isFinished = (chain.getBackupJobs().get(0).getState() == BackupJob.FINISHED); for (int i = 1; i < chain.getBackupJobs().size(); i++) { isFinished &= (chain.getBackupJobs().get(i).getState() == BackupJob.FINISHED); } if (isFinished) { stopedList.add(chain); } } // STOP backups for (BackupChain chain : stopedList) { stopBackup(chain); } } catch (InterruptedException e) { LOG.error("The interapted this thread.", e); } catch (Throwable e) //NOSONAR { LOG.error("The unknown error", e); } } } public void close() { isToBeStopped = true; } } class RepositoryBackupAutoStopper extends Thread { boolean isToBeStopped = false; RepositoryBackupAutoStopper(ExoContainerContext ctx) { super("RepositoryBackupAutoStopper" + (ctx == null ? "" : " " + ctx.getName())); } /** * {@inheritDoc} */ @Override public void run() { while (!isToBeStopped) { try { Thread.sleep(AUTO_STOPPER_TIMEOUT); Iterator<RepositoryBackupChain> it = currentRepositoryBackups.iterator(); List<RepositoryBackupChain> stopedList = new ArrayList<RepositoryBackupChain>(); while (it.hasNext()) { RepositoryBackupChain chain = it.next(); if (chain.isFinished()) { stopedList.add(chain); } } // STOP backups for (RepositoryBackupChain chain : stopedList) { stopBackup(chain); } } catch (InterruptedException e) { LOG.error("The interapted this thread.", e); } catch (Throwable e) //NOSONAR { LOG.error("The unknown error", e); } } } public void close() { isToBeStopped = true; } } /** * BackupManagerImpl constructor. * * @param initParams * InitParams, the init parameters * @param repoService * RepositoryService, the repository service */ public BackupManagerImpl(InitParams initParams, RepositoryService repoService) { this(null, initParams, repoService, null); } /** * BackupManagerImpl constructor. * * @param initParams * InitParams, the init parameters * @param repoService * RepositoryService, the repository service */ public BackupManagerImpl(ExoContainerContext ctx, InitParams initParams, RepositoryService repoService) { this(ctx, initParams, repoService, null); } /** * BackupManagerImpl constructor. * * InitParams, the init parameters * @param repoService * RepositoryService, the repository service * @param registryService * RegistryService, the registry service */ public BackupManagerImpl(InitParams initParams, RepositoryService repoService, RegistryService registryService) { this(null, initParams, repoService, registryService); } /** * BackupManagerImpl constructor. * * InitParams, the init parameters * @param repoService * RepositoryService, the repository service * @param registryService * RegistryService, the registry service */ public BackupManagerImpl(ExoContainerContext ctx, InitParams initParams, RepositoryService repoService, RegistryService registryService) { this.messagesListener = new MessagesListener(); this.repoService = repoService; this.registryService = registryService; this.initParams = initParams; this.tempDir = new File(PrivilegedSystemHelper.getProperty("java.io.tmpdir")); currentBackups = Collections.synchronizedSet(new HashSet<BackupChain>()); currentRepositoryBackups = Collections.synchronizedSet(new HashSet<RepositoryBackupChain>()); messages = new BackupMessagesLog(MESSAGES_MAXSIZE); this.restoreJobs = new ArrayList<JobWorkspaceRestore>(); this.restoreRepositoryJobs = new CopyOnWriteArrayList<JobRepositoryRestore>(); this.workspaceBackupStopper = new WorkspaceBackupAutoStopper(ctx); this.repositoryBackupStopper = new RepositoryBackupAutoStopper(ctx); } /** * {@inheritDoc} */ public Set<BackupChain> getCurrentBackups() { return currentBackups; } /** * {@inheritDoc} */ public BackupMessage[] getMessages() { return messages.getMessages(); } /** * {@inheritDoc} */ public BackupChainLog[] getBackupsLogs() { File[] cfs = PrivilegedFileHelper.listFiles(logsDirectory, new BackupLogsFilter()); List<BackupChainLog> logs = new ArrayList<BackupChainLog>(); for (int i = 0; i < cfs.length; i++) { File cf = cfs[i]; try { if (!isCurrentBackup(cf)) { logs.add(new BackupChainLog(cf)); } } catch (BackupOperationException e) { LOG.warn("Log file " + PrivilegedFileHelper.getAbsolutePath(cf) + " is bussy or corrupted. Skipped. " + e, e); } } BackupChainLog[] ls = new BackupChainLog[logs.size()]; logs.toArray(ls); return ls; } /** * {@inheritDoc} */ public RepositoryBackupChainLog[] getRepositoryBackupsLogs() { File[] cfs = PrivilegedFileHelper.listFiles(logsDirectory, new RepositoryBackupLogsFilter()); List<RepositoryBackupChainLog> logs = new ArrayList<RepositoryBackupChainLog>(); for (int i = 0; i < cfs.length; i++) { File cf = cfs[i]; try { if (!isCurrentRepositoryBackup(cf)) { logs.add(new RepositoryBackupChainLog(cf)); } } catch (BackupOperationException e) { LOG.warn("Log file " + PrivilegedFileHelper.getAbsolutePath(cf) + " is bussy or corrupted. Skipped. " + e, e); } } RepositoryBackupChainLog[] ls = new RepositoryBackupChainLog[logs.size()]; logs.toArray(ls); return ls; } /** * isCurrentBackup. * * @param log * File, the log to backup * @return boolean return the 'true' if this log is current backup. */ private boolean isCurrentBackup(File log) { for (BackupChain chain : currentBackups) { if (log.getName().equals(new File(chain.getLogFilePath()).getName())) { return true; } } return false; } /** * isCurrentRepositoryBackup. * * @param log * File, the log to backup * @return boolean return the 'true' if this log is current backup. */ private boolean isCurrentRepositoryBackup(File log) { for (RepositoryBackupChain chain : currentRepositoryBackups) { if (log.getName().equals(new File(chain.getLogFilePath()).getName())) { return true; } } return false; } protected void restoreOverInitializer(BackupChainLog log, String repositoryName, WorkspaceEntry workspaceEntry) throws BackupOperationException, RepositoryException, RepositoryConfigurationException, BackupConfigurationException { List<JobEntryInfo> list = log.getJobEntryInfos(); BackupConfig config = log.getBackupConfig(); String reposytoryName = (repositoryName == null ? config.getRepository() : repositoryName); String workspaceName = workspaceEntry.getName(); String fullbackupType = null; try { if ((ClassLoading.forName(log.getFullBackupType(), this).equals(FullBackupJob.class))) { fullbackupType = log.getFullBackupType(); } else if ((ClassLoading.forName(log.getFullBackupType(), this) .equals(org.exoplatform.services.jcr.ext.backup.impl.rdbms.FullBackupJob.class))) { fullbackupType = log.getFullBackupType(); } else { throw new BackupOperationException( "Class \"" + log.getFullBackupType() + "\" is not support as full backup."); } } catch (ClassNotFoundException e) { throw new BackupOperationException("Class \"" + log.getFullBackupType() + "\" is not found.", e); } // ws should not exists. if (!workspaceAlreadyExist(reposytoryName, workspaceName)) { for (int i = 0; i < list.size(); i++) { if (i == 0) { try { fullRestoreOverInitializer(list.get(i).getURL().getPath(), reposytoryName, workspaceEntry, fullbackupType); } catch (FileNotFoundException e) { throw new BackupOperationException("Restore of full backup file error " + e, e); } catch (IOException e) { throw new BackupOperationException("Restore of full backup file I/O error " + e, e); } catch (ClassNotFoundException e) { throw new BackupOperationException("Restore of full backup class load error " + e, e); } repoService.getConfig().retain(); // save configuration to persistence (file or persister) } else { try { incrementalRestore(list.get(i).getURL().getPath(), reposytoryName, workspaceName); } catch (FileNotFoundException e) { throw new BackupOperationException("Restore of incremental backup file error " + e, e); } catch (IOException e) { throw new BackupOperationException("Restore of incremental backup file I/O error " + e, e); } catch (ClassNotFoundException e) { throw new BackupOperationException("Restore of incremental backup error " + e, e); } } } } else { throw new BackupConfigurationException("Workspace \"" + workspaceName + "\" should not exists."); } } private boolean workspaceAlreadyExist(String repository, String workspace) throws RepositoryException, RepositoryConfigurationException { String[] ws = repoService.getRepository(repository).getWorkspaceNames(); for (int i = 0; i < ws.length; i++) { if (ws[i].equals(workspace)) { return true; } } return false; } /** * {@inheritDoc} */ public BackupChain startBackup(BackupConfig config) throws BackupOperationException, BackupConfigurationException, RepositoryException, RepositoryConfigurationException { return startBackup(config, null); } /** * Internally used for call with job listener from scheduler. * * @param config * @param jobListener * @return * @throws BackupOperationException * @throws BackupConfigurationException * @throws RepositoryException * @throws RepositoryConfigurationException */ BackupChain startBackup(BackupConfig config, BackupJobListener jobListener) throws BackupOperationException, BackupConfigurationException, RepositoryException, RepositoryConfigurationException { validateBackupConfig(config); Calendar startTime = Calendar.getInstance(); File dir = FileNameProducer.generateBackupSetDir(config.getRepository(), config.getWorkspace(), config.getBackupDir().getPath(), startTime); PrivilegedFileHelper.mkdirs(dir); config.setBackupDir(dir); BackupChain bchain = new BackupChainImpl(config, logsDirectory, repoService, fullBackupType, incrementalBackupType, IdGenerator.generate(), logsDirectory, startTime); bchain.addListener(messagesListener); bchain.addListener(jobListener); currentBackups.add(bchain); bchain.startBackup(); return bchain; } /** * Initialize backup chain to workspace backup. * * @param config * @return * @throws BackupOperationException * @throws BackupConfigurationException * @throws RepositoryException * @throws RepositoryConfigurationException */ private void validateBackupConfig(RepositoryBackupConfig config) throws BackupConfigurationException { if (config.getIncrementalJobPeriod() < 0) { throw new BackupConfigurationException("The parameter 'incremental job period' can not be negative."); } if (config.getIncrementalJobNumber() < 0) { throw new BackupConfigurationException("The parameter 'incremental job number' can not be negative."); } if (config.getIncrementalJobPeriod() == 0 && config.getBackupType() == BackupManager.FULL_AND_INCREMENTAL) { config.setIncrementalJobPeriod(defaultIncrementalJobPeriod); } } /** * {@inheritDoc} */ public void stopBackup(BackupChain backup) { backup.stopBackup(); currentBackups.remove(backup); } /** * {@inheritDoc} */ public void start() { this.workspaceBackupStopper.start(); this.repositoryBackupStopper.start(); if (!PrivilegedFileHelper.exists(tempDir)) { throw new IllegalStateException( "Directory " + tempDir.getAbsolutePath() + " not found. Please create it."); } //remove if exists all old jcrrestorewi*.tmp files. File[] files = PrivilegedFileHelper.listFiles(tempDir, new JcrRestoreWiFilter()); for (int i = 0; i < files.length; i++) { PrivilegedFileHelper.delete(files[i]); } // start all scheduled before tasks if (registryService != null && !registryService.getForceXMLConfigurationValue(initParams)) { SessionProvider sessionProvider = SessionProvider.createSystemProvider(); try { readParamsFromRegistryService(sessionProvider); } catch (Exception e) { readParamsFromFile(); try { writeParamsToRegistryService(sessionProvider); } catch (Exception exc) { LOG.error("Cannot write init configuration to RegistryService.", exc); } } finally { sessionProvider.close(); } } else { readParamsFromFile(); } } /** * {@inheritDoc} */ public void stop() { workspaceBackupStopper.close(); repositoryBackupStopper.close(); // 1. stop current backup chains // for (Iterator iterator = currentBackups.iterator(); iterator.hasNext();) { // BackupChain bc = (BackupChain) iterator.next(); // stopBackup(bc); // } // // // 2. stop all scheduled tasks // scheduler = null; } private void fullRestoreOverInitializer(String pathBackupFile, String repositoryName, WorkspaceEntry workspaceEntry, String fBackupType) throws FileNotFoundException, IOException, RepositoryException, RepositoryConfigurationException, ClassNotFoundException { WorkspaceInitializerEntry wieOriginal = workspaceEntry.getInitializer(); RepositoryImpl defRep = (RepositoryImpl) repoService.getRepository(repositoryName); WorkspaceInitializerEntry wiEntry = new WorkspaceInitializerEntry(); if ((ClassLoading.forName(fBackupType, this).equals(FullBackupJob.class))) { // set the initializer SysViewWorkspaceInitializer wiEntry.setType(SysViewWorkspaceInitializer.class.getCanonicalName()); List<SimpleParameterEntry> wieParams = new ArrayList<SimpleParameterEntry>(); wieParams.add( new SimpleParameterEntry(SysViewWorkspaceInitializer.RESTORE_PATH_PARAMETER, pathBackupFile)); wiEntry.setParameters(wieParams); } else if ((ClassLoading.forName(fBackupType, this) .equals(org.exoplatform.services.jcr.ext.backup.impl.rdbms.FullBackupJob.class))) { // set the initializer RdbmsWorkspaceInitializer wiEntry.setType(RdbmsWorkspaceInitializer.class.getCanonicalName()); List<SimpleParameterEntry> wieParams = new ArrayList<SimpleParameterEntry>(); wieParams.add(new SimpleParameterEntry(RdbmsWorkspaceInitializer.RESTORE_PATH_PARAMETER, new File(pathBackupFile).getParent())); wiEntry.setParameters(wieParams); } workspaceEntry.setInitializer(wiEntry); //restore defRep.configWorkspace(workspaceEntry); defRep.createWorkspace(workspaceEntry.getName()); //set original workspace initializer WorkspaceContainerFacade wcf = defRep.getWorkspaceContainer(workspaceEntry.getName()); WorkspaceEntry createdWorkspaceEntry = (WorkspaceEntry) wcf.getComponent(WorkspaceEntry.class); createdWorkspaceEntry.setInitializer(wieOriginal); } private void incrementalRestore(String pathBackupFile, String repositoryName, String workspaceName) throws RepositoryException, RepositoryConfigurationException, BackupOperationException, FileNotFoundException, IOException, ClassNotFoundException { WorkspaceContainerFacade workspaceContainer = repoService.getRepository(repositoryName) .getWorkspaceContainer(workspaceName); WorkspacePersistentDataManager dataManager = (WorkspacePersistentDataManager) workspaceContainer .getComponent(WorkspacePersistentDataManager.class); FileCleanerHolder cleanerHolder = (FileCleanerHolder) workspaceContainer .getComponent(FileCleanerHolder.class); JCRRestore restorer = new JCRRestore(dataManager, cleanerHolder.getFileCleaner()); restorer.incrementalRestore(new File(pathBackupFile)); } /** * Write parameters to RegistryService. * * @param sessionProvider * The SessionProvider * @throws ParserConfigurationException * @throws SAXException * @throws IOException * @throws RepositoryException */ private void writeParamsToRegistryService(SessionProvider sessionProvider) throws IOException, SAXException, ParserConfigurationException, RepositoryException { Document doc = SecurityHelper .doPrivilegedParserConfigurationAction(new PrivilegedExceptionAction<Document>() { public Document run() throws Exception { return DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument(); } }); Element root = doc.createElement(SERVICE_NAME); doc.appendChild(root); Element element = doc.createElement(BACKUP_PROPERTIES); setAttributeSmart(element, BACKUP_DIR, backupDir); setAttributeSmart(element, DEFAULT_INCREMENTAL_JOB_PERIOD, defIncrPeriod); setAttributeSmart(element, FULL_BACKUP_TYPE, fullBackupType); setAttributeSmart(element, INCREMENTAL_BACKUP_TYPE, incrementalBackupType); root.appendChild(element); RegistryEntry serviceEntry = new RegistryEntry(doc); registryService.createEntry(sessionProvider, RegistryService.EXO_SERVICES, serviceEntry); } /** * Read parameters from RegistryService. * * @param sessionProvider * The SessionProvider * @throws RepositoryException * @throws PathNotFoundException */ private void readParamsFromRegistryService(SessionProvider sessionProvider) throws PathNotFoundException, RepositoryException { String entryPath = RegistryService.EXO_SERVICES + "/" + SERVICE_NAME + "/" + BACKUP_PROPERTIES; RegistryEntry registryEntry = registryService.getEntry(sessionProvider, entryPath); Document doc = registryEntry.getDocument(); Element element = doc.getDocumentElement(); backupDir = getAttributeSmart(element, BACKUP_DIR); defIncrPeriod = getAttributeSmart(element, DEFAULT_INCREMENTAL_JOB_PERIOD); fullBackupType = getAttributeSmart(element, FULL_BACKUP_TYPE); incrementalBackupType = getAttributeSmart(element, INCREMENTAL_BACKUP_TYPE); LOG.info("Backup dir from RegistryService: " + backupDir); LOG.info("Default incremental job period from RegistryService: " + defIncrPeriod); LOG.info("Full backup type from RegistryService: " + fullBackupType); LOG.info("Incremental backup type from RegistryService: " + incrementalBackupType); checkParams(); } /** * Get attribute value. * * @param element * The element to get attribute value * @param attr * The attribute name * @return Value of attribute if present and null in other case */ private String getAttributeSmart(Element element, String attr) { return element.hasAttribute(attr) ? element.getAttribute(attr) : null; } /** * Set attribute value. If value is null the attribute will be removed. * * @param element * The element to set attribute value * @param attr * The attribute name * @param value * The value of attribute */ private void setAttributeSmart(Element element, String attr, String value) { if (value == null) { element.removeAttribute(attr); } else { element.setAttribute(attr, value); } } /** * Get parameters which passed from the file. * * @throws RepositoryConfigurationException */ private void readParamsFromFile() { PropertiesParam pps = initParams.getPropertiesParam(BACKUP_PROPERTIES); backupDir = pps.getProperty(BACKUP_DIR); // full backup type can be not defined. Using default. fullBackupType = pps.getProperty(FULL_BACKUP_TYPE) == null ? DEFAULT_VALUE_FULL_BACKUP_TYPE : pps.getProperty(FULL_BACKUP_TYPE); // incremental backup can be not configured. Using default values. defIncrPeriod = pps.getProperty(DEFAULT_INCREMENTAL_JOB_PERIOD) == null ? DEFAULT_VALUE_INCREMENTAL_JOB_PERIOD : pps.getProperty(DEFAULT_INCREMENTAL_JOB_PERIOD); incrementalBackupType = pps.getProperty(INCREMENTAL_BACKUP_TYPE) == null ? DEFAULT_VALUE_INCREMENTAL_BACKUP_TYPE : pps.getProperty(INCREMENTAL_BACKUP_TYPE); LOG.info("Backup dir from configuration file: " + backupDir); LOG.info("Full backup type from configuration file: " + fullBackupType); LOG.info("(Experimental) Incremental backup type from configuration file: " + incrementalBackupType); LOG.info("(Experimental) Default incremental job period from configuration file: " + defIncrPeriod); checkParams(); } /** * Check read params and initialize. */ private void checkParams() { if (backupDir == null) { throw new IllegalStateException(BACKUP_DIR + " not specified"); } logsDirectory = new File(backupDir); if (!PrivilegedFileHelper.exists(logsDirectory)) { if (!PrivilegedFileHelper.mkdirs(logsDirectory)) { throw new IllegalStateException( "Could not create the backup directory at " + logsDirectory.getAbsolutePath()); } } if (defIncrPeriod == null) { throw new IllegalStateException(DEFAULT_INCREMENTAL_JOB_PERIOD + " not specified"); } defaultIncrementalJobPeriod = Integer.valueOf(defIncrPeriod); if (fullBackupType == null) { throw new IllegalStateException(FULL_BACKUP_TYPE + " not specified"); } if (incrementalBackupType == null) { throw new IllegalStateException(INCREMENTAL_BACKUP_TYPE + " not specified"); } } /** * {@inheritDoc} */ public BackupChain findBackup(String repository, String workspace) { Iterator<BackupChain> it = currentBackups.iterator(); while (it.hasNext()) { BackupChain chain = it.next(); if (repository.equals(chain.getBackupConfig().getRepository()) && workspace.equals(chain.getBackupConfig().getWorkspace())) { return chain; } } return null; } /** * {@inheritDoc} */ public BackupChain findBackup(String backupId) { Iterator<BackupChain> it = currentBackups.iterator(); while (it.hasNext()) { BackupChain chain = it.next(); if (backupId.equals(chain.getBackupId())) { return chain; } } return null; } /** * getLogsDirectory. * * @return File * return the logs directory */ File getLogsDirectory() { return logsDirectory; } /** * {@inheritDoc} */ public File getBackupDirectory() { return getLogsDirectory(); } /** * {@inheritDoc} */ public String getFullBackupType() { return fullBackupType; } /** * {@inheritDoc} */ public String getIncrementalBackupType() { return incrementalBackupType; } /** * {@inheritDoc} */ public long getDefaultIncrementalJobPeriod() { return defaultIncrementalJobPeriod; } /** * {@inheritDoc} */ public List<JobWorkspaceRestore> getRestores() { return restoreJobs; } /** * {@inheritDoc} */ public JobWorkspaceRestore getLastRestore(String repositoryName, String workspaceName) { for (int i = restoreJobs.size() - 1; i >= 0; i--) { JobWorkspaceRestore job = restoreJobs.get(i); if (repositoryName.equals(job.getRepositoryName()) && workspaceName.equals(job.getWorkspaceName())) { return job; } } return null; } /** * {@inheritDoc} */ public JobRepositoryRestore getLastRepositoryRestore(String repositoryName) { for (int i = restoreRepositoryJobs.size() - 1; i >= 0; i--) { JobRepositoryRestore job = restoreRepositoryJobs.get(i); if (repositoryName.equals(job.getRepositoryName())) { return job; } } return null; } public List<JobRepositoryRestore> getRepositoryRestores() { return restoreRepositoryJobs; } /** * {@inheritDoc} */ public void restore(BackupChainLog log, String repositoryName, WorkspaceEntry workspaceEntry, boolean asynchronous) throws BackupOperationException, BackupConfigurationException, RepositoryException, RepositoryConfigurationException { if (workspaceEntry == null) { if (!log.getBackupConfig().getRepository().equals(repositoryName)) { throw new WorkspaceRestoreException( "If workspaceEntry is null, so will be restored with original configuration. " + "The repositoryName (\"" + repositoryName + "\") should be equals original repository name (\"" + log.getBackupConfig().getRepository() + "\"). "); } if (log.getOriginalWorkspaceEntry() == null) { throw new RepositoryRestoreExeption( "The backup log is not contains original repository log : " + log.getLogFilePath()); } this.restore(log, log.getBackupConfig().getRepository(), log.getOriginalWorkspaceEntry(), asynchronous); return; } if (asynchronous) { JobWorkspaceRestore jobRestore = new JobWorkspaceRestore(repoService, this, repositoryName, new File(log.getLogFilePath()), workspaceEntry); restoreJobs.add(jobRestore); jobRestore.start(); } else { this.restoreOverInitializer(log, repositoryName, workspaceEntry); } } /** * {@inheritDoc} */ public void restore(RepositoryBackupChainLog log, RepositoryEntry repositoryEntry, boolean asynchronous) throws BackupOperationException, BackupConfigurationException, RepositoryException, RepositoryConfigurationException { this.restore(log, repositoryEntry, asynchronous, false); } /** * {@inheritDoc} */ public void restore(RepositoryBackupChainLog log, RepositoryEntry repositoryEntry, boolean asynchronous, boolean removeJobOnceOver) throws BackupOperationException, BackupConfigurationException, RepositoryException, RepositoryConfigurationException { if (repositoryEntry == null) { if (log.getOriginalRepositoryEntry() == null) { throw new RepositoryRestoreExeption( "The backup log is not contains original repository log : " + log.getLogFilePath()); } this.restore(log, log.getOriginalRepositoryEntry(), asynchronous); return; } this.restoreRepository(log, repositoryEntry, null, asynchronous, removeJobOnceOver); } /** * {@inheritDoc} */ public void restore(RepositoryBackupChainLog rblog, RepositoryEntry repositoryEntry, Map<String, String> workspaceNamesCorrespondMap, boolean asynchronous) throws BackupOperationException, BackupConfigurationException, RepositoryException, RepositoryConfigurationException { this.restoreRepository(rblog, repositoryEntry, workspaceNamesCorrespondMap, asynchronous, false); } /** * Repository restore from backup. * * @param log * RepositoryBackupChainLog, the repository backup log * @param repositoryEntry * RepositoryEntry, the repository entry * @param workspaceNamesCorrespondMap * Map<String, String>, the map with correspondence workspace name in RepositoryEntry and RepositoryBackupChainLog. * @param asynchronous * boolean, in 'true' then asynchronous restore. * @param removeJobOnceOver * boolean, in 'true' then restore job well remove after restore. * @throws BackupOperationException * will be generate the exception BackupOperationException * @throws BackupConfigurationException * will be generate the exception BackupConfigurationException * @throws RepositoryException * will be generate the exception RepositoryException * @throws RepositoryConfigurationException * will be generate the exception RepositoryConfigurationException */ private void restoreRepository(RepositoryBackupChainLog rblog, RepositoryEntry repositoryEntry, Map<String, String> workspaceNamesCorrespondMap, boolean asynchronous, boolean removeJobOnceOver) throws BackupOperationException, BackupConfigurationException, RepositoryException, RepositoryConfigurationException { // Checking repository exists. try { repoService.getRepository(repositoryEntry.getName()); throw new BackupConfigurationException( "Repository \"" + repositoryEntry.getName() + "\" is already exists."); } catch (RepositoryException e) { //OK. Repository with "repositoryEntry.getName" is not exists. if (LOG.isTraceEnabled()) { LOG.trace("An exception occurred: " + e.getMessage()); } } Map<String, File> workspacesMapping = new HashedMap(); Map<String, BackupChainLog> backups = new HashedMap(); if (workspaceNamesCorrespondMap == null) { for (String path : rblog.getWorkspaceBackupsInfo()) { BackupChainLog bLog = new BackupChainLog(new File(path)); backups.put(bLog.getBackupConfig().getWorkspace(), bLog); } if (!rblog.getSystemWorkspace().equals(repositoryEntry.getSystemWorkspaceName())) { throw new BackupConfigurationException( "The backup to system workspace is not system workspace in repository entry: " + rblog.getSystemWorkspace() + " is not equal " + repositoryEntry.getSystemWorkspaceName()); } if (backups.size() != repositoryEntry.getWorkspaceEntries().size()) { throw new BackupConfigurationException( "The repository entry is contains more or less workspace entry than backups of workspace in " + rblog.getLogFilePath()); } for (WorkspaceEntry wsEntry : repositoryEntry.getWorkspaceEntries()) { if (!backups.containsKey(wsEntry.getName())) { throw new BackupConfigurationException("The workspace '" + wsEntry.getName() + "' is not found in backup " + rblog.getLogFilePath()); } else { workspacesMapping.put(wsEntry.getName(), new File(backups.get(wsEntry.getName()).getLogFilePath())); } } } else { // Create map [new_ws_name : backupLog to that workspace]. for (String path : rblog.getWorkspaceBackupsInfo()) { BackupChainLog bLog = new BackupChainLog(new File(path)); if (!workspaceNamesCorrespondMap.containsKey(bLog.getBackupConfig().getWorkspace())) { throw new BackupConfigurationException( "Can not found coresptonding workspace name to workspace '" + bLog.getBackupConfig().getWorkspace() + "' in " + workspaceNamesCorrespondMap.keySet()); } backups.put(workspaceNamesCorrespondMap.get(bLog.getBackupConfig().getWorkspace()), bLog); } // Checking system workspace. if (!repositoryEntry.getSystemWorkspaceName() .equals(workspaceNamesCorrespondMap.get(rblog.getSystemWorkspace()))) { throw new BackupConfigurationException( "The backup to system workspace is not system workspace in repository entry: " + repositoryEntry.getSystemWorkspaceName() + " is not equal " + workspaceNamesCorrespondMap.get(rblog.getSystemWorkspace())); } // Checking count of corresponding workspaces. if (workspaceNamesCorrespondMap.size() != repositoryEntry.getWorkspaceEntries().size()) { throw new BackupConfigurationException( "The repository entry is contains more or less workspace entry than backups of workspace in " + rblog.getLogFilePath()); } for (WorkspaceEntry wsEntry : repositoryEntry.getWorkspaceEntries()) { if (!workspaceNamesCorrespondMap.containsValue(wsEntry.getName())) { throw new BackupConfigurationException( "The workspace '" + wsEntry.getName() + "' is not found workspaceNamesCorrespondMap : " + workspaceNamesCorrespondMap.values()); } else if (!backups.containsKey(wsEntry.getName())) { throw new BackupConfigurationException("The workspace '" + wsEntry.getName() + "' is not found in backup " + rblog.getLogFilePath()); } else { workspacesMapping.put(wsEntry.getName(), new File(backups.get(wsEntry.getName()).getLogFilePath())); } } } JobRepositoryRestore jobRepositoryRestore = new JobRepositoryRestore(repoService, this, repositoryEntry, workspacesMapping, new File(rblog.getLogFilePath()), removeJobOnceOver); restoreRepositoryJobs.add(jobRepositoryRestore); if (asynchronous) { jobRepositoryRestore.start(); } else { jobRepositoryRestore.restore(); } } /** * {@inheritDoc} */ public RepositoryBackupChain startBackup(RepositoryBackupConfig config) throws BackupOperationException, BackupConfigurationException, RepositoryException, RepositoryConfigurationException { validateBackupConfig(config); File dir = new File(config.getBackupDir() + File.separator + "repository_" + config.getRepository() + "_backup_" + System.currentTimeMillis()); PrivilegedFileHelper.mkdirs(dir); config.setBackupDir(dir); RepositoryBackupChain repositoryBackupChain = new RepositoryBackupChainImpl(config, logsDirectory, repoService, fullBackupType, incrementalBackupType, IdGenerator.generate()); repositoryBackupChain.startBackup(); currentRepositoryBackups.add(repositoryBackupChain); return repositoryBackupChain; } /** * {@inheritDoc} */ public void stopBackup(RepositoryBackupChain backup) { backup.stopBackup(); currentRepositoryBackups.remove(backup); } /** * {@inheritDoc} */ public RepositoryBackupChain findRepositoryBackup(String repository) { Iterator<RepositoryBackupChain> it = currentRepositoryBackups.iterator(); while (it.hasNext()) { RepositoryBackupChain chain = it.next(); if (repository.equals(chain.getBackupConfig().getRepository())) { return chain; } } return null; } /** * {@inheritDoc} */ public Set<RepositoryBackupChain> getCurrentRepositoryBackups() { return currentRepositoryBackups; } /** * {@inheritDoc} */ public RepositoryBackupChain findRepositoryBackupId(String backupId) { Iterator<RepositoryBackupChain> it = currentRepositoryBackups.iterator(); while (it.hasNext()) { RepositoryBackupChain chain = it.next(); if (backupId.equals(chain.getBackupId())) { return chain; } } return null; } /** * {@inheritDoc} */ public void restoreExistingRepository(RepositoryBackupChainLog rblog, RepositoryEntry repositoryEntry, boolean asynchronous) throws BackupOperationException, BackupConfigurationException { try { // repository should be existed repoService.getRepository(repositoryEntry.getName()); } catch (RepositoryException e) { throw new RepositoryRestoreExeption( "Repository \"" + repositoryEntry.getName() + "\" should be existed", e); } catch (RepositoryConfigurationException e) { throw new RepositoryRestoreExeption( "Repository \"" + repositoryEntry.getName() + "\" should be existed", e); } Map<String, File> workspacesMapping = new HashedMap(); Map<String, BackupChainLog> backups = new HashedMap(); for (String path : rblog.getWorkspaceBackupsInfo()) { BackupChainLog bLog = new BackupChainLog(new File(path)); backups.put(bLog.getBackupConfig().getWorkspace(), bLog); } if (!rblog.getSystemWorkspace().equals(repositoryEntry.getSystemWorkspaceName())) { throw new BackupConfigurationException( "The backup to system workspace is not system workspace in repository entry: " + rblog.getSystemWorkspace() + " is not equal " + repositoryEntry.getSystemWorkspaceName()); } if (backups.size() != repositoryEntry.getWorkspaceEntries().size()) { throw new BackupConfigurationException( "The repository entry is contains more or less workspace entry than backups of workspace in " + rblog.getLogFilePath()); } for (WorkspaceEntry wsEntry : repositoryEntry.getWorkspaceEntries()) { if (!backups.containsKey(wsEntry.getName())) { throw new BackupConfigurationException("The workspace '" + wsEntry.getName() + "' is not found in backup " + rblog.getLogFilePath()); } else { workspacesMapping.put(wsEntry.getName(), new File(backups.get(wsEntry.getName()).getLogFilePath())); } } // check if we have deal with RDBMS backup boolean isSameConfigRestore = false; try { BackupChainLog bclog = new BackupChainLog( workspacesMapping.get(repositoryEntry.getWorkspaceEntries().get(0).getName())); if (ClassLoading.forName(bclog.getFullBackupType(), this) .equals(org.exoplatform.services.jcr.ext.backup.impl.rdbms.FullBackupJob.class)) { String newConf = new JsonGeneratorImpl().createJsonObject(repositoryEntry).toString(); String currnetConf = new JsonGeneratorImpl() .createJsonObject(repoService.getRepository(repositoryEntry.getName()).getConfiguration()) .toString(); isSameConfigRestore = newConf.equals(currnetConf); } } catch (JsonException e) { this.LOG.error("Can't get JSON object from wokrspace configuration", e); } catch (RepositoryException e) { this.LOG.error(e); } catch (RepositoryConfigurationException e) { this.LOG.error(e); } catch (ClassNotFoundException e) { this.LOG.error(e); } JobRepositoryRestore jobExistedRepositoryRestore = isSameConfigRestore ? new JobExistingRepositorySameConfigRestore(repoService, this, repositoryEntry, workspacesMapping, new File(rblog.getLogFilePath())) : new JobExistingRepositoryRestore(repoService, this, repositoryEntry, workspacesMapping, new File(rblog.getLogFilePath())); restoreRepositoryJobs.add(jobExistedRepositoryRestore); if (asynchronous) { jobExistedRepositoryRestore.start(); } else { jobExistedRepositoryRestore.restore(); } } /** * {@inheritDoc} */ public void restoreExistingRepository(String repositoryBackupIdentifier, RepositoryEntry repositoryEntry, boolean asynchronous) throws BackupOperationException, BackupConfigurationException { RepositoryBackupChainLog backupChainLog = null; for (RepositoryBackupChainLog chainLog : getRepositoryBackupsLogs()) { if (chainLog.getBackupId().equals(repositoryBackupIdentifier)) { backupChainLog = chainLog; break; } } if (backupChainLog == null) { throw new BackupConfigurationException( "Can not found backup of repository with id \"" + repositoryBackupIdentifier + "\""); } this.restoreExistingRepository(backupChainLog, repositoryEntry, asynchronous); } /** * {@inheritDoc} */ public void restoreExistingWorkspace(BackupChainLog log, String repositoryName, WorkspaceEntry workspaceEntry, boolean asynchronous) throws BackupOperationException, BackupConfigurationException { try { // repository should be existed repoService.getRepository(repositoryName); // workspace should be existed if (!workspaceAlreadyExist(repositoryName, workspaceEntry.getName())) { throw new WorkspaceRestoreException("Workspace \"" + workspaceEntry.getName() + "\" should be existed in repository \"" + repositoryName + "\"."); } } catch (RepositoryException e) { throw new WorkspaceRestoreException("Repository \"" + repositoryName + "\" should be existed", e); } catch (RepositoryConfigurationException e) { throw new WorkspaceRestoreException("Repository \"" + repositoryName + "\" should be existed", e); } // check if we need to use restore with same configuration as original // it allows to use atomic restore in cluster env boolean isSameConfigRestore = false; try { if (ClassLoading.forName(log.getFullBackupType(), this) .equals(org.exoplatform.services.jcr.ext.backup.impl.rdbms.FullBackupJob.class)) { WorkspaceEntry currentWsEntry = null; for (WorkspaceEntry wsEntry : repoService.getRepository(repositoryName).getConfiguration() .getWorkspaceEntries()) { if (wsEntry.getName().equals(workspaceEntry.getName())) { currentWsEntry = wsEntry; break; } } String newConf = new JsonGeneratorImpl().createJsonObject(workspaceEntry).toString(); String currnetConf = new JsonGeneratorImpl().createJsonObject(currentWsEntry).toString(); isSameConfigRestore = newConf.equals(currnetConf); } } catch (JsonException e) { LOG.error("Can't get JSON object from wokrspace configuration", e); } catch (RepositoryException e) { LOG.error(e); } catch (RepositoryConfigurationException e) { LOG.error(e); } catch (ClassNotFoundException e) { LOG.error(e); } JobWorkspaceRestore jobRestore; if (isSameConfigRestore) { jobRestore = new JobExistingWorkspaceSameConfigRestore(repoService, this, repositoryName, new File(log.getLogFilePath()), workspaceEntry); } else { jobRestore = new JobExistingWorkspaceRestore(repoService, this, repositoryName, new File(log.getLogFilePath()), workspaceEntry); } restoreJobs.add(jobRestore); if (asynchronous) { jobRestore.start(); } else { try { jobRestore.restore(); } catch (Throwable e) //NOSONAR { throw new BackupOperationException(e); } } } /** * {@inheritDoc} */ public void restoreExistingWorkspace(String workspaceBackupIdentifier, String repositoryName, WorkspaceEntry workspaceEntry, boolean asynchronous) throws BackupOperationException, BackupConfigurationException { BackupChainLog backupChainLog = null; for (BackupChainLog chainLog : getBackupsLogs()) { if (chainLog.getBackupId().equals(workspaceBackupIdentifier)) { backupChainLog = chainLog; break; } } if (backupChainLog == null) { throw new BackupConfigurationException( "Can not found backup of workspace with id \"" + workspaceBackupIdentifier + "\""); } this.restoreExistingWorkspace(backupChainLog, repositoryName, workspaceEntry, asynchronous); } /** * {@inheritDoc} */ public void restoreExistingRepository(String repositoryBackupIdentifier, boolean asynchronous) throws BackupOperationException, BackupConfigurationException { RepositoryBackupChainLog backupChainLog = null; for (RepositoryBackupChainLog chainLog : getRepositoryBackupsLogs()) { if (chainLog.getBackupId().equals(repositoryBackupIdentifier)) { backupChainLog = chainLog; break; } } if (backupChainLog == null) { throw new BackupConfigurationException( "Can not found backup of repository with id \"" + repositoryBackupIdentifier + "\""); } this.restoreExistingRepository(backupChainLog, backupChainLog.getOriginalRepositoryEntry(), asynchronous); } /** * {@inheritDoc} */ public void restoreExistingWorkspace(String workspaceBackupIdentifier, boolean asynchronous) throws BackupOperationException, BackupConfigurationException { BackupChainLog backupChainLog = null; for (BackupChainLog chainLog : getBackupsLogs()) { if (chainLog.getBackupId().equals(workspaceBackupIdentifier)) { backupChainLog = chainLog; break; } } if (backupChainLog == null) { throw new BackupConfigurationException( "Can not found backup of workspace with id \"" + workspaceBackupIdentifier + "\""); } this.restoreExistingWorkspace(backupChainLog, backupChainLog.getBackupConfig().getRepository(), backupChainLog.getOriginalWorkspaceEntry(), asynchronous); } /** * {@inheritDoc} */ public void restoreRepository(String repositoryBackupIdentifier, boolean asynchronous) throws BackupOperationException, BackupConfigurationException { RepositoryBackupChainLog backupChainLog = null; for (RepositoryBackupChainLog chainLog : getRepositoryBackupsLogs()) { if (chainLog.getBackupId().equals(repositoryBackupIdentifier)) { backupChainLog = chainLog; break; } } if (backupChainLog == null) { throw new BackupConfigurationException( "Can not found backup of repository with id \"" + repositoryBackupIdentifier + "\""); } try { this.restore(backupChainLog, backupChainLog.getOriginalRepositoryEntry(), asynchronous); } catch (RepositoryException e) { throw new RepositoryRestoreExeption( "Repository \"" + backupChainLog.getOriginalRepositoryEntry().getName() + "\" was not restored", e); } catch (RepositoryConfigurationException e) { throw new RepositoryRestoreExeption( "Repository \"" + backupChainLog.getOriginalRepositoryEntry().getName() + "\" was not restored", e); } } /** * {@inheritDoc} */ public void restoreWorkspace(String workspaceBackupIdentifier, boolean asynchronous) throws BackupOperationException, BackupConfigurationException { BackupChainLog backupChainLog = null; for (BackupChainLog chainLog : getBackupsLogs()) { if (chainLog.getBackupId().equals(workspaceBackupIdentifier)) { backupChainLog = chainLog; break; } } if (backupChainLog == null) { throw new BackupConfigurationException( "Can not found backup of workspace with id \"" + workspaceBackupIdentifier + "\""); } try { this.restore(backupChainLog, backupChainLog.getBackupConfig().getRepository(), backupChainLog.getOriginalWorkspaceEntry(), asynchronous); } catch (RepositoryException e) { throw new WorkspaceRestoreException("Workapce \"" + backupChainLog.getOriginalWorkspaceEntry().getName() + "\" was not restored in repository \"" + backupChainLog.getBackupConfig().getRepository() + "\"", e); } catch (RepositoryConfigurationException e) { throw new WorkspaceRestoreException("Workapce \"" + backupChainLog.getOriginalWorkspaceEntry().getName() + "\" was not restored in repository \"" + backupChainLog.getBackupConfig().getRepository() + "\"", e); } } /** * {@inheritDoc} */ public void restoreExistingRepository(File repositoryBackupSetDir, boolean asynchronous) throws BackupOperationException, BackupConfigurationException { File[] cfs = PrivilegedFileHelper.listFiles(repositoryBackupSetDir, new RepositoryBackupLogsFilter()); if (cfs.length == 0) { throw new BackupConfigurationException( "Can not found repository backup log in directory : " + repositoryBackupSetDir.getPath()); } if (cfs.length > 1) { throw new BackupConfigurationException( "Backup set directory should contains only one repository backup log : " + repositoryBackupSetDir.getPath()); } RepositoryBackupChainLog backupChainLog = new RepositoryBackupChainLog(cfs[0]); this.restoreExistingRepository(backupChainLog, backupChainLog.getOriginalRepositoryEntry(), asynchronous); } /** * {@inheritDoc} */ public void restoreExistingWorkspace(File workspaceBackupSetDir, boolean asynchronous) throws BackupOperationException, BackupConfigurationException { File[] cfs = PrivilegedFileHelper.listFiles(workspaceBackupSetDir, new BackupLogsFilter()); if (cfs.length == 0) { throw new BackupConfigurationException( "Can not found workspace backup log in directory : " + workspaceBackupSetDir.getPath()); } if (cfs.length > 1) { throw new BackupConfigurationException( "Backup set directory should contains only one workspace backup log : " + workspaceBackupSetDir.getPath()); } BackupChainLog backupChainLog = new BackupChainLog(cfs[0]); this.restoreExistingWorkspace(backupChainLog, backupChainLog.getBackupConfig().getRepository(), backupChainLog.getOriginalWorkspaceEntry(), asynchronous); } /** * {@inheritDoc} */ public void restoreRepository(File repositoryBackupSetDir, boolean asynchronous) throws BackupOperationException, BackupConfigurationException { File[] cfs = PrivilegedFileHelper.listFiles(repositoryBackupSetDir, new RepositoryBackupLogsFilter()); if (cfs.length == 0) { throw new BackupConfigurationException( "Can not found repository backup log in directory : " + repositoryBackupSetDir.getPath()); } if (cfs.length > 1) { throw new BackupConfigurationException( "Backup set directory should contains only one repository backup log : " + repositoryBackupSetDir.getPath()); } RepositoryBackupChainLog backupChainLog = new RepositoryBackupChainLog(cfs[0]); try { this.restore(backupChainLog, backupChainLog.getOriginalRepositoryEntry(), asynchronous); } catch (RepositoryException e) { throw new RepositoryRestoreExeption( "Repository \"" + backupChainLog.getOriginalRepositoryEntry().getName() + "\" was not restored", e); } catch (RepositoryConfigurationException e) { throw new RepositoryRestoreExeption( "Repository \"" + backupChainLog.getOriginalRepositoryEntry().getName() + "\" was not restored", e); } } /** * {@inheritDoc} */ public void restoreWorkspace(File workspaceBackupSetDir, boolean asynchronous) throws BackupOperationException, BackupConfigurationException { File[] cfs = PrivilegedFileHelper.listFiles(workspaceBackupSetDir, new BackupLogsFilter()); if (cfs.length == 0) { throw new BackupConfigurationException( "Can not found workspace backup log in directory : " + workspaceBackupSetDir.getPath()); } if (cfs.length > 1) { throw new BackupConfigurationException( "Backup set directory should contains only one workspace backup log : " + workspaceBackupSetDir.getPath()); } BackupChainLog backupChainLog = new BackupChainLog(cfs[0]); try { this.restore(backupChainLog, backupChainLog.getBackupConfig().getRepository(), backupChainLog.getOriginalWorkspaceEntry(), asynchronous); } catch (RepositoryException e) { throw new WorkspaceRestoreException("Workapce \"" + backupChainLog.getOriginalWorkspaceEntry().getName() + "\" was not restored in repository \"" + backupChainLog.getBackupConfig().getRepository() + "\"", e); } catch (RepositoryConfigurationException e) { throw new WorkspaceRestoreException("Workapce \"" + backupChainLog.getOriginalWorkspaceEntry().getName() + "\" was not restored in repository \"" + backupChainLog.getBackupConfig().getRepository() + "\"", e); } } }