Author: areshetnyak Date: 2010-12-08 04:35:29 -0500 (Wed, 08 Dec 2010) New Revision: 3617 Added: jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/AbstractBackupUseCasesTest.java jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/BaseRDBMSBackupTest.java jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/TestRDBMSBackupManager.java Modified: jcr/trunk/exo.jcr.component.ext/pom.xml jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/BackupChainLog.java jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/BackupManagerImpl.java jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/AbstractBackupTestCase.java jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/TestBackupManager.java jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/TestBackupRestart.java jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/TestBackupScheduler.java jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/TestRdbmsFullBackupJob.java jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/TestRdbmsWorkspaceInitializer.java jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/repository/creation/TestRepositoryCreationService.java Log: EXOJCR-1078 : Test TestRDBMSBAckupManager was added. Use RdbmsWorkspaceInitializer was added in restore. Modified: jcr/trunk/exo.jcr.component.ext/pom.xml =================================================================== --- jcr/trunk/exo.jcr.component.ext/pom.xml 2010-12-08 09:32:42 UTC (rev 3616) +++ jcr/trunk/exo.jcr.component.ext/pom.xml 2010-12-08 09:35:29 UTC (rev 3617) @@ -185,11 +185,15 @@ <include>**/replication/*.java</include> <include>**/replication/external/*.java</include> <include>**/replication/async/**/*.java</include> + <include>**/backup/TestFileNameProduser.java</include> + <include>**/**/TestFullBackupJob.java</include> <include>**/backup/*.java</include> </includes> <excludes> + <exclude>**/backup/TestRDBMSBackupManager.java</exclude> <exclude>**/BaseStandaloneTest.java</exclude> <exclude>**/backup/AbstractBackupTestCase.java</exclude> + <exclude>**/backup/BaseRDBMSBackupTest.java</exclude> <exclude>**/backup/TestBackupScheduler.java</exclude> <exclude>**/backup/TestBackupRestart.java</exclude> <exclude>**/replication/*.java</exclude> Modified: jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/BackupChainLog.java =================================================================== --- jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/BackupChainLog.java 2010-12-08 09:32:42 UTC (rev 3616) +++ jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/BackupChainLog.java 2010-12-08 09:35:29 UTC (rev 3617) @@ -106,6 +106,10 @@ private File rootDir; + private String fullBackupType; + + private String incrementalBackupType; + /** * BackupChainLog constructor. * @@ -135,6 +139,8 @@ PrivilegedFileHelper.createNewFile(this.log); this.rootDir = rootDir; this.backupId = backupId; + this.fullBackupType = fullBackupType; + this.incrementalBackupType = incrementalBackupType; this.config = config; this.jobEntries = new ArrayList<JobEntryInfo>(); this.originalWorkspaceEntry = wEntry; @@ -187,6 +193,8 @@ this.finishedTime = logReader.getEndTime(); this.jobEntries = logReader.getJobEntryInfoNormalizeList(); this.originalWorkspaceEntry = logReader.getOriginalWorkspaceEntry(); + this.fullBackupType = logReader.getFullBackupType(); + this.incrementalBackupType = logReader.getIncrementalBackupType(); for (JobEntryInfo info : jobEntries) { @@ -408,6 +416,10 @@ private String version; + private String iBackupType; + + private String fBackupType; + public LogReader(File logFile) throws FileNotFoundException, XMLStreamException, FactoryConfigurationError { this.logFile = logFile; @@ -417,6 +429,16 @@ PrivilegedFileHelper.fileInputStream(this.logFile), Constants.DEFAULT_ENCODING); } + public String getIncrementalBackupType() + { + return iBackupType; + } + + public String getFullBackupType() + { + return fBackupType; + } + public String getVersionLog() { return version; @@ -654,6 +676,12 @@ if (name.equals("incremental-job-number")) conf.setIncrementalJobNumber(Integer.valueOf(readContent()).intValue()); + if (name.equals("full-backup-type")) + this.fBackupType = readContent(); + + if (name.equals("incremental-backup-type")) + this.iBackupType = readContent(); + break; case StartElement.END_ELEMENT : @@ -901,4 +929,14 @@ { return finalized; } + + public String getFullBackupType() + { + return fullBackupType; + } + + public String getIncrementalBackupType() + { + return incrementalBackupType; + } } Modified: jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/BackupManagerImpl.java =================================================================== --- jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/BackupManagerImpl.java 2010-12-08 09:32:42 UTC (rev 3616) +++ jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/BackupManagerImpl.java 2010-12-08 09:35:29 UTC (rev 3617) @@ -76,10 +76,12 @@ 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.common.SessionProvider; import org.exoplatform.services.jcr.ext.registry.RegistryEntry; import org.exoplatform.services.jcr.ext.registry.RegistryService; import org.exoplatform.services.jcr.ext.replication.FixupStream; +import org.exoplatform.services.jcr.impl.core.RdbmsWorkspaceInitializer; import org.exoplatform.services.jcr.impl.core.RepositoryImpl; import org.exoplatform.services.jcr.impl.core.SessionImpl; import org.exoplatform.services.jcr.impl.core.SysViewWorkspaceInitializer; @@ -112,27 +114,27 @@ /** * Name of default incremental job period parameter in configuration. */ - private final static String DEFAULT_INCREMENTAL_JOB_PERIOD = "default-incremental-job-period"; + public final static String DEFAULT_INCREMENTAL_JOB_PERIOD = "default-incremental-job-period"; /** * Name of backup properties parameter in configuration. */ - private final static String BACKUP_PROPERTIES = "backup-properties"; + public final static String BACKUP_PROPERTIES = "backup-properties"; /** * Name of full backup type parameter in configuration. */ - private final static String FULL_BACKUP_TYPE = "full-backup-type"; + public final static String FULL_BACKUP_TYPE = "full-backup-type"; /** * Name of incremental backup type parameter in configuration. */ - private final static String INCREMENTAL_BACKUP_TYPE = "incremental-backup-type"; + public final static String INCREMENTAL_BACKUP_TYPE = "incremental-backup-type"; /** * Name of backup dir parameter in configuration. */ - private final static String BACKUP_DIR = "backup-dir"; + public final static String BACKUP_DIR = "backup-dir"; /** * Backup messages log max. size. @@ -650,6 +652,29 @@ String reposytoryName = (repositoryName == null ? config.getRepository() : repositoryName); String workspaceName = workspaceEntry.getName(); + String fullbackupType = null; + + try + { + if ((Class.forName(log.getFullBackupType()).equals(FullBackupJob.class))) + { + fullbackupType = log.getFullBackupType(); + } + else if ((Class.forName(log.getFullBackupType()) + .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)) { @@ -660,7 +685,8 @@ { try { - fullRestoreOverInitializer(list.get(i).getURL().getPath(), reposytoryName, workspaceEntry); + fullRestoreOverInitializer(list.get(i).getURL().getPath(), reposytoryName, workspaceEntry, + fullbackupType); } catch (FileNotFoundException e) { @@ -670,6 +696,10 @@ { 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) } @@ -874,22 +904,40 @@ defRep.importWorkspace(workspaceEntry.getName(), PrivilegedFileHelper.fileInputStream(pathBackupFile)); } - private void fullRestoreOverInitializer(String pathBackupFile, String repositoryName, WorkspaceEntry workspaceEntry) - throws FileNotFoundException, IOException, RepositoryException, RepositoryConfigurationException + 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); - // set the initializer SysViewWorkspaceInitializer WorkspaceInitializerEntry wiEntry = new WorkspaceInitializerEntry(); - wiEntry.setType(SysViewWorkspaceInitializer.class.getCanonicalName()); - List<SimpleParameterEntry> wieParams = new ArrayList<SimpleParameterEntry>(); - wieParams.add(new SimpleParameterEntry(SysViewWorkspaceInitializer.RESTORE_PATH_PARAMETER, pathBackupFile)); + if ((Class.forName(fBackupType).equals(FullBackupJob.class))) + { + // set the initializer SysViewWorkspaceInitializer + wiEntry.setType(SysViewWorkspaceInitializer.class.getCanonicalName()); - wiEntry.setParameters(wieParams); + List<SimpleParameterEntry> wieParams = new ArrayList<SimpleParameterEntry>(); + wieParams.add(new SimpleParameterEntry(SysViewWorkspaceInitializer.RESTORE_PATH_PARAMETER, pathBackupFile)); + wiEntry.setParameters(wieParams); + } + else if ((Class.forName(fBackupType) + .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(SysViewWorkspaceInitializer.RESTORE_PATH_PARAMETER, new File( + pathBackupFile).getParent())); + + wiEntry.setParameters(wieParams); + } + workspaceEntry.setInitializer(wiEntry); //restore Modified: jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/AbstractBackupTestCase.java =================================================================== --- jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/AbstractBackupTestCase.java 2010-12-08 09:32:42 UTC (rev 3616) +++ jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/AbstractBackupTestCase.java 2010-12-08 09:35:29 UTC (rev 3617) @@ -60,7 +60,7 @@ * @author <a href="mailto:peter.nedonosko@exoplatform.com.ua">Peter Nedonosko</a> * @version $Id: AbstractBackupTestCase.java 760 2008-02-07 15:08:07Z pnedonosko $ */ -public class AbstractBackupTestCase +public abstract class AbstractBackupTestCase extends BaseStandaloneTest { @@ -102,9 +102,7 @@ { super.setUp();// this - // RepositoryContainer rcontainer = (RepositoryContainer) - // container.getComponentInstanceOfType(RepositoryContainer.class); - backup = (ExtendedBackupManager) container.getComponentInstanceOfType(BackupManager.class); + backup = getBackupManager(); if (backup == null) throw new Exception("There are no BackupManagerImpl in configuration"); @@ -134,6 +132,9 @@ ws2Session = (SessionImpl) repository.login(credentials, "ws2"); } + protected abstract ExtendedBackupManager getBackupManager(); + + @Override protected void tearDown() throws Exception { Added: jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/AbstractBackupUseCasesTest.java =================================================================== --- jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/AbstractBackupUseCasesTest.java (rev 0) +++ jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/AbstractBackupUseCasesTest.java 2010-12-08 09:35:29 UTC (rev 3617) @@ -0,0 +1,2251 @@ +/* + * Copyright (C) 2003-2010 eXo Platform SAS. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation; either version 3 + * of the License, or (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see<http://www.gnu.org/licenses/>;. + */ +package org.exoplatform.services.jcr.ext.backup; + +import java.io.ByteArrayInputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.InputStream; +import java.util.Map; + +import javax.jcr.Node; +import javax.jcr.RepositoryException; +import javax.jcr.lock.Lock; + +import org.apache.commons.collections.map.HashedMap; +import org.exoplatform.services.jcr.config.RepositoryEntry; +import org.exoplatform.services.jcr.config.WorkspaceEntry; +import org.exoplatform.services.jcr.core.ManageableRepository; +import org.exoplatform.services.jcr.ext.backup.impl.JobRepositoryRestore; +import org.exoplatform.services.jcr.ext.backup.impl.JobWorkspaceRestore; +import org.exoplatform.services.jcr.impl.core.RepositoryImpl; +import org.exoplatform.services.jcr.impl.core.SessionImpl; + +/** + * Created by The eXo Platform SAS. + * + * <br/>Date: 2010 + * + * @author <a href="mailto:alex.reshetnyak@exoplatform.com.ua">Alex Reshetnyak</a> + * @version $Id$ + */ +public abstract class AbstractBackupUseCasesTest + extends AbstractBackupTestCase +{ + + public void testFullBackupRestore() throws Exception + { + // backup + File backDir = new File("target/backup/ws1"); + backDir.mkdirs(); + + BackupConfig config = new BackupConfig(); + config.setRepository(repository.getName()); + config.setWorkspace("ws1"); + config.setBackupType(BackupManager.FULL_BACKUP_ONLY); + + config.setBackupDir(backDir); + + backup.startBackup(config); + + BackupChain bch = backup.findBackup(repository.getName(), "ws1"); + + // wait till full backup will be stopped + while (bch.getFullBackupState() != BackupJob.FINISHED) + { + Thread.yield(); + Thread.sleep(50); + } + + // stop fullBackup + + if (bch != null) + backup.stopBackup(bch); + else + fail("Can't get fullBackup chain"); + + // restore + RepositoryEntry re = + (RepositoryEntry) ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); + WorkspaceEntry ws1back = makeWorkspaceEntry("ws1back", "jdbcjcr_backup_only_use_1"); + + // BackupChainLog bchLog = new BackupChainLog(backDir, rconfig); + File backLog = new File(bch.getLogFilePath()); + if (backLog.exists()) + { + BackupChainLog bchLog = new BackupChainLog(backLog); + + assertNotNull(bchLog.getStartedTime()); + assertNotNull(bchLog.getFinishedTime()); + + backup.restore(bchLog, re.getName(), ws1back, false); + + // check + SessionImpl back1 = null; + try + { + back1 = (SessionImpl) repository.login(credentials, "ws1back"); + Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); + assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") + .getProperty("exo:data").getString()); + } + catch (Exception e) + { + e.printStackTrace(); + fail(e.getMessage()); + } + finally + { + if (back1 != null) + back1.logout(); + } + } + else + fail("There are no backup files in " + backDir.getAbsolutePath()); + } + + public void testIncrementalBackupRestore() throws Exception + { + // full backup & incremental + File backDir = new File("target/backup/ws1.incr"); + backDir.mkdirs(); + + BackupConfig config = new BackupConfig(); + config.setRepository(repository.getName()); + config.setWorkspace("ws1"); + config.setBackupType(BackupManager.FULL_AND_INCREMENTAL); + + config.setBackupDir(backDir); + + backup.startBackup(config); + + BackupChain bch = backup.findBackup(repository.getName(), "ws1"); + + // wait till full backup will be stopped + while (bch.getFullBackupState() != BackupJob.FINISHED) + { + Thread.yield(); + Thread.sleep(50); + } + + // add some changes which will be logged in incremental log + ws1TestRoot.getNode("node_3").remove(); + ws1TestRoot.getNode("node_4").remove(); + ws1TestRoot.getNode("node_5").remove(); + ws1TestRoot.addNode("node #3").setProperty("exo:data", "property #3"); + ws1TestRoot.addNode("node #5").setProperty("exo:extraData", "property #5"); + + ws1TestRoot.save(); // log here via listener + + // stop all + if (bch != null) + backup.stopBackup(bch); + else + fail("Can't get fullBackup chain"); + + // restore + RepositoryEntry re = + (RepositoryEntry) ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); + WorkspaceEntry ws1back = makeWorkspaceEntry("ws1back.incr", "jdbcjcr_backup_only_use_2"); + + File backLog = new File(bch.getLogFilePath()); + if (backLog.exists()) + { + BackupChainLog bchLog = new BackupChainLog(backLog); + + assertNotNull(bchLog.getStartedTime()); + assertNotNull(bchLog.getFinishedTime()); + + backup.restore(bchLog, re.getName(), ws1back, false); + + // check + SessionImpl back1 = null; + try + { + back1 = (SessionImpl) repository.login(credentials, ws1back.getName()); + Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); + assertFalse("Node should be removed", ws1backTestRoot.hasNode("node_3")); + assertFalse("Node should be removed", ws1backTestRoot.hasNode("node_4")); + assertFalse("Node should be removed", ws1backTestRoot.hasNode("node_5")); + + assertEquals("Restored content should be same", "property #3", ws1backTestRoot.getNode("node #3") + .getProperty("exo:data").getString()); + assertEquals("Restored content should be same", "property #5", ws1backTestRoot.getNode("node #5") + .getProperty("exo:extraData").getString()); + + assertFalse("Proeprty should be removed", ws1backTestRoot.getNode("node #5").hasProperty("exo:data")); + } + catch (Exception e) + { + e.printStackTrace(); + fail(e.getMessage()); + } + finally + { + if (back1 != null) + back1.logout(); + } + } + else + fail("There are no backup files in " + backDir.getAbsolutePath()); + } + + /** + * With BLOBs, locks, copy and move + * + * @throws Exception + */ + + public void testIncrementalBackupRestore2() throws Exception + { + // full backup with BLOBs & incremental with BLOBs + + // BLOBs for full + File tempf = createBLOBTempFile("testIncrementalBackupRestore2-", 5 * 1024); // 5M + tempf.deleteOnExit(); + ws1TestRoot.addNode("node_101").setProperty("exo:data", new FileInputStream(tempf)); + ws1TestRoot.addNode("node_102").setProperty("exo:extraData", new FileInputStream(tempf)); + + File backDir = new File("target/backup/ws1.incr2"); + backDir.mkdirs(); + + BackupConfig config = new BackupConfig(); + config.setRepository(repository.getName()); + config.setWorkspace("ws1"); + config.setBackupType(BackupManager.FULL_AND_INCREMENTAL); + + config.setBackupDir(backDir); + + backup.startBackup(config); + + BackupChain bch = backup.findBackup(repository.getName(), "ws1"); + + // wait till full backup will be stopped + while (bch.getFullBackupState() != BackupJob.FINISHED) + { + Thread.yield(); + Thread.sleep(50); + } + + // add some changes which will be logged in incremental log + ws1TestRoot.addNode("node #53").setProperty("exo:extraData", "property #53"); + ws1TestRoot.save(); // log here via listener + + // BLOBs for incr + ws1TestRoot.getNode("node_1").setProperty("exo:extraData", new FileInputStream(tempf)); + ws1TestRoot.getNode("node_5").setProperty("exo:data", new FileInputStream(tempf)); + + ws1TestRoot.addNode("node_101").setProperty("exo:data", new FileInputStream(tempf)); + ws1TestRoot.addNode("node_102").setProperty("exo:data", new FileInputStream(tempf)); + ws1TestRoot.save(); // log here via listener + + ws1TestRoot.getNode("node_2").setProperty("exo:data", (InputStream) null); // remove property + ws1TestRoot.getNode("node_3").setProperty("exo:data", new ByteArrayInputStream("aaa".getBytes())); // set + // aaa + // bytes + ws1TestRoot.getNode("node_4").remove(); // (*) + ws1TestRoot.save(); // log here via listener + + ws1TestRoot.getNode("node_5").addMixin("mix:lockable"); + ws1TestRoot.save(); // log here via listener + Lock n107lock = ws1TestRoot.getNode("node_5").lock(true, false); + ws1TestRoot.getSession().move(ws1TestRoot.getNode("node #53").getPath(), + ws1TestRoot.getNode("node_5").getPath() + "/node #53"); + ws1TestRoot.save(); // log here via listener + + ws1TestRoot.getNode("node_6").addMixin("mix:referenceable"); + String id6 = ws1TestRoot.getNode("node_6").getUUID(); + ws1TestRoot.save(); // log here via listener + + // before(*), log here via listener + ws1TestRoot.getSession().getWorkspace().move(ws1TestRoot.getNode("node_6").getPath(), + ws1TestRoot.getPath() + "/node_4"); // in place of + // 4 removed + + // stop all + if (bch != null) + backup.stopBackup(bch); + else + fail("Can't get fullBackup chain"); + + // restore + RepositoryEntry re = + (RepositoryEntry) ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); + WorkspaceEntry ws1back = makeWorkspaceEntry("ws1back.incr2", "jdbcjcr_backup_only_use_3"); + + File backLog = new File(bch.getLogFilePath()); + if (backLog.exists()) + { + BackupChainLog bchLog = new BackupChainLog(backLog); + + assertNotNull(bchLog.getStartedTime()); + assertNotNull(bchLog.getFinishedTime()); + + backup.restore(bchLog, re.getName(), ws1back, false); + + // check + SessionImpl back1 = null; + try + { + back1 = (SessionImpl) repository.login(credentials, ws1back.getName()); + Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); + + assertTrue("Node should exists", ws1backTestRoot.getNode("node_5").hasNode("node #53")); + assertTrue("Property should exists", ws1backTestRoot.getNode("node_5") + .hasProperty("node #53/exo:extraData")); + + assertTrue("Node should exists", ws1backTestRoot.hasNode("node_7")); + assertTrue("Property should exists", ws1backTestRoot.hasProperty("node_5/exo:data")); + assertTrue("Property should exists", ws1backTestRoot.hasProperty("node_1/exo:extraData")); + assertTrue("Node should exists", ws1backTestRoot.hasNode("node_102")); + + compareStream(new FileInputStream(tempf), ws1backTestRoot.getNode("node_5").getProperty("exo:data") + .getStream()); + compareStream(new FileInputStream(tempf), ws1backTestRoot.getNode("node_1").getProperty("exo:extraData") + .getStream()); + + assertFalse("Property should be removed", ws1backTestRoot.getNode("node_2").hasProperty("exo:data")); + + compareStream(new ByteArrayInputStream("aaa".getBytes()), ws1backTestRoot.getNode("node_3").getProperty( + "exo:data").getStream()); + + assertTrue("Node should be mix:lockable ", ws1backTestRoot.getNode("node_5").isNodeType("mix:lockable")); + assertFalse("Node should be not locked ", ws1backTestRoot.getNode("node_5").isLocked()); + + assertEquals("Node should be mix:referenceable and UUID should be " + id6, id6, ws1backTestRoot.getNode( + "node_4").getUUID()); + } + catch (Exception e) + { + e.printStackTrace(); + fail(e.getMessage()); + } + finally + { + if (back1 != null) + back1.logout(); + } + } + else + fail("There are no backup files in " + backDir.getAbsolutePath()); + } + + public void testFullBackupRestoreAsync() throws Exception + { + SessionImpl sessionWS1 = (SessionImpl) repository.login(credentials, "ws1"); + sessionWS1.getRootNode().addNode("backupTest").addNode("node_5").setProperty("exo:data", + "Restored content should be same"); + sessionWS1.save(); + + // backup + File backDir = new File("target/backup/ws1_a"); + backDir.mkdirs(); + + BackupConfig config = new BackupConfig(); + config.setRepository(repository.getName()); + config.setWorkspace("ws1"); + config.setBackupType(BackupManager.FULL_BACKUP_ONLY); + + config.setBackupDir(backDir); + + backup.startBackup(config); + + BackupChain bch = backup.findBackup(repository.getName(), "ws1"); + + // wait till full backup will be stopped + while (bch.getFullBackupState() != BackupJob.FINISHED) + { + Thread.yield(); + Thread.sleep(50); + } + + // stop fullBackup + + if (bch != null) + backup.stopBackup(bch); + else + fail("Can't get fullBackup chain"); + + // restore + WorkspaceEntry ws1back = makeWorkspaceEntry("ws1back5", "jdbcjcr_backup_only_use_5"); + + File backLog = new File(bch.getLogFilePath()); + if (backLog.exists()) + { + BackupChainLog bchLog = new BackupChainLog(backLog); + + assertNotNull(bchLog.getStartedTime()); + assertNotNull(bchLog.getFinishedTime()); + + backup.restore(bchLog, repository.getName(), ws1back, true); + + while (backup.getLastRestore(repository.getName(), ws1back.getName()).getStateRestore() != JobWorkspaceRestore.RESTORE_SUCCESSFUL + && backup.getLastRestore(repository.getName(), ws1back.getName()).getStateRestore() != JobWorkspaceRestore.RESTORE_FAIL) + { + Thread.sleep(50); + } + + if (backup.getLastRestore(repository.getName(), ws1back.getName()).getStateRestore() == JobWorkspaceRestore.RESTORE_FAIL) + throw (Exception) backup.getLastRestore(repository.getName(), ws1back.getName()).getRestoreException(); + + // check + SessionImpl back1 = null; + try + { + back1 = (SessionImpl) repository.login(credentials, "ws1back5"); + Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); + assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") + .getProperty("exo:data").getString()); + } + catch (Exception e) + { + e.printStackTrace(); + fail(e.getMessage()); + } + finally + { + if (back1 != null) + back1.logout(); + } + } + else + fail("There are no backup files in " + backDir.getAbsolutePath()); + } + + public void testAutoStopBackupFull() throws Exception + { + // backup + File backDir = new File("target/backup/ws1_123"); + backDir.mkdirs(); + + BackupConfig config = new BackupConfig(); + config.setRepository(repository.getName()); + config.setWorkspace("ws1"); + config.setBackupType(BackupManager.FULL_BACKUP_ONLY); + + config.setBackupDir(backDir); + + BackupChain bch = backup.startBackup(config); + + Thread.sleep(11000); + + for (BackupChain chain : backup.getCurrentBackups()) + if (bch.getBackupId().equals(chain.getBackupId())) + fail("The backup with id '" + chain.getBackupId() + "' should not be active"); + } + + public void testAutoStopBackupIncr() throws Exception + { + // backup + File backDir = new File("target/backup/ws1_123_321"); + backDir.mkdirs(); + + BackupConfig config = new BackupConfig(); + config.setRepository(repository.getName()); + config.setWorkspace("ws1"); + config.setBackupType(BackupManager.FULL_AND_INCREMENTAL); + config.setBackupDir(backDir); + config.setIncrementalJobPeriod(3); + config.setIncrementalJobNumber(0); + + BackupChain bch = backup.startBackup(config); + + Thread.sleep(11000); + + boolean isFail = true; + + for (BackupChain chain : backup.getCurrentBackups()) + if (bch.getBackupId().equals(chain.getBackupId())) + isFail = false; + + if (isFail) + fail("The backup with id '" + bch.getBackupId() + "' should be active"); + } + + public void testAutoStopBackupIncrRepetion() throws Exception + { + // backup + File backDir = new File("target/backup/ws1_123321"); + backDir.mkdirs(); + + BackupConfig config = new BackupConfig(); + config.setRepository(repository.getName()); + config.setWorkspace("ws1"); + config.setBackupType(BackupManager.FULL_AND_INCREMENTAL); + config.setBackupDir(backDir); + config.setIncrementalJobPeriod(4); + config.setIncrementalJobNumber(2); + + final BackupChain bch = backup.startBackup(config); + + Thread.sleep(40000); + + assertTrue(bch.isFinished()); + + for (BackupChain chain : backup.getCurrentBackups()) + if (bch.getBackupId().equals(chain.getBackupId())) + fail("The backup with id '" + chain.getBackupId() + "' should not be active"); + } + + public void testTwoRestores() throws Exception + { + { + SessionImpl sessionWS1 = (SessionImpl) repository.login(credentials, "ws3"); + + sessionWS1.getRootNode().addNode("asdasdasda", "nt:unstructured").setProperty("data", + new FileInputStream(createBLOBTempFile(1024))); + sessionWS1.save(); + + // 1-st backup + File backDir = new File("target/backup/ws1_restore_1"); + backDir.mkdirs(); + + BackupConfig config = new BackupConfig(); + config.setRepository(repository.getName()); + config.setWorkspace("ws3"); + config.setBackupType(BackupManager.FULL_BACKUP_ONLY); + config.setBackupDir(backDir); + + BackupChain bch = backup.startBackup(config); + + // wait till full backup will be stopped + while (!bch.isFinished()) + { + Thread.yield(); + Thread.sleep(50); + } + + // 1-st restore + WorkspaceEntry ws1_restore_1 = makeWorkspaceEntry("ws1_restore_1", "jdbcjcr_backup_only_use_6"); + + File backLog = new File(bch.getLogFilePath()); + if (backLog.exists()) + { + BackupChainLog bchLog = new BackupChainLog(backLog); + + backup.restore(bchLog, repository.getName(), ws1_restore_1, false); + + // check + SessionImpl back1 = (SessionImpl) repository.login(credentials, "ws1_restore_1"); + assertNotNull(back1.getRootNode().getNode("asdasdasda").getProperty("data")); + + // add date to restored workspace + back1.getRootNode().addNode("gdfgrghfhf", "nt:unstructured").setProperty("data", + new FileInputStream(createBLOBTempFile(1024))); + back1.save(); + } + else + fail("There are no backup files in " + backDir.getAbsolutePath()); + } + + { + // 2-st backup + File backDir = new File("target/backup/ws1_restore_2"); + backDir.mkdirs(); + + BackupConfig config = new BackupConfig(); + config.setRepository(repository.getName()); + config.setWorkspace("ws1_restore_1"); + config.setBackupType(BackupManager.FULL_BACKUP_ONLY); + config.setBackupDir(backDir); + + BackupChain bch = backup.startBackup(config); + + // wait till full backup will be stopped + while (!bch.isFinished()) + { + Thread.yield(); + Thread.sleep(50); + } + + // 2-st restore + WorkspaceEntry ws1_restore_2 = makeWorkspaceEntry("ws1_restore_2", "jdbcjcr_backup_only_use_7"); + + File backLog = new File(bch.getLogFilePath()); + if (backLog.exists()) + { + BackupChainLog bchLog = new BackupChainLog(backLog); + + backup.restore(bchLog, repository.getName(), ws1_restore_2, false); + + // check + SessionImpl back2 = (SessionImpl) repository.login(credentials, "ws1_restore_2"); + assertNotNull(back2.getRootNode().getNode("gdfgrghfhf").getProperty("data")); + } + else + fail("There are no backup files in " + backDir.getAbsolutePath()); + } + } + + public void testStartFullBackupWIthJobPeriod() throws Exception + { + // backup + File backDir = new File("target/backup/ws1_fwp"); + backDir.mkdirs(); + + BackupConfig config = new BackupConfig(); + config.setRepository(repository.getName()); + config.setWorkspace("ws1"); + config.setBackupType(BackupManager.FULL_BACKUP_ONLY); + config.setBackupDir(backDir); + config.setIncrementalJobPeriod(3600); + + backup.startBackup(config); + + BackupChain bch = backup.findBackup(repository.getName(), "ws1"); + + // wait till full backup will be stopped + while (bch.getFullBackupState() != BackupJob.FINISHED) + { + Thread.yield(); + Thread.sleep(50); + } + } + + public void testNegativeIncremetalJobPeriod() throws Exception + { + // backup + File backDir = new File("target/backup/ws1_negative_period"); + backDir.mkdirs(); + + BackupConfig config = new BackupConfig(); + config.setRepository(repository.getName()); + config.setWorkspace("ws1"); + config.setBackupType(BackupManager.FULL_AND_INCREMENTAL); + config.setIncrementalJobPeriod(-1000); + + config.setBackupDir(backDir); + + try + { + backup.startBackup(config); + fail("The backup can not be started."); + } + catch (BackupConfigurationException e) + { + //ok + } + } + + public void testNegativeIncremetalJobNumber() throws Exception + { + // backup + File backDir = new File("target/backup/ws1_negative_job_number"); + backDir.mkdirs(); + + BackupConfig config = new BackupConfig(); + config.setRepository(repository.getName()); + config.setWorkspace("ws1"); + config.setBackupType(BackupManager.FULL_AND_INCREMENTAL); + config.setIncrementalJobNumber(-5); + + config.setBackupDir(backDir); + + try + { + backup.startBackup(config); + fail("The backup can not be started."); + } + catch (BackupConfigurationException e) + { + //ok + } + } + + public void testRestoreAfterFAilureRestore() throws Exception + { + // backup + File backDir = new File("target/backup/ws1"); + backDir.mkdirs(); + + BackupConfig config = new BackupConfig(); + config.setRepository(repository.getName()); + config.setWorkspace("ws1"); + config.setBackupType(BackupManager.FULL_BACKUP_ONLY); + + config.setBackupDir(backDir); + + backup.startBackup(config); + + BackupChain bch = backup.findBackup(repository.getName(), "ws1"); + + // wait till full backup will be stopped + while (bch.getFullBackupState() != BackupJob.FINISHED) + { + Thread.yield(); + Thread.sleep(50); + } + + // stop fullBackup + + if (bch != null) + backup.stopBackup(bch); + else + fail("Can't get fullBackup chain"); + + // restore + RepositoryEntry re = + (RepositoryEntry) ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); + WorkspaceEntry ws1back = makeWorkspaceEntry("ws1backt", "jdbcjcr_backup_only_use_8_NOT_EXIST"); + + File backLog = new File(bch.getLogFilePath()); + if (backLog.exists()) + { + BackupChainLog bchLog = new BackupChainLog(backLog); + + try + { + backup.restore(bchLog, re.getName(), ws1back, false); + fail("The backup can not be restored."); + } + catch (Exception e) + { + //ok + + WorkspaceEntry ws1backTwo = makeWorkspaceEntry("ws1backt", "jdbcjcr_backup_only_use_8"); + + backup.restore(bchLog, re.getName(), ws1backTwo, false); + } + + // check + SessionImpl back1 = null; + try + { + back1 = (SessionImpl) repository.login(credentials, "ws1back"); + Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); + assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") + .getProperty("exo:data").getString()); + } + catch (Exception e) + { + e.printStackTrace(); + fail(e.getMessage()); + } + finally + { + if (back1 != null) + back1.logout(); + } + } + else + fail("There are no backup files in " + backDir.getAbsolutePath()); + } + + public void testRepositoryFullBackupRestore() throws Exception + { + // backup + File backDir = new File("target/backup"); + backDir.mkdirs(); + + RepositoryBackupConfig config = new RepositoryBackupConfig(); + config.setRepository(repository.getName()); + config.setBackupType(BackupManager.FULL_BACKUP_ONLY); + + config.setBackupDir(backDir); + + backup.startBackup(config); + + RepositoryBackupChain bch = backup.findRepositoryBackup(repository.getName()); + + // wait till full backup will be stopped + while (bch.getState() != RepositoryBackupChain.FINISHED) + { + Thread.yield(); + Thread.sleep(50); + } + + // stop fullBackup + + backup.stopBackup(bch); + + // restore + RepositoryEntry re = + (RepositoryEntry) ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); + + String newRepositoryName = "repo_restored_1"; + RepositoryEntry newRepositoryEntry = + makeRepositoryEntry(newRepositoryName, re, "jdbcjcr_to_repository_restore_1", null); + + File backLog = new File(bch.getLogFilePath()); + if (backLog.exists()) + { + RepositoryBackupChainLog bchLog = new RepositoryBackupChainLog(backLog); + + assertNotNull(bchLog.getStartedTime()); + assertNotNull(bchLog.getFinishedTime()); + + backup.restore(bchLog, newRepositoryEntry, false); + assertEquals(JobWorkspaceRestore.RESTORE_SUCCESSFUL, backup.getLastRepositoryRestore( + newRepositoryEntry.getName()).getStateRestore()); + + // check + ManageableRepository restoredRepository = repositoryService.getRepository(newRepositoryName); + + for (String wsName : restoredRepository.getWorkspaceNames()) + { + SessionImpl back1 = null; + try + { + back1 = (SessionImpl) restoredRepository.login(credentials, wsName); + Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); + assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") + .getProperty("exo:data").getString()); + } + catch (Exception e) + { + e.printStackTrace(); + fail(e.getMessage()); + } + finally + { + if (back1 != null) + back1.logout(); + } + } + } + else + fail("There are no backup files in " + backDir.getAbsolutePath()); + } + + public void testRepositoryFullAndIncrementalBackupRestore() throws Exception + { + // backup + File backDir = new File("target/backup"); + backDir.mkdirs(); + + RepositoryBackupConfig config = new RepositoryBackupConfig(); + config.setRepository(repository.getName()); + config.setBackupType(BackupManager.FULL_AND_INCREMENTAL); + config.setIncrementalJobPeriod(1000); + + config.setBackupDir(backDir); + + backup.startBackup(config); + + RepositoryBackupChain bch = backup.findRepositoryBackup(repository.getName()); + + // wait till full backup will be stopped + while (bch.getState() != RepositoryBackupChain.FULL_BACKUP_FINISHED_INCREMENTAL_BACKUP_WORKING) + { + Thread.yield(); + Thread.sleep(50); + } + + // stop fullBackup + + backup.stopBackup(bch); + + // restore + RepositoryEntry re = + (RepositoryEntry) ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); + + String newRepositoryName = "repo_restored_4"; + RepositoryEntry newRepositoryEntry = + makeRepositoryEntry(newRepositoryName, re, "jdbcjcr_to_repository_restore_4", null); + + File backLog = new File(bch.getLogFilePath()); + if (backLog.exists()) + { + RepositoryBackupChainLog bchLog = new RepositoryBackupChainLog(backLog); + + assertNotNull(bchLog.getStartedTime()); + assertNotNull(bchLog.getFinishedTime()); + + backup.restore(bchLog, newRepositoryEntry, false); + + // check + ManageableRepository restoredRepository = repositoryService.getRepository(newRepositoryName); + + for (String wsName : restoredRepository.getWorkspaceNames()) + { + SessionImpl back1 = null; + try + { + back1 = (SessionImpl) repository.login(credentials, wsName); + Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); + assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") + .getProperty("exo:data").getString()); + } + catch (Exception e) + { + e.printStackTrace(); + fail(e.getMessage()); + } + finally + { + if (back1 != null) + back1.logout(); + } + } + } + else + fail("There are no backup files in " + backDir.getAbsolutePath()); + } + + public void testRepositoryFullBackupAsynchronusRestore() throws Exception + { + // backup + File backDir = new File("target/backup"); + backDir.mkdirs(); + + RepositoryBackupConfig config = new RepositoryBackupConfig(); + config.setRepository(repository.getName()); + config.setBackupType(BackupManager.FULL_BACKUP_ONLY); + + config.setBackupDir(backDir); + + backup.startBackup(config); + + RepositoryBackupChain bch = backup.findRepositoryBackup(repository.getName()); + + // wait till full backup will be stopped + while (bch.getState() != RepositoryBackupChain.FINISHED) + { + Thread.yield(); + Thread.sleep(50); + } + + // stop fullBackup + + backup.stopBackup(bch); + + // restore + RepositoryEntry re = + (RepositoryEntry) ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); + + String newRepositoryName = "repo_restored_2"; + RepositoryEntry newRepositoryEntry = + makeRepositoryEntry(newRepositoryName, re, "jdbcjcr_to_repository_restore_2", null); + + File backLog = new File(bch.getLogFilePath()); + if (backLog.exists()) + { + RepositoryBackupChainLog bchLog = new RepositoryBackupChainLog(backLog); + + assertNotNull(bchLog.getStartedTime()); + assertNotNull(bchLog.getFinishedTime()); + + backup.restore(bchLog, newRepositoryEntry, true); + + JobRepositoryRestore job = backup.getLastRepositoryRestore(newRepositoryName); + + while (job.getStateRestore() != JobRepositoryRestore.REPOSITORY_RESTORE_SUCCESSFUL + || job.getStateRestore() == JobRepositoryRestore.REPOSITORY_RESTORE_FAIL) + { + Thread.yield(); + Thread.sleep(50); + } + + // check + ManageableRepository restoredRepository = repositoryService.getRepository(newRepositoryName); + + for (String wsName : restoredRepository.getWorkspaceNames()) + { + SessionImpl back1 = null; + try + { + back1 = (SessionImpl) restoredRepository.login(credentials, wsName); + Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); + assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") + .getProperty("exo:data").getString()); + } + catch (Exception e) + { + e.printStackTrace(); + fail(e.getMessage()); + } + finally + { + if (back1 != null) + back1.logout(); + } + } + } + else + fail("There are no backup files in " + backDir.getAbsolutePath()); + } + + public void testRepositoryFullBackupAsynchronusRestoreWorkspaceMapping() throws Exception + { + // backup + File backDir = new File("target/backup"); + backDir.mkdirs(); + + RepositoryBackupConfig config = new RepositoryBackupConfig(); + config.setRepository(repository.getName()); + config.setBackupType(BackupManager.FULL_BACKUP_ONLY); + + config.setBackupDir(backDir); + + backup.startBackup(config); + + RepositoryBackupChain bch = backup.findRepositoryBackup(repository.getName()); + + // wait till full backup will be stopped + while (bch.getState() != RepositoryBackupChain.FINISHED) + { + Thread.yield(); + Thread.sleep(50); + } + + // stop fullBackup + + backup.stopBackup(bch); + + // restore + RepositoryEntry re = + (RepositoryEntry) ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); + + String newRepositoryName = "repo_restored_3"; + RepositoryEntry newRepositoryEntry = + makeRepositoryEntry(newRepositoryName, re, "jdbcjcr_to_repository_restore_3", null); + + // create workspace mappingS + Map<String, String> workspaceMapping = new HashedMap(); + for (WorkspaceEntry we : newRepositoryEntry.getWorkspaceEntries()) + { + workspaceMapping.put(we.getName(), we.getName() + "_mapped"); + } + + // Change workspaeNames + for (WorkspaceEntry we : newRepositoryEntry.getWorkspaceEntries()) + { + if (newRepositoryEntry.getSystemWorkspaceName().equals(we.getName())) + { + newRepositoryEntry.setSystemWorkspaceName(workspaceMapping.get(we.getName())); + newRepositoryEntry.setDefaultWorkspaceName(workspaceMapping.get(we.getName())); + } + + we.setName(workspaceMapping.get(we.getName())); + we.setUniqueName(we.getUniqueName() + workspaceMapping.get(we.getName())); + } + + File backLog = new File(bch.getLogFilePath()); + if (backLog.exists()) + { + RepositoryBackupChainLog bchLog = new RepositoryBackupChainLog(backLog); + + assertNotNull(bchLog.getStartedTime()); + assertNotNull(bchLog.getFinishedTime()); + + backup.restore(bchLog, newRepositoryEntry, workspaceMapping, true); + + JobRepositoryRestore job = backup.getLastRepositoryRestore(newRepositoryName); + + while (job.getStateRestore() != JobRepositoryRestore.REPOSITORY_RESTORE_SUCCESSFUL + || job.getStateRestore() == JobRepositoryRestore.REPOSITORY_RESTORE_FAIL) + { + Thread.yield(); + Thread.sleep(50); + } + + // check + ManageableRepository restoredRepository = repositoryService.getRepository(newRepositoryName); + + for (String wsName : restoredRepository.getWorkspaceNames()) + { + SessionImpl back1 = null; + try + { + back1 = (SessionImpl) restoredRepository.login(credentials, workspaceMapping.get(wsName)); + Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); + assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") + .getProperty("exo:data").getString()); + } + catch (Exception e) + { + e.printStackTrace(); + fail(e.getMessage()); + } + finally + { + if (back1 != null) + back1.logout(); + } + } + } + else + fail("There are no backup files in " + backDir.getAbsolutePath()); + } + + public void testAutoStopRepositoryBackupIncrRepetion() throws Exception + { + // backup + File backDir = new File("target/backup/" + repository.getName() + "_" + System.currentTimeMillis()); + backDir.mkdirs(); + + RepositoryBackupConfig config = new RepositoryBackupConfig(); + config.setRepository(repository.getName()); + config.setBackupType(BackupManager.FULL_AND_INCREMENTAL); + config.setBackupDir(backDir); + config.setIncrementalJobPeriod(4); + config.setIncrementalJobNumber(2); + + final RepositoryBackupChain bch = backup.startBackup(config); + + Thread.sleep(40000); + + assertTrue(bch.isFinished()); + + for (RepositoryBackupChain chain : backup.getCurrentRepositoryBackups()) + if (bch.getBackupId().equals(chain.getBackupId())) + fail("The backup with id '" + chain.getBackupId() + "' should not be active"); + } + + public void testRepositoryRestoreFail() throws Exception + { + // restore + RepositoryEntry re = + (RepositoryEntry) ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); + + String newRepositoryName = "repo_restored_5"; + RepositoryEntry newRepositoryEntry = + makeRepositoryEntry(newRepositoryName, re, "jdbcjcr_to_repository_restore_5", null); + + //create broken system workspaceEntry + newRepositoryEntry.getWorkspaceEntries().get(0).getQueryHandler().setType("gg"); + + File backLog = new File(backup.getRepositoryBackupsLogs()[0].getLogFilePath()); + + RepositoryBackupChainLog bchLog = new RepositoryBackupChainLog(backLog); + + try + { + backup.restore(bchLog, newRepositoryEntry, false); + fail("The backup " + backLog.getAbsolutePath() + "shoulde not restored."); + } + catch (RepositoryRestoreExeption e) + { + // ok. + } + + // check + + try + { + ManageableRepository restoredRepository = repositoryService.getRepository(newRepositoryName); + fail("The repository " + newRepositoryName + "shoulde not exists."); + } + catch (RepositoryException e) + { + // ok. + } + } + + public void testIncrementalBackupRestoreEXOJCR_737() throws Exception + { + // full backup with BLOBs & incremental with BLOBs + + // BLOBs for full + File tempf = createBLOBTempFile("testIncrementalBackupRestore737-", 5 * 1024); // 5M + tempf.deleteOnExit(); + + File backDir = new File("target/backup/ws1.incr737"); + backDir.mkdirs(); + + BackupConfig config = new BackupConfig(); + config.setRepository(repository.getName()); + config.setWorkspace("ws1"); + config.setBackupType(BackupManager.FULL_AND_INCREMENTAL); + + config.setBackupDir(backDir); + + backup.startBackup(config); + + BackupChain bch = backup.findBackup(repository.getName(), "ws1"); + + // wait till full backup will be stopped + while (bch.getFullBackupState() != BackupJob.FINISHED) + { + Thread.yield(); + Thread.sleep(50); + } + + // add data + ws1Session.getRootNode().addNode("node_101").setProperty("exo:data", new FileInputStream(tempf)); + ws1Session.getRootNode().addNode("node_102").setProperty("exo:extraData", new FileInputStream(tempf)); + ws1Session.getRootNode().save(); // log here via listener + + // stop backup + if (bch != null) + backup.stopBackup(bch); + else + fail("Can't get fullBackup chain"); + + //remove data + ws1Session.getRootNode().getNode("node_101").remove(); + ws1Session.getRootNode().getNode("node_102").remove(); + ws1Session.getRootNode().save(); + + // restore + RepositoryEntry re = + (RepositoryEntry) ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); + WorkspaceEntry ws1back = makeWorkspaceEntry("ws1back.incr737", "jdbcjcr25"); + + File backLog = new File(bch.getLogFilePath()); + if (backLog.exists()) + { + BackupChainLog bchLog = new BackupChainLog(backLog); + + assertNotNull(bchLog.getStartedTime()); + assertNotNull(bchLog.getFinishedTime()); + + backup.restore(bchLog, re.getName(), ws1back, false); + + // check + SessionImpl back1 = null; + try + { + back1 = (SessionImpl) repository.login(credentials, ws1back.getName()); + + Node node_101 = back1.getRootNode().getNode("node_101"); + assertNotNull(node_101); + assertEquals(tempf.length(), node_101.getProperty("exo:data").getStream().available()); + compareStream(new FileInputStream(tempf), node_101.getProperty("exo:data").getStream()); + + Node node_102 = back1.getRootNode().getNode("node_102"); + assertNotNull(node_102); + assertEquals(tempf.length(), node_102.getProperty("exo:extraData").getStream().available()); + compareStream(new FileInputStream(tempf), node_102.getProperty("exo:extraData").getStream()); + + } + catch (Exception e) + { + e.printStackTrace(); + fail(e.getMessage()); + } + finally + { + if (back1 != null) + back1.logout(); + } + } + else + fail("There are no backup files in " + backDir.getAbsolutePath()); + } + + public void testExistedWorkspaceRestore() throws Exception + { + // backup + File backDir = new File("target/backup/ws1"); + backDir.mkdirs(); + + BackupConfig config = new BackupConfig(); + config.setRepository(repository.getName()); + config.setWorkspace("ws1"); + config.setBackupType(BackupManager.FULL_BACKUP_ONLY); + + config.setBackupDir(backDir); + + backup.startBackup(config); + + BackupChain bch = backup.findBackup(repository.getName(), "ws1"); + + // wait till full backup will be stopped + while (bch.getFullBackupState() != BackupJob.FINISHED) + { + Thread.yield(); + Thread.sleep(50); + } + + // stop fullBackup + + if (bch != null) + backup.stopBackup(bch); + else + fail("Can't get fullBackup chain"); + + // restore + RepositoryEntry re = + (RepositoryEntry) ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); + WorkspaceEntry ws1 = null; + for (WorkspaceEntry we : re.getWorkspaceEntries()) + { + if (ws1Session.getWorkspace().getName().equals(we.getName())) + { + ws1 = we; + break; + } + } + + File backLog = new File(bch.getLogFilePath()); + if (backLog.exists()) + { + BackupChainLog bchLog = new BackupChainLog(backLog); + + assertNotNull(bchLog.getStartedTime()); + assertNotNull(bchLog.getFinishedTime()); + + backup.restoreExistingWorkspace(bchLog, re.getName(), ws1, false); + + // check + SessionImpl back1 = null; + try + { + back1 = (SessionImpl) repository.login(credentials, "ws1"); + Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); + assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") + .getProperty("exo:data").getString()); + } + catch (Exception e) + { + e.printStackTrace(); + fail(e.getMessage()); + } + finally + { + if (back1 != null) + back1.logout(); + } + } + else + fail("There are no backup files in " + backDir.getAbsolutePath()); + } + + public void testExistedWorkspaceRestoreAsync() throws Exception + { + // backup + File backDir = new File("target/backup/ws1"); + backDir.mkdirs(); + + BackupConfig config = new BackupConfig(); + config.setRepository(repository.getName()); + config.setWorkspace("ws1"); + config.setBackupType(BackupManager.FULL_BACKUP_ONLY); + + config.setBackupDir(backDir); + + backup.startBackup(config); + + BackupChain bch = backup.findBackup(repository.getName(), "ws1"); + + // wait till full backup will be stopped + while (bch.getFullBackupState() != BackupJob.FINISHED) + { + Thread.yield(); + Thread.sleep(50); + } + + // stop fullBackup + + if (bch != null) + backup.stopBackup(bch); + else + fail("Can't get fullBackup chain"); + + // restore + RepositoryEntry re = + (RepositoryEntry) ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); + WorkspaceEntry ws1 = null; + for (WorkspaceEntry we : re.getWorkspaceEntries()) + { + if (ws1Session.getWorkspace().getName().equals(we.getName())) + { + ws1 = we; + break; + } + } + + File backLog = new File(bch.getLogFilePath()); + if (backLog.exists()) + { + BackupChainLog bchLog = new BackupChainLog(backLog); + + assertNotNull(bchLog.getStartedTime()); + assertNotNull(bchLog.getFinishedTime()); + + backup.restoreExistingWorkspace(bchLog, re.getName(), ws1, true); + + while (backup.getLastRestore(repository.getName(), ws1.getName()).getStateRestore() != JobWorkspaceRestore.RESTORE_SUCCESSFUL + && backup.getLastRestore(repository.getName(), ws1.getName()).getStateRestore() != JobWorkspaceRestore.RESTORE_FAIL) + { + Thread.sleep(50); + } + + // check + SessionImpl back1 = null; + try + { + back1 = (SessionImpl) repository.login(credentials, "ws1"); + Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); + assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") + .getProperty("exo:data").getString()); + } + catch (Exception e) + { + e.printStackTrace(); + fail(e.getMessage()); + } + finally + { + if (back1 != null) + back1.logout(); + } + } + else + fail("There are no backup files in " + backDir.getAbsolutePath()); + } + + public void testExistedWorkspaceRestoreAsync2() throws Exception + { + // backup + File backDir = new File("target/backup/ws1"); + backDir.mkdirs(); + + BackupConfig config = new BackupConfig(); + config.setRepository(repository.getName()); + config.setWorkspace("ws1"); + config.setBackupType(BackupManager.FULL_BACKUP_ONLY); + + config.setBackupDir(backDir); + + backup.startBackup(config); + + BackupChain bch = backup.findBackup(repository.getName(), "ws1"); + + // wait till full backup will be stopped + while (bch.getFullBackupState() != BackupJob.FINISHED) + { + Thread.yield(); + Thread.sleep(50); + } + + // stop fullBackup + + if (bch != null) + backup.stopBackup(bch); + else + fail("Can't get fullBackup chain"); + + // restore + RepositoryEntry re = + (RepositoryEntry) ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); + WorkspaceEntry ws1 = null; + for (WorkspaceEntry we : re.getWorkspaceEntries()) + { + if (ws1Session.getWorkspace().getName().equals(we.getName())) + { + ws1 = we; + break; + } + } + + File backLog = new File(bch.getLogFilePath()); + if (backLog.exists()) + { + BackupChainLog bchLog = new BackupChainLog(backLog); + + assertNotNull(bchLog.getStartedTime()); + assertNotNull(bchLog.getFinishedTime()); + + backup.restoreExistingWorkspace(bchLog.getBackupId(), re.getName(), ws1, true); + + while (backup.getLastRestore(repository.getName(), ws1.getName()).getStateRestore() != JobWorkspaceRestore.RESTORE_SUCCESSFUL + && backup.getLastRestore(repository.getName(), ws1.getName()).getStateRestore() != JobWorkspaceRestore.RESTORE_FAIL) + { + Thread.sleep(50); + } + + // check + SessionImpl back1 = null; + try + { + back1 = (SessionImpl) repository.login(credentials, "ws1"); + Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); + assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") + .getProperty("exo:data").getString()); + } + catch (Exception e) + { + e.printStackTrace(); + fail(e.getMessage()); + } + finally + { + if (back1 != null) + back1.logout(); + } + } + else + fail("There are no backup files in " + backDir.getAbsolutePath()); + } + + public void testExistedRepositoryRestore() throws Exception + { + RepositoryImpl repositoryDB8 = (RepositoryImpl) repositoryService.getRepository("db8"); + + for (String wsName : repositoryDB8.getWorkspaceNames()) + { + SessionImpl sessionWS = (SessionImpl) repositoryDB8.login(credentials, wsName); + + Node wsTestRoot = sessionWS.getRootNode().addNode("backupTest"); + sessionWS.getRootNode().save(); + addContent(wsTestRoot, 1, 10, 1); + sessionWS.getRootNode().save(); + } + + SessionImpl sessionWS = (SessionImpl) repositoryDB8.login(credentials, WS_NAME); + + // backup + File backDir = new File("target/backup"); + backDir.mkdirs(); + + RepositoryBackupConfig config = new RepositoryBackupConfig(); + config.setRepository(repositoryDB8.getName()); + config.setBackupType(BackupManager.FULL_BACKUP_ONLY); + + config.setBackupDir(backDir); + + backup.startBackup(config); + + RepositoryBackupChain bch = backup.findRepositoryBackup(repositoryDB8.getName()); + + // wait till full backup will be stopped + while (bch.getState() != RepositoryBackupChain.FINISHED) + { + Thread.yield(); + Thread.sleep(50); + } + + // stop fullBackup + + backup.stopBackup(bch); + + // restore + RepositoryEntry baseRE = + (RepositoryEntry) sessionWS.getContainer().getComponentInstanceOfType(RepositoryEntry.class); + RepositoryEntry re = makeRepositoryEntry(baseRE.getName(), baseRE, null, null); + + File backLog = new File(bch.getLogFilePath()); + if (backLog.exists()) + { + RepositoryBackupChainLog bchLog = new RepositoryBackupChainLog(backLog); + + assertNotNull(bchLog.getStartedTime()); + assertNotNull(bchLog.getFinishedTime()); + + backup.restoreExistingRepository(bchLog, re, false); + + assertEquals(JobWorkspaceRestore.RESTORE_SUCCESSFUL, backup.getLastRepositoryRestore(re.getName()) + .getStateRestore()); + + // check + ManageableRepository restoredRepository = repositoryService.getRepository(re.getName()); + + for (String wsName : restoredRepository.getWorkspaceNames()) + { + SessionImpl back1 = null; + try + { + back1 = (SessionImpl) restoredRepository.login(credentials, wsName); + Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); + assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") + .getProperty("exo:data").getString()); + } + catch (Exception e) + { + e.printStackTrace(); + fail(e.getMessage()); + } + finally + { + if (back1 != null) + back1.logout(); + } + } + } + else + fail("There are no backup files in " + backDir.getAbsolutePath()); + } + + public void testExistedRepositoryRestoreMultiDB() throws Exception + { + RepositoryImpl repositoryDB7 = (RepositoryImpl) repositoryService.getRepository("db7"); + + for (String wsName : repositoryDB7.getWorkspaceNames()) + { + SessionImpl sessionWS = (SessionImpl) repositoryDB7.login(credentials, wsName); + + Node wsTestRoot = sessionWS.getRootNode().addNode("backupTest"); + sessionWS.getRootNode().save(); + addContent(wsTestRoot, 1, 10, 1); + sessionWS.getRootNode().save(); + } + + SessionImpl sessionWS = (SessionImpl) repositoryDB7.login(credentials, WS_NAME); + + // backup + File backDir = new File("target/backup"); + backDir.mkdirs(); + + RepositoryBackupConfig config = new RepositoryBackupConfig(); + config.setRepository(repositoryDB7.getName()); + config.setBackupType(BackupManager.FULL_BACKUP_ONLY); + + config.setBackupDir(backDir); + + backup.startBackup(config); + + RepositoryBackupChain bch = backup.findRepositoryBackup(repositoryDB7.getName()); + + // wait till full backup will be stopped + while (bch.getState() != RepositoryBackupChain.FINISHED) + { + Thread.yield(); + Thread.sleep(50); + } + + // stop fullBackup + + backup.stopBackup(bch); + + // restore + RepositoryEntry baseRE = + (RepositoryEntry) sessionWS.getContainer().getComponentInstanceOfType(RepositoryEntry.class); + RepositoryEntry re = makeRepositoryEntry(baseRE.getName(), baseRE, null, null); + + File backLog = new File(bch.getLogFilePath()); + if (backLog.exists()) + { + RepositoryBackupChainLog bchLog = new RepositoryBackupChainLog(backLog); + + assertNotNull(bchLog.getStartedTime()); + assertNotNull(bchLog.getFinishedTime()); + + backup.restoreExistingRepository(bchLog, re, false); + + assertEquals(JobWorkspaceRestore.RESTORE_SUCCESSFUL, backup.getLastRepositoryRestore(re.getName()) + .getStateRestore()); + + // check + ManageableRepository restoredRepository = repositoryService.getRepository(re.getName()); + + for (String wsName : restoredRepository.getWorkspaceNames()) + { + SessionImpl back1 = null; + try + { + back1 = (SessionImpl) restoredRepository.login(credentials, wsName); + Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); + assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") + .getProperty("exo:data").getString()); + } + catch (Exception e) + { + e.printStackTrace(); + fail(e.getMessage()); + } + finally + { + if (back1 != null) + back1.logout(); + } + } + } + else + fail("There are no backup files in " + backDir.getAbsolutePath()); + } + + public void testExistedRepositoryRestoreAsync() throws Exception + { + RepositoryImpl repositoryDB8 = (RepositoryImpl) repositoryService.getRepository("db8"); + + for (String wsName : repositoryDB8.getWorkspaceNames()) + { + SessionImpl sessionWS = (SessionImpl) repositoryDB8.login(credentials, wsName); + + Node wsTestRoot = sessionWS.getRootNode().addNode("backupTest"); + sessionWS.getRootNode().save(); + addContent(wsTestRoot, 1, 10, 1); + sessionWS.getRootNode().save(); + } + + SessionImpl sessionWS = (SessionImpl) repositoryDB8.login(credentials, WS_NAME); + + // backup + File backDir = new File("target/backup"); + backDir.mkdirs(); + + RepositoryBackupConfig config = new RepositoryBackupConfig(); + config.setRepository(repositoryDB8.getName()); + config.setBackupType(BackupManager.FULL_BACKUP_ONLY); + + config.setBackupDir(backDir); + + backup.startBackup(config); + + RepositoryBackupChain bch = backup.findRepositoryBackup(repositoryDB8.getName()); + + // wait till full backup will be stopped + while (bch.getState() != RepositoryBackupChain.FINISHED) + { + Thread.yield(); + Thread.sleep(50); + } + + // stop fullBackup + + backup.stopBackup(bch); + + // restore + RepositoryEntry baseRE = + (RepositoryEntry) sessionWS.getContainer().getComponentInstanceOfType(RepositoryEntry.class); + RepositoryEntry re = makeRepositoryEntry(baseRE.getName(), baseRE, null, null); + + File backLog = new File(bch.getLogFilePath()); + if (backLog.exists()) + { + RepositoryBackupChainLog bchLog = new RepositoryBackupChainLog(backLog); + + assertNotNull(bchLog.getStartedTime()); + assertNotNull(bchLog.getFinishedTime()); + + backup.restoreExistingRepository(bchLog, re, true); + + JobRepositoryRestore job = backup.getLastRepositoryRestore(re.getName()); + + while (job.getStateRestore() != JobRepositoryRestore.REPOSITORY_RESTORE_SUCCESSFUL + && job.getStateRestore() != JobRepositoryRestore.REPOSITORY_RESTORE_FAIL) + { + Thread.sleep(50); + } + + assertEquals(JobRepositoryRestore.REPOSITORY_RESTORE_SUCCESSFUL, backup.getLastRepositoryRestore(re.getName()) + .getStateRestore()); + + // check + ManageableRepository restoredRepository = repositoryService.getRepository(re.getName()); + + for (String wsName : restoredRepository.getWorkspaceNames()) + { + SessionImpl back1 = null; + try + { + back1 = (SessionImpl) restoredRepository.login(credentials, wsName); + Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); + assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") + .getProperty("exo:data").getString()); + } + catch (Exception e) + { + e.printStackTrace(); + fail(e.getMessage()); + } + finally + { + if (back1 != null) + back1.logout(); + } + } + } + else + fail("There are no backup files in " + backDir.getAbsolutePath()); + } + + public void testExistedRepositoryRestoreAsync2() throws Exception + { + RepositoryImpl repositoryDB8 = (RepositoryImpl) repositoryService.getRepository("db8"); + + for (String wsName : repositoryDB8.getWorkspaceNames()) + { + SessionImpl sessionWS = (SessionImpl) repositoryDB8.login(credentials, wsName); + + Node wsTestRoot = sessionWS.getRootNode().addNode("backupTest"); + sessionWS.getRootNode().save(); + addContent(wsTestRoot, 1, 10, 1); + sessionWS.getRootNode().save(); + } + + SessionImpl sessionWS = (SessionImpl) repositoryDB8.login(credentials, WS_NAME); + + // backup + File backDir = new File("target/backup"); + backDir.mkdirs(); + + RepositoryBackupConfig config = new RepositoryBackupConfig(); + config.setRepository(repositoryDB8.getName()); + config.setBackupType(BackupManager.FULL_BACKUP_ONLY); + + config.setBackupDir(backDir); + + backup.startBackup(config); + + RepositoryBackupChain bch = backup.findRepositoryBackup(repositoryDB8.getName()); + + // wait till full backup will be stopped + while (bch.getState() != RepositoryBackupChain.FINISHED) + { + Thread.yield(); + Thread.sleep(50); + } + + // stop fullBackup + + backup.stopBackup(bch); + + // restore + RepositoryEntry baseRE = + (RepositoryEntry) sessionWS.getContainer().getComponentInstanceOfType(RepositoryEntry.class); + RepositoryEntry re = makeRepositoryEntry(baseRE.getName(), baseRE, null, null); + + File backLog = new File(bch.getLogFilePath()); + if (backLog.exists()) + { + RepositoryBackupChainLog bchLog = new RepositoryBackupChainLog(backLog); + + assertNotNull(bchLog.getStartedTime()); + assertNotNull(bchLog.getFinishedTime()); + + backup.restoreExistingRepository(bchLog.getBackupId(), re, true); + + JobRepositoryRestore job = backup.getLastRepositoryRestore(re.getName()); + + while (job.getStateRestore() != JobRepositoryRestore.REPOSITORY_RESTORE_SUCCESSFUL + && job.getStateRestore() != JobRepositoryRestore.REPOSITORY_RESTORE_FAIL) + { + Thread.sleep(50); + } + + assertEquals(JobWorkspaceRestore.RESTORE_SUCCESSFUL, backup.getLastRepositoryRestore(re.getName()) + .getStateRestore()); + + // check + ManageableRepository restoredRepository = repositoryService.getRepository(re.getName()); + + for (String wsName : restoredRepository.getWorkspaceNames()) + { + SessionImpl back1 = null; + try + { + back1 = (SessionImpl) restoredRepository.login(credentials, wsName); + Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); + assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") + .getProperty("exo:data").getString()); + } + catch (Exception e) + { + e.printStackTrace(); + fail(e.getMessage()); + } + finally + { + if (back1 != null) + back1.logout(); + } + } + } + else + fail("There are no backup files in " + backDir.getAbsolutePath()); + } + + public void testExistedWorkspaceRestoreMultiDB() throws Exception + { + RepositoryImpl repositoryDB7 = (RepositoryImpl) repositoryService.getRepository("db7"); + + SessionImpl sessionWS = (SessionImpl) repositoryDB7.login(credentials, "ws1"); + + Node wsTestRoot = sessionWS.getRootNode().addNode("backupTest"); + sessionWS.getRootNode().save(); + addContent(wsTestRoot, 1, 10, 1); + sessionWS.getRootNode().save(); + + // backup + File backDir = new File("target/backup/ws1"); + backDir.mkdirs(); + + BackupConfig config = new BackupConfig(); + config.setRepository(repositoryDB7.getName()); + config.setWorkspace("ws1"); + config.setBackupType(BackupManager.FULL_BACKUP_ONLY); + + config.setBackupDir(backDir); + + backup.startBackup(config); + + BackupChain bch = backup.findBackup(repositoryDB7.getName(), "ws1"); + + // wait till full backup will be stopped + while (bch.getFullBackupState() != BackupJob.FINISHED) + { + Thread.yield(); + Thread.sleep(50); + } + + // stop fullBackup + + if (bch != null) + backup.stopBackup(bch); + else + fail("Can't get fullBackup chain"); + + // restore + RepositoryEntry re = (RepositoryEntry) sessionWS.getContainer().getComponentInstanceOfType(RepositoryEntry.class); + WorkspaceEntry ws1 = null; + for (WorkspaceEntry we : re.getWorkspaceEntries()) + { + if (sessionWS.getWorkspace().getName().equals(we.getName())) + { + ws1 = we; + break; + } + } + + File backLog = new File(bch.getLogFilePath()); + if (backLog.exists()) + { + BackupChainLog bchLog = new BackupChainLog(backLog); + + assertNotNull(bchLog.getStartedTime()); + assertNotNull(bchLog.getFinishedTime()); + + backup.restoreExistingWorkspace(bchLog, re.getName(), ws1, false); + + // check + SessionImpl back1 = null; + try + { + back1 = (SessionImpl) repositoryDB7.login(credentials, "ws1"); + Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); + assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") + .getProperty("exo:data").getString()); + } + catch (Exception e) + { + e.printStackTrace(); + fail(e.getMessage()); + } + finally + { + if (back1 != null) + back1.logout(); + } + } + else + fail("There are no backup files in " + backDir.getAbsolutePath()); + } + + public void testExistedWorkspaceRestoreWithConfig() throws Exception + { + // backup + File backDir = new File("target/backup/ws1"); + backDir.mkdirs(); + + BackupConfig config = new BackupConfig(); + config.setRepository(repository.getName()); + config.setWorkspace("ws1"); + config.setBackupType(BackupManager.FULL_BACKUP_ONLY); + + config.setBackupDir(backDir); + + backup.startBackup(config); + + BackupChain bch = backup.findBackup(repository.getName(), "ws1"); + + // wait till full backup will be stopped + while (bch.getFullBackupState() != BackupJob.FINISHED) + { + Thread.yield(); + Thread.sleep(50); + } + + // stop fullBackup + if (bch != null) + backup.stopBackup(bch); + else + fail("Can't get fullBackup chain"); + + super.tearDown(); + + File backLog = new File(bch.getLogFilePath()); + if (backLog.exists()) + { + BackupChainLog bchLog = new BackupChainLog(backLog); + + assertNotNull(bchLog.getStartedTime()); + assertNotNull(bchLog.getFinishedTime()); + + backup.restoreExistingWorkspace(bchLog.getBackupId(), false); + + // check + SessionImpl back1 = null; + try + { + back1 = (SessionImpl) repository.login(credentials, "ws1"); + Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); + assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") + .getProperty("exo:data").getString()); + } + catch (Exception e) + { + e.printStackTrace(); + fail(e.getMessage()); + } + finally + { + if (back1 != null) + back1.logout(); + } + } + else + fail("There are no backup files in " + backDir.getAbsolutePath()); + } + + public void testExistedRepositoryRestoreWithConfig() throws Exception + { + RepositoryImpl repositoryDB8 = (RepositoryImpl) repositoryService.getRepository("db8"); + + for (String wsName : repositoryDB8.getWorkspaceNames()) + { + SessionImpl sessionWS = (SessionImpl) repositoryDB8.login(credentials, wsName); + + Node wsTestRoot = sessionWS.getRootNode().addNode("backupTest"); + sessionWS.getRootNode().save(); + addContent(wsTestRoot, 1, 10, 1); + sessionWS.getRootNode().save(); + } + + SessionImpl sessionWS = (SessionImpl) repositoryDB8.login(credentials, WS_NAME); + + // backup + File backDir = new File("target/backup/db1"); + backDir.mkdirs(); + + RepositoryBackupConfig config = new RepositoryBackupConfig(); + String repoName = repositoryDB8.getName(); + config.setRepository(repoName); + config.setBackupType(BackupManager.FULL_BACKUP_ONLY); + + config.setBackupDir(backDir); + + backup.startBackup(config); + + RepositoryBackupChain bch = backup.findRepositoryBackup(repositoryDB8.getName()); + + // wait till full backup will be stopped + while (bch.getState() != RepositoryBackupChain.FINISHED) + { + Thread.yield(); + Thread.sleep(50); + } + + // stop fullBackup + backup.stopBackup(bch); + + // check + super.tearDown(); + + // restore + File backLog = new File(bch.getLogFilePath()); + if (backLog.exists()) + { + RepositoryBackupChainLog bchLog = new RepositoryBackupChainLog(backLog); + + assertNotNull(bchLog.getStartedTime()); + assertNotNull(bchLog.getFinishedTime()); + + backup.restoreExistingRepository(bchLog.getBackupId(), false); + + assertEquals(JobWorkspaceRestore.RESTORE_SUCCESSFUL, backup.getLastRepositoryRestore(repoName) + .getStateRestore()); + + // check + ManageableRepository restoredRepository = repositoryService.getRepository(repoName); + + for (String wsName : restoredRepository.getWorkspaceNames()) + { + SessionImpl back1 = null; + try + { + back1 = (SessionImpl) restoredRepository.login(credentials, wsName); + Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); + assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") + .getProperty("exo:data").getString()); + } + catch (Exception e) + { + e.printStackTrace(); + fail(e.getMessage()); + } + finally + { + if (back1 != null) + back1.logout(); + } + } + } + else + fail("There are no backup files in " + backDir.getAbsolutePath()); + } + + public void testWorkspaceRestoreWithConfig() throws Exception + { + // backup + File backDir = new File("target/backup/ws1"); + backDir.mkdirs(); + + BackupConfig config = new BackupConfig(); + config.setRepository(repository.getName()); + config.setWorkspace("ws1"); + config.setBackupType(BackupManager.FULL_BACKUP_ONLY); + + config.setBackupDir(backDir); + + backup.startBackup(config); + + BackupChain bch = backup.findBackup(repository.getName(), "ws1"); + + // wait till full backup will be stopped + while (bch.getFullBackupState() != BackupJob.FINISHED) + { + Thread.yield(); + Thread.sleep(50); + } + + // stop fullBackup + + if (bch != null) + backup.stopBackup(bch); + else + fail("Can't get fullBackup chain"); + + //TODO + super.tearDown(); + removeWorkspaceFully(repository.getName(), "ws1"); + + File backLog = new File(bch.getLogFilePath()); + if (backLog.exists()) + { + BackupChainLog bchLog = new BackupChainLog(backLog); + + assertNotNull(bchLog.getStartedTime()); + assertNotNull(bchLog.getFinishedTime()); + + backup.restoreWorkspace(bchLog.getBackupId(), false); + + // check + SessionImpl back1 = null; + try + { + back1 = (SessionImpl) repository.login(credentials, "ws1"); + Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); + assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") + .getProperty("exo:data").getString()); + } + catch (Exception e) + { + e.printStackTrace(); + fail(e.getMessage()); + } + finally + { + if (back1 != null) + back1.logout(); + } + } + else + fail("There are no backup files in " + backDir.getAbsolutePath()); + } + + public void testRepositoryRestoreWithConfig() throws Exception + { + RepositoryImpl repositoryDB8 = (RepositoryImpl) repositoryService.getRepository("db8"); + + for (String wsName : repositoryDB8.getWorkspaceNames()) + { + SessionImpl sessionWS = (SessionImpl) repositoryDB8.login(credentials, wsName); + + Node wsTestRoot = sessionWS.getRootNode().addNode("backupTest"); + sessionWS.getRootNode().save(); + addContent(wsTestRoot, 1, 10, 1); + sessionWS.getRootNode().save(); + } + + SessionImpl sessionWS = (SessionImpl) repositoryDB8.login(credentials, WS_NAME); + + // backup + File backDir = new File("target/backup"); + backDir.mkdirs(); + + RepositoryBackupConfig config = new RepositoryBackupConfig(); + String repoName = repositoryDB8.getName(); + config.setRepository(repoName); + config.setBackupType(BackupManager.FULL_BACKUP_ONLY); + + config.setBackupDir(backDir); + + backup.startBackup(config); + + RepositoryBackupChain bch = backup.findRepositoryBackup(repositoryDB8.getName()); + + // wait till full backup will be stopped + while (bch.getState() != RepositoryBackupChain.FINISHED) + { + Thread.yield(); + Thread.sleep(50); + } + + // stop fullBackup + + backup.stopBackup(bch); + + //TODO + super.tearDown(); + removeRepositoryFully(repositoryDB8.getName()); + + // restore + File backLog = new File(bch.getLogFilePath()); + if (backLog.exists()) + { + RepositoryBackupChainLog bchLog = new RepositoryBackupChainLog(backLog); + + assertNotNull(bchLog.getStartedTime()); + assertNotNull(bchLog.getFinishedTime()); + + backup.restoreRepository(bchLog.getBackupId(), false); + + assertEquals(JobWorkspaceRestore.RESTORE_SUCCESSFUL, backup.getLastRepositoryRestore(repoName) + .getStateRestore()); + + // check + ManageableRepository restoredRepository = repositoryService.getRepository(repoName); + + for (String wsName : restoredRepository.getWorkspaceNames()) + { + SessionImpl back1 = null; + try + { + back1 = (SessionImpl) restoredRepository.login(credentials, wsName); + Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); + assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") + .getProperty("exo:data").getString()); + } + catch (Exception e) + { + e.printStackTrace(); + fail(e.getMessage()); + } + finally + { + if (back1 != null) + back1.logout(); + } + } + } + else + fail("There are no backup files in " + backDir.getAbsolutePath()); + } +} Property changes on: jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/AbstractBackupUseCasesTest.java ___________________________________________________________________ Name: svn:keywords + Id Name: svn:eol-style + native Added: jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/BaseRDBMSBackupTest.java =================================================================== --- jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/BaseRDBMSBackupTest.java (rev 0) +++ jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/BaseRDBMSBackupTest.java 2010-12-08 09:35:29 UTC (rev 3617) @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2003-2010 eXo Platform SAS. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation; either version 3 + * of the License, or (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see<http://www.gnu.org/licenses/>;. + */ +package org.exoplatform.services.jcr.ext.backup; + +import org.exoplatform.container.xml.InitParams; +import org.exoplatform.container.xml.PropertiesParam; +import org.exoplatform.services.jcr.ext.backup.impl.BackupManagerImpl; + +/** + * Created by The eXo Platform SAS. + * + * <br/>Date: 2010 + * + * @author <a href="mailto:alex.reshetnyak@exoplatform.com.ua">Alex Reshetnyak</a> + * @version $Id$ + */ +public class BaseRDBMSBackupTest + extends AbstractBackupTestCase +{ + protected ExtendedBackupManager getBackupManager() + { + InitParams initParams = new InitParams(); + PropertiesParam pps = new PropertiesParam(); + pps.setProperty(BackupManagerImpl.FULL_BACKUP_TYPE, + "org.exoplatform.services.jcr.ext.backup.impl.rdbms.FullBackupJob"); + pps.setProperty(BackupManagerImpl.INCREMENTAL_BACKUP_TYPE, + "org.exoplatform.services.jcr.ext.backup.impl.fs.IncrementalBackupJob"); + pps.setProperty(BackupManagerImpl.BACKUP_DIR, "target/backup_BaseRDBMSBackupTest"); + pps.setProperty(BackupManagerImpl.DEFAULT_INCREMENTAL_JOB_PERIOD, "3600"); + + initParams.put(BackupManagerImpl.BACKUP_PROPERTIES, pps); + + BackupManagerImpl backupManagerImpl = new BackupManagerImpl(initParams, repositoryService); + backupManagerImpl.start(); + + return backupManagerImpl; + } +} Property changes on: jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/BaseRDBMSBackupTest.java ___________________________________________________________________ Name: svn:keywords + Id Name: svn:eol-style + native Modified: jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/TestBackupManager.java =================================================================== --- jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/TestBackupManager.java 2010-12-08 09:32:42 UTC (rev 3616) +++ jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/TestBackupManager.java 2010-12-08 09:35:29 UTC (rev 3617) @@ -18,25 +18,7 @@ */ package org.exoplatform.services.jcr.ext.backup; -import org.apache.commons.collections.map.HashedMap; -import org.exoplatform.services.jcr.config.RepositoryEntry; -import org.exoplatform.services.jcr.config.WorkspaceEntry; -import org.exoplatform.services.jcr.core.ManageableRepository; -import org.exoplatform.services.jcr.ext.backup.impl.JobRepositoryRestore; -import org.exoplatform.services.jcr.ext.backup.impl.JobWorkspaceRestore; -import org.exoplatform.services.jcr.impl.core.RepositoryImpl; -import org.exoplatform.services.jcr.impl.core.SessionImpl; -import java.io.ByteArrayInputStream; -import java.io.File; -import java.io.FileInputStream; -import java.io.InputStream; -import java.util.Map; - -import javax.jcr.Node; -import javax.jcr.RepositoryException; -import javax.jcr.lock.Lock; - /** * Created by The eXo Platform SAS. * Author : Peter Nedonosko peter.nedonosko(a)exoplatform.com.ua @@ -46,2196 +28,11 @@ * @version $Id: TestBackupManager.java 760 2008-02-07 15:08:07Z pnedonosko $ */ public class TestBackupManager - extends AbstractBackupTestCase + extends AbstractBackupUseCasesTest { - public void testFullBackupRestore() throws Exception + protected ExtendedBackupManager getBackupManager() { - // backup - File backDir = new File("target/backup/ws1"); - backDir.mkdirs(); - - BackupConfig config = new BackupConfig(); - config.setRepository(repository.getName()); - config.setWorkspace("ws1"); - config.setBackupType(BackupManager.FULL_BACKUP_ONLY); - - config.setBackupDir(backDir); - - backup.startBackup(config); - - BackupChain bch = backup.findBackup(repository.getName(), "ws1"); - - // wait till full backup will be stopped - while (bch.getFullBackupState() != BackupJob.FINISHED) - { - Thread.yield(); - Thread.sleep(50); - } - - // stop fullBackup - - if (bch != null) - backup.stopBackup(bch); - else - fail("Can't get fullBackup chain"); - - // restore - RepositoryEntry re = (RepositoryEntry)ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); - WorkspaceEntry ws1back = makeWorkspaceEntry("ws1back", "jdbcjcr_backup_only_use_1"); - - // BackupChainLog bchLog = new BackupChainLog(backDir, rconfig); - File backLog = new File(bch.getLogFilePath()); - if (backLog.exists()) - { - BackupChainLog bchLog = new BackupChainLog(backLog); - - assertNotNull(bchLog.getStartedTime()); - assertNotNull(bchLog.getFinishedTime()); - - backup.restore(bchLog, re.getName(), ws1back, false); - - // check - SessionImpl back1 = null; - try - { - back1 = (SessionImpl)repository.login(credentials, "ws1back"); - Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); - assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") - .getProperty("exo:data").getString()); - } - catch (Exception e) - { - e.printStackTrace(); - fail(e.getMessage()); - } - finally - { - if (back1 != null) - back1.logout(); - } - } - else - fail("There are no backup files in " + backDir.getAbsolutePath()); + return (ExtendedBackupManager) container.getComponentInstanceOfType(BackupManager.class); } - - public void testIncrementalBackupRestore() throws Exception - { - // full backup & incremental - File backDir = new File("target/backup/ws1.incr"); - backDir.mkdirs(); - - BackupConfig config = new BackupConfig(); - config.setRepository(repository.getName()); - config.setWorkspace("ws1"); - config.setBackupType(BackupManager.FULL_AND_INCREMENTAL); - - config.setBackupDir(backDir); - - backup.startBackup(config); - - BackupChain bch = backup.findBackup(repository.getName(), "ws1"); - - // wait till full backup will be stopped - while (bch.getFullBackupState() != BackupJob.FINISHED) - { - Thread.yield(); - Thread.sleep(50); - } - - // add some changes which will be logged in incremental log - ws1TestRoot.getNode("node_3").remove(); - ws1TestRoot.getNode("node_4").remove(); - ws1TestRoot.getNode("node_5").remove(); - ws1TestRoot.addNode("node #3").setProperty("exo:data", "property #3"); - ws1TestRoot.addNode("node #5").setProperty("exo:extraData", "property #5"); - - ws1TestRoot.save(); // log here via listener - - // stop all - if (bch != null) - backup.stopBackup(bch); - else - fail("Can't get fullBackup chain"); - - // restore - RepositoryEntry re = (RepositoryEntry)ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); - WorkspaceEntry ws1back = makeWorkspaceEntry("ws1back.incr", "jdbcjcr_backup_only_use_2"); - - File backLog = new File(bch.getLogFilePath()); - if (backLog.exists()) - { - BackupChainLog bchLog = new BackupChainLog(backLog); - - assertNotNull(bchLog.getStartedTime()); - assertNotNull(bchLog.getFinishedTime()); - - backup.restore(bchLog, re.getName(), ws1back, false); - - // check - SessionImpl back1 = null; - try - { - back1 = (SessionImpl)repository.login(credentials, ws1back.getName()); - Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); - assertFalse("Node should be removed", ws1backTestRoot.hasNode("node_3")); - assertFalse("Node should be removed", ws1backTestRoot.hasNode("node_4")); - assertFalse("Node should be removed", ws1backTestRoot.hasNode("node_5")); - - assertEquals("Restored content should be same", "property #3", ws1backTestRoot.getNode("node #3") - .getProperty("exo:data").getString()); - assertEquals("Restored content should be same", "property #5", ws1backTestRoot.getNode("node #5") - .getProperty("exo:extraData").getString()); - - assertFalse("Proeprty should be removed", ws1backTestRoot.getNode("node #5").hasProperty("exo:data")); - } - catch (Exception e) - { - e.printStackTrace(); - fail(e.getMessage()); - } - finally - { - if (back1 != null) - back1.logout(); - } - } - else - fail("There are no backup files in " + backDir.getAbsolutePath()); - } - - /** - * With BLOBs, locks, copy and move - * - * @throws Exception - */ - - public void testIncrementalBackupRestore2() throws Exception - { - // full backup with BLOBs & incremental with BLOBs - - // BLOBs for full - File tempf = createBLOBTempFile("testIncrementalBackupRestore2-", 5 * 1024); // 5M - tempf.deleteOnExit(); - ws1TestRoot.addNode("node_101").setProperty("exo:data", new FileInputStream(tempf)); - ws1TestRoot.addNode("node_102").setProperty("exo:extraData", new FileInputStream(tempf)); - - File backDir = new File("target/backup/ws1.incr2"); - backDir.mkdirs(); - - BackupConfig config = new BackupConfig(); - config.setRepository(repository.getName()); - config.setWorkspace("ws1"); - config.setBackupType(BackupManager.FULL_AND_INCREMENTAL); - - config.setBackupDir(backDir); - - backup.startBackup(config); - - BackupChain bch = backup.findBackup(repository.getName(), "ws1"); - - // wait till full backup will be stopped - while (bch.getFullBackupState() != BackupJob.FINISHED) - { - Thread.yield(); - Thread.sleep(50); - } - - // add some changes which will be logged in incremental log - ws1TestRoot.addNode("node #53").setProperty("exo:extraData", "property #53"); - ws1TestRoot.save(); // log here via listener - - // BLOBs for incr - ws1TestRoot.getNode("node_1").setProperty("exo:extraData", new FileInputStream(tempf)); - ws1TestRoot.getNode("node_5").setProperty("exo:data", new FileInputStream(tempf)); - - ws1TestRoot.addNode("node_101").setProperty("exo:data", new FileInputStream(tempf)); - ws1TestRoot.addNode("node_102").setProperty("exo:data", new FileInputStream(tempf)); - ws1TestRoot.save(); // log here via listener - - ws1TestRoot.getNode("node_2").setProperty("exo:data", (InputStream)null); // remove property - ws1TestRoot.getNode("node_3").setProperty("exo:data", new ByteArrayInputStream("aaa".getBytes())); // set - // aaa - // bytes - ws1TestRoot.getNode("node_4").remove(); // (*) - ws1TestRoot.save(); // log here via listener - - ws1TestRoot.getNode("node_5").addMixin("mix:lockable"); - ws1TestRoot.save(); // log here via listener - Lock n107lock = ws1TestRoot.getNode("node_5").lock(true, false); - ws1TestRoot.getSession().move(ws1TestRoot.getNode("node #53").getPath(), - ws1TestRoot.getNode("node_5").getPath() + "/node #53"); - ws1TestRoot.save(); // log here via listener - - ws1TestRoot.getNode("node_6").addMixin("mix:referenceable"); - String id6 = ws1TestRoot.getNode("node_6").getUUID(); - ws1TestRoot.save(); // log here via listener - - // before(*), log here via listener - ws1TestRoot.getSession().getWorkspace() - .move(ws1TestRoot.getNode("node_6").getPath(), ws1TestRoot.getPath() + "/node_4"); // in place of - // 4 removed - - // stop all - if (bch != null) - backup.stopBackup(bch); - else - fail("Can't get fullBackup chain"); - - // restore - RepositoryEntry re = (RepositoryEntry)ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); - WorkspaceEntry ws1back = makeWorkspaceEntry("ws1back.incr2", "jdbcjcr_backup_only_use_3"); - - File backLog = new File(bch.getLogFilePath()); - if (backLog.exists()) - { - BackupChainLog bchLog = new BackupChainLog(backLog); - - assertNotNull(bchLog.getStartedTime()); - assertNotNull(bchLog.getFinishedTime()); - - backup.restore(bchLog, re.getName(), ws1back, false); - - // check - SessionImpl back1 = null; - try - { - back1 = (SessionImpl)repository.login(credentials, ws1back.getName()); - Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); - - assertTrue("Node should exists", ws1backTestRoot.getNode("node_5").hasNode("node #53")); - assertTrue("Property should exists", ws1backTestRoot.getNode("node_5") - .hasProperty("node #53/exo:extraData")); - - assertTrue("Node should exists", ws1backTestRoot.hasNode("node_7")); - assertTrue("Property should exists", ws1backTestRoot.hasProperty("node_5/exo:data")); - assertTrue("Property should exists", ws1backTestRoot.hasProperty("node_1/exo:extraData")); - assertTrue("Node should exists", ws1backTestRoot.hasNode("node_102")); - - compareStream(new FileInputStream(tempf), ws1backTestRoot.getNode("node_5").getProperty("exo:data") - .getStream()); - compareStream(new FileInputStream(tempf), ws1backTestRoot.getNode("node_1").getProperty("exo:extraData") - .getStream()); - - assertFalse("Property should be removed", ws1backTestRoot.getNode("node_2").hasProperty("exo:data")); - - compareStream(new ByteArrayInputStream("aaa".getBytes()), - ws1backTestRoot.getNode("node_3").getProperty("exo:data").getStream()); - - assertTrue("Node should be mix:lockable ", ws1backTestRoot.getNode("node_5").isNodeType("mix:lockable")); - assertFalse("Node should be not locked ", ws1backTestRoot.getNode("node_5").isLocked()); - - assertEquals("Node should be mix:referenceable and UUID should be " + id6, id6, - ws1backTestRoot.getNode("node_4").getUUID()); - } - catch (Exception e) - { - e.printStackTrace(); - fail(e.getMessage()); - } - finally - { - if (back1 != null) - back1.logout(); - } - } - else - fail("There are no backup files in " + backDir.getAbsolutePath()); - } - - public void testFullBackupRestoreAsync() throws Exception - { - SessionImpl sessionWS1 = (SessionImpl)repository.login(credentials, "ws1"); - sessionWS1.getRootNode().addNode("backupTest").addNode("node_5") - .setProperty("exo:data", "Restored content should be same"); - sessionWS1.save(); - - // backup - File backDir = new File("target/backup/ws1_a"); - backDir.mkdirs(); - - BackupConfig config = new BackupConfig(); - config.setRepository(repository.getName()); - config.setWorkspace("ws1"); - config.setBackupType(BackupManager.FULL_BACKUP_ONLY); - - config.setBackupDir(backDir); - - backup.startBackup(config); - - BackupChain bch = backup.findBackup(repository.getName(), "ws1"); - - // wait till full backup will be stopped - while (bch.getFullBackupState() != BackupJob.FINISHED) - { - Thread.yield(); - Thread.sleep(50); - } - - // stop fullBackup - - if (bch != null) - backup.stopBackup(bch); - else - fail("Can't get fullBackup chain"); - - // restore - WorkspaceEntry ws1back = makeWorkspaceEntry("ws1back5", "jdbcjcr_backup_only_use_5"); - - File backLog = new File(bch.getLogFilePath()); - if (backLog.exists()) - { - BackupChainLog bchLog = new BackupChainLog(backLog); - - assertNotNull(bchLog.getStartedTime()); - assertNotNull(bchLog.getFinishedTime()); - - backup.restore(bchLog, repository.getName(), ws1back, true); - - while (backup.getLastRestore(repository.getName(), ws1back.getName()).getStateRestore() != JobWorkspaceRestore.RESTORE_SUCCESSFUL - && backup.getLastRestore(repository.getName(), ws1back.getName()).getStateRestore() != JobWorkspaceRestore.RESTORE_FAIL) - { - Thread.sleep(50); - } - - if (backup.getLastRestore(repository.getName(), ws1back.getName()).getStateRestore() == JobWorkspaceRestore.RESTORE_FAIL) - throw (Exception)backup.getLastRestore(repository.getName(), ws1back.getName()).getRestoreException(); - - // check - SessionImpl back1 = null; - try - { - back1 = (SessionImpl)repository.login(credentials, "ws1back5"); - Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); - assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") - .getProperty("exo:data").getString()); - } - catch (Exception e) - { - e.printStackTrace(); - fail(e.getMessage()); - } - finally - { - if (back1 != null) - back1.logout(); - } - } - else - fail("There are no backup files in " + backDir.getAbsolutePath()); - } - - public void testAutoStopBackupFull() throws Exception - { - // backup - File backDir = new File("target/backup/ws1_123"); - backDir.mkdirs(); - - BackupConfig config = new BackupConfig(); - config.setRepository(repository.getName()); - config.setWorkspace("ws1"); - config.setBackupType(BackupManager.FULL_BACKUP_ONLY); - - config.setBackupDir(backDir); - - BackupChain bch = backup.startBackup(config); - - Thread.sleep(11000); - - for (BackupChain chain : backup.getCurrentBackups()) - if (bch.getBackupId().equals(chain.getBackupId())) - fail("The backup with id '" + chain.getBackupId() + "' should not be active"); - } - - public void testAutoStopBackupIncr() throws Exception - { - // backup - File backDir = new File("target/backup/ws1_123_321"); - backDir.mkdirs(); - - BackupConfig config = new BackupConfig(); - config.setRepository(repository.getName()); - config.setWorkspace("ws1"); - config.setBackupType(BackupManager.FULL_AND_INCREMENTAL); - config.setBackupDir(backDir); - config.setIncrementalJobPeriod(3); - config.setIncrementalJobNumber(0); - - BackupChain bch = backup.startBackup(config); - - Thread.sleep(11000); - - boolean isFail = true; - - for (BackupChain chain : backup.getCurrentBackups()) - if (bch.getBackupId().equals(chain.getBackupId())) - isFail = false; - - if (isFail) - fail("The backup with id '" + bch.getBackupId() + "' should be active"); - } - - public void testAutoStopBackupIncrRepetion() throws Exception - { - // backup - File backDir = new File("target/backup/ws1_123321"); - backDir.mkdirs(); - - BackupConfig config = new BackupConfig(); - config.setRepository(repository.getName()); - config.setWorkspace("ws1"); - config.setBackupType(BackupManager.FULL_AND_INCREMENTAL); - config.setBackupDir(backDir); - config.setIncrementalJobPeriod(4); - config.setIncrementalJobNumber(2); - - final BackupChain bch = backup.startBackup(config); - - Thread.sleep(40000); - - assertTrue(bch.isFinished()); - - for (BackupChain chain : backup.getCurrentBackups()) - if (bch.getBackupId().equals(chain.getBackupId())) - fail("The backup with id '" + chain.getBackupId() + "' should not be active"); - } - - public void testTwoRestores() throws Exception - { - { - SessionImpl sessionWS1 = (SessionImpl)repository.login(credentials, "ws3"); - - sessionWS1.getRootNode().addNode("asdasdasda", "nt:unstructured") - .setProperty("data", new FileInputStream(createBLOBTempFile(1024))); - sessionWS1.save(); - - // 1-st backup - File backDir = new File("target/backup/ws1_restore_1"); - backDir.mkdirs(); - - BackupConfig config = new BackupConfig(); - config.setRepository(repository.getName()); - config.setWorkspace("ws3"); - config.setBackupType(BackupManager.FULL_BACKUP_ONLY); - config.setBackupDir(backDir); - - BackupChain bch = backup.startBackup(config); - - // wait till full backup will be stopped - while (!bch.isFinished()) - { - Thread.yield(); - Thread.sleep(50); - } - - // 1-st restore - WorkspaceEntry ws1_restore_1 = makeWorkspaceEntry("ws1_restore_1", "jdbcjcr_backup_only_use_6"); - - File backLog = new File(bch.getLogFilePath()); - if (backLog.exists()) - { - BackupChainLog bchLog = new BackupChainLog(backLog); - - backup.restore(bchLog, repository.getName(), ws1_restore_1, false); - - // check - SessionImpl back1 = (SessionImpl)repository.login(credentials, "ws1_restore_1"); - assertNotNull(back1.getRootNode().getNode("asdasdasda").getProperty("data")); - - // add date to restored workspace - back1.getRootNode().addNode("gdfgrghfhf", "nt:unstructured") - .setProperty("data", new FileInputStream(createBLOBTempFile(1024))); - back1.save(); - } - else - fail("There are no backup files in " + backDir.getAbsolutePath()); - } - - { - // 2-st backup - File backDir = new File("target/backup/ws1_restore_2"); - backDir.mkdirs(); - - BackupConfig config = new BackupConfig(); - config.setRepository(repository.getName()); - config.setWorkspace("ws1_restore_1"); - config.setBackupType(BackupManager.FULL_BACKUP_ONLY); - config.setBackupDir(backDir); - - BackupChain bch = backup.startBackup(config); - - // wait till full backup will be stopped - while (!bch.isFinished()) - { - Thread.yield(); - Thread.sleep(50); - } - - // 2-st restore - WorkspaceEntry ws1_restore_2 = makeWorkspaceEntry("ws1_restore_2", "jdbcjcr_backup_only_use_7"); - - File backLog = new File(bch.getLogFilePath()); - if (backLog.exists()) - { - BackupChainLog bchLog = new BackupChainLog(backLog); - - backup.restore(bchLog, repository.getName(), ws1_restore_2, false); - - // check - SessionImpl back2 = (SessionImpl)repository.login(credentials, "ws1_restore_2"); - assertNotNull(back2.getRootNode().getNode("gdfgrghfhf").getProperty("data")); - } - else - fail("There are no backup files in " + backDir.getAbsolutePath()); - } - } - - public void testStartFullBackupWIthJobPeriod() throws Exception - { - // backup - File backDir = new File("target/backup/ws1_fwp"); - backDir.mkdirs(); - - BackupConfig config = new BackupConfig(); - config.setRepository(repository.getName()); - config.setWorkspace("ws1"); - config.setBackupType(BackupManager.FULL_BACKUP_ONLY); - config.setBackupDir(backDir); - config.setIncrementalJobPeriod(3600); - - backup.startBackup(config); - - BackupChain bch = backup.findBackup(repository.getName(), "ws1"); - - // wait till full backup will be stopped - while (bch.getFullBackupState() != BackupJob.FINISHED) - { - Thread.yield(); - Thread.sleep(50); - } - } - - public void testNegativeIncremetalJobPeriod() throws Exception - { - // backup - File backDir = new File("target/backup/ws1_negative_period"); - backDir.mkdirs(); - - BackupConfig config = new BackupConfig(); - config.setRepository(repository.getName()); - config.setWorkspace("ws1"); - config.setBackupType(BackupManager.FULL_AND_INCREMENTAL); - config.setIncrementalJobPeriod(-1000); - - config.setBackupDir(backDir); - - try - { - backup.startBackup(config); - fail("The backup can not be started."); - } - catch (BackupConfigurationException e) - { - //ok - } - } - - public void testNegativeIncremetalJobNumber() throws Exception - { - // backup - File backDir = new File("target/backup/ws1_negative_job_number"); - backDir.mkdirs(); - - BackupConfig config = new BackupConfig(); - config.setRepository(repository.getName()); - config.setWorkspace("ws1"); - config.setBackupType(BackupManager.FULL_AND_INCREMENTAL); - config.setIncrementalJobNumber(-5); - - config.setBackupDir(backDir); - - try - { - backup.startBackup(config); - fail("The backup can not be started."); - } - catch (BackupConfigurationException e) - { - //ok - } - } - - public void testRestoreAfterFAilureRestore() throws Exception - { - // backup - File backDir = new File("target/backup/ws1"); - backDir.mkdirs(); - - BackupConfig config = new BackupConfig(); - config.setRepository(repository.getName()); - config.setWorkspace("ws1"); - config.setBackupType(BackupManager.FULL_BACKUP_ONLY); - - config.setBackupDir(backDir); - - backup.startBackup(config); - - BackupChain bch = backup.findBackup(repository.getName(), "ws1"); - - // wait till full backup will be stopped - while (bch.getFullBackupState() != BackupJob.FINISHED) - { - Thread.yield(); - Thread.sleep(50); - } - - // stop fullBackup - - if (bch != null) - backup.stopBackup(bch); - else - fail("Can't get fullBackup chain"); - - // restore - RepositoryEntry re = (RepositoryEntry)ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); - WorkspaceEntry ws1back = makeWorkspaceEntry("ws1backt", "jdbcjcr_backup_only_use_8_NOT_EXIST"); - - File backLog = new File(bch.getLogFilePath()); - if (backLog.exists()) - { - BackupChainLog bchLog = new BackupChainLog(backLog); - - try - { - backup.restore(bchLog, re.getName(), ws1back, false); - fail("The backup can not be restored."); - } - catch (Exception e) - { - //ok - - WorkspaceEntry ws1backTwo = makeWorkspaceEntry("ws1backt", "jdbcjcr_backup_only_use_8"); - - backup.restore(bchLog, re.getName(), ws1backTwo, false); - } - - // check - SessionImpl back1 = null; - try - { - back1 = (SessionImpl)repository.login(credentials, "ws1back"); - Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); - assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") - .getProperty("exo:data").getString()); - } - catch (Exception e) - { - e.printStackTrace(); - fail(e.getMessage()); - } - finally - { - if (back1 != null) - back1.logout(); - } - } - else - fail("There are no backup files in " + backDir.getAbsolutePath()); - } - - public void testRepositoryFullBackupRestore() throws Exception - { - // backup - File backDir = new File("target/backup"); - backDir.mkdirs(); - - RepositoryBackupConfig config = new RepositoryBackupConfig(); - config.setRepository(repository.getName()); - config.setBackupType(BackupManager.FULL_BACKUP_ONLY); - - config.setBackupDir(backDir); - - backup.startBackup(config); - - RepositoryBackupChain bch = backup.findRepositoryBackup(repository.getName()); - - // wait till full backup will be stopped - while (bch.getState() != RepositoryBackupChain.FINISHED) - { - Thread.yield(); - Thread.sleep(50); - } - - // stop fullBackup - - backup.stopBackup(bch); - - // restore - RepositoryEntry re = (RepositoryEntry)ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); - - String newRepositoryName = "repo_restored_1"; - RepositoryEntry newRepositoryEntry = - makeRepositoryEntry(newRepositoryName, re, "jdbcjcr_to_repository_restore_1", null); - - File backLog = new File(bch.getLogFilePath()); - if (backLog.exists()) - { - RepositoryBackupChainLog bchLog = new RepositoryBackupChainLog(backLog); - - assertNotNull(bchLog.getStartedTime()); - assertNotNull(bchLog.getFinishedTime()); - - backup.restore(bchLog, newRepositoryEntry, false); - assertEquals(JobWorkspaceRestore.RESTORE_SUCCESSFUL, - backup.getLastRepositoryRestore(newRepositoryEntry.getName()).getStateRestore()); - - // check - ManageableRepository restoredRepository = repositoryService.getRepository(newRepositoryName); - - for (String wsName : restoredRepository.getWorkspaceNames()) - { - SessionImpl back1 = null; - try - { - back1 = (SessionImpl)restoredRepository.login(credentials, wsName); - Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); - assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") - .getProperty("exo:data").getString()); - } - catch (Exception e) - { - e.printStackTrace(); - fail(e.getMessage()); - } - finally - { - if (back1 != null) - back1.logout(); - } - } - } - else - fail("There are no backup files in " + backDir.getAbsolutePath()); - } - - public void testRepositoryFullAndIncrementalBackupRestore() throws Exception - { - // backup - File backDir = new File("target/backup"); - backDir.mkdirs(); - - RepositoryBackupConfig config = new RepositoryBackupConfig(); - config.setRepository(repository.getName()); - config.setBackupType(BackupManager.FULL_AND_INCREMENTAL); - config.setIncrementalJobPeriod(1000); - - config.setBackupDir(backDir); - - backup.startBackup(config); - - RepositoryBackupChain bch = backup.findRepositoryBackup(repository.getName()); - - // wait till full backup will be stopped - while (bch.getState() != RepositoryBackupChain.FULL_BACKUP_FINISHED_INCREMENTAL_BACKUP_WORKING) - { - Thread.yield(); - Thread.sleep(50); - } - - // stop fullBackup - - backup.stopBackup(bch); - - // restore - RepositoryEntry re = (RepositoryEntry)ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); - - String newRepositoryName = "repo_restored_4"; - RepositoryEntry newRepositoryEntry = - makeRepositoryEntry(newRepositoryName, re, "jdbcjcr_to_repository_restore_4", null); - - File backLog = new File(bch.getLogFilePath()); - if (backLog.exists()) - { - RepositoryBackupChainLog bchLog = new RepositoryBackupChainLog(backLog); - - assertNotNull(bchLog.getStartedTime()); - assertNotNull(bchLog.getFinishedTime()); - - backup.restore(bchLog, newRepositoryEntry, false); - - // check - ManageableRepository restoredRepository = repositoryService.getRepository(newRepositoryName); - - for (String wsName : restoredRepository.getWorkspaceNames()) - { - SessionImpl back1 = null; - try - { - back1 = (SessionImpl)repository.login(credentials, wsName); - Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); - assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") - .getProperty("exo:data").getString()); - } - catch (Exception e) - { - e.printStackTrace(); - fail(e.getMessage()); - } - finally - { - if (back1 != null) - back1.logout(); - } - } - } - else - fail("There are no backup files in " + backDir.getAbsolutePath()); - } - - public void testRepositoryFullBackupAsynchronusRestore() throws Exception - { - // backup - File backDir = new File("target/backup"); - backDir.mkdirs(); - - RepositoryBackupConfig config = new RepositoryBackupConfig(); - config.setRepository(repository.getName()); - config.setBackupType(BackupManager.FULL_BACKUP_ONLY); - - config.setBackupDir(backDir); - - backup.startBackup(config); - - RepositoryBackupChain bch = backup.findRepositoryBackup(repository.getName()); - - // wait till full backup will be stopped - while (bch.getState() != RepositoryBackupChain.FINISHED) - { - Thread.yield(); - Thread.sleep(50); - } - - // stop fullBackup - - backup.stopBackup(bch); - - // restore - RepositoryEntry re = (RepositoryEntry)ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); - - String newRepositoryName = "repo_restored_2"; - RepositoryEntry newRepositoryEntry = - makeRepositoryEntry(newRepositoryName, re, "jdbcjcr_to_repository_restore_2", null); - - File backLog = new File(bch.getLogFilePath()); - if (backLog.exists()) - { - RepositoryBackupChainLog bchLog = new RepositoryBackupChainLog(backLog); - - assertNotNull(bchLog.getStartedTime()); - assertNotNull(bchLog.getFinishedTime()); - - backup.restore(bchLog, newRepositoryEntry, true); - - JobRepositoryRestore job = backup.getLastRepositoryRestore(newRepositoryName); - - while (job.getStateRestore() != JobRepositoryRestore.REPOSITORY_RESTORE_SUCCESSFUL - || job.getStateRestore() == JobRepositoryRestore.REPOSITORY_RESTORE_FAIL) - { - Thread.yield(); - Thread.sleep(50); - } - - // check - ManageableRepository restoredRepository = repositoryService.getRepository(newRepositoryName); - - for (String wsName : restoredRepository.getWorkspaceNames()) - { - SessionImpl back1 = null; - try - { - back1 = (SessionImpl)restoredRepository.login(credentials, wsName); - Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); - assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") - .getProperty("exo:data").getString()); - } - catch (Exception e) - { - e.printStackTrace(); - fail(e.getMessage()); - } - finally - { - if (back1 != null) - back1.logout(); - } - } - } - else - fail("There are no backup files in " + backDir.getAbsolutePath()); - } - - public void testRepositoryFullBackupAsynchronusRestoreWorkspaceMapping() throws Exception - { - // backup - File backDir = new File("target/backup"); - backDir.mkdirs(); - - RepositoryBackupConfig config = new RepositoryBackupConfig(); - config.setRepository(repository.getName()); - config.setBackupType(BackupManager.FULL_BACKUP_ONLY); - - config.setBackupDir(backDir); - - backup.startBackup(config); - - RepositoryBackupChain bch = backup.findRepositoryBackup(repository.getName()); - - // wait till full backup will be stopped - while (bch.getState() != RepositoryBackupChain.FINISHED) - { - Thread.yield(); - Thread.sleep(50); - } - - // stop fullBackup - - backup.stopBackup(bch); - - // restore - RepositoryEntry re = (RepositoryEntry)ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); - - String newRepositoryName = "repo_restored_3"; - RepositoryEntry newRepositoryEntry = - makeRepositoryEntry(newRepositoryName, re, "jdbcjcr_to_repository_restore_3", null); - - // create workspace mappingS - Map<String, String> workspaceMapping = new HashedMap(); - for (WorkspaceEntry we : newRepositoryEntry.getWorkspaceEntries()) - { - workspaceMapping.put(we.getName(), we.getName() + "_mapped"); - } - - // Change workspaeNames - for (WorkspaceEntry we : newRepositoryEntry.getWorkspaceEntries()) - { - if (newRepositoryEntry.getSystemWorkspaceName().equals(we.getName())) - { - newRepositoryEntry.setSystemWorkspaceName(workspaceMapping.get(we.getName())); - newRepositoryEntry.setDefaultWorkspaceName(workspaceMapping.get(we.getName())); - } - - we.setName(workspaceMapping.get(we.getName())); - we.setUniqueName(we.getUniqueName() + workspaceMapping.get(we.getName())); - } - - File backLog = new File(bch.getLogFilePath()); - if (backLog.exists()) - { - RepositoryBackupChainLog bchLog = new RepositoryBackupChainLog(backLog); - - assertNotNull(bchLog.getStartedTime()); - assertNotNull(bchLog.getFinishedTime()); - - backup.restore(bchLog, newRepositoryEntry, workspaceMapping, true); - - JobRepositoryRestore job = backup.getLastRepositoryRestore(newRepositoryName); - - while (job.getStateRestore() != JobRepositoryRestore.REPOSITORY_RESTORE_SUCCESSFUL - || job.getStateRestore() == JobRepositoryRestore.REPOSITORY_RESTORE_FAIL) - { - Thread.yield(); - Thread.sleep(50); - } - - // check - ManageableRepository restoredRepository = repositoryService.getRepository(newRepositoryName); - - for (String wsName : restoredRepository.getWorkspaceNames()) - { - SessionImpl back1 = null; - try - { - back1 = (SessionImpl)restoredRepository.login(credentials, workspaceMapping.get(wsName)); - Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); - assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") - .getProperty("exo:data").getString()); - } - catch (Exception e) - { - e.printStackTrace(); - fail(e.getMessage()); - } - finally - { - if (back1 != null) - back1.logout(); - } - } - } - else - fail("There are no backup files in " + backDir.getAbsolutePath()); - } - - public void testAutoStopRepositoryBackupIncrRepetion() throws Exception - { - // backup - File backDir = new File("target/backup/" + repository.getName() + "_" + System.currentTimeMillis()); - backDir.mkdirs(); - - RepositoryBackupConfig config = new RepositoryBackupConfig(); - config.setRepository(repository.getName()); - config.setBackupType(BackupManager.FULL_AND_INCREMENTAL); - config.setBackupDir(backDir); - config.setIncrementalJobPeriod(4); - config.setIncrementalJobNumber(2); - - final RepositoryBackupChain bch = backup.startBackup(config); - - Thread.sleep(40000); - - assertTrue(bch.isFinished()); - - for (RepositoryBackupChain chain : backup.getCurrentRepositoryBackups()) - if (bch.getBackupId().equals(chain.getBackupId())) - fail("The backup with id '" + chain.getBackupId() + "' should not be active"); - } - - public void testRepositoryRestoreFail() throws Exception - { - // restore - RepositoryEntry re = (RepositoryEntry)ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); - - String newRepositoryName = "repo_restored_5"; - RepositoryEntry newRepositoryEntry = - makeRepositoryEntry(newRepositoryName, re, "jdbcjcr_to_repository_restore_5", null); - - //create broken system workspaceEntry - newRepositoryEntry.getWorkspaceEntries().get(0).getQueryHandler().setType("gg"); - - File backLog = new File(backup.getRepositoryBackupsLogs()[0].getLogFilePath()); - - RepositoryBackupChainLog bchLog = new RepositoryBackupChainLog(backLog); - - try - { - backup.restore(bchLog, newRepositoryEntry, false); - fail("The backup " + backLog.getAbsolutePath() + "shoulde not restored."); - } - catch (RepositoryRestoreExeption e) - { - // ok. - } - - // check - - try - { - ManageableRepository restoredRepository = repositoryService.getRepository(newRepositoryName); - fail("The repository " + newRepositoryName + "shoulde not exists."); - } - catch (RepositoryException e) - { - // ok. - } - } - - public void testIncrementalBackupRestoreEXOJCR_737() throws Exception - { - // full backup with BLOBs & incremental with BLOBs - - // BLOBs for full - File tempf = createBLOBTempFile("testIncrementalBackupRestore737-", 5 * 1024); // 5M - tempf.deleteOnExit(); - - File backDir = new File("target/backup/ws1.incr737"); - backDir.mkdirs(); - - BackupConfig config = new BackupConfig(); - config.setRepository(repository.getName()); - config.setWorkspace("ws1"); - config.setBackupType(BackupManager.FULL_AND_INCREMENTAL); - - config.setBackupDir(backDir); - - backup.startBackup(config); - - BackupChain bch = backup.findBackup(repository.getName(), "ws1"); - - // wait till full backup will be stopped - while (bch.getFullBackupState() != BackupJob.FINISHED) - { - Thread.yield(); - Thread.sleep(50); - } - - // add data - ws1Session.getRootNode().addNode("node_101").setProperty("exo:data", new FileInputStream(tempf)); - ws1Session.getRootNode().addNode("node_102").setProperty("exo:extraData", new FileInputStream(tempf)); - ws1Session.getRootNode().save(); // log here via listener - - // stop backup - if (bch != null) - backup.stopBackup(bch); - else - fail("Can't get fullBackup chain"); - - //remove data - ws1Session.getRootNode().getNode("node_101").remove(); - ws1Session.getRootNode().getNode("node_102").remove(); - ws1Session.getRootNode().save(); - - // restore - RepositoryEntry re = (RepositoryEntry)ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); - WorkspaceEntry ws1back = makeWorkspaceEntry("ws1back.incr737", "jdbcjcr25"); - - File backLog = new File(bch.getLogFilePath()); - if (backLog.exists()) - { - BackupChainLog bchLog = new BackupChainLog(backLog); - - assertNotNull(bchLog.getStartedTime()); - assertNotNull(bchLog.getFinishedTime()); - - backup.restore(bchLog, re.getName(), ws1back, false); - - // check - SessionImpl back1 = null; - try - { - back1 = (SessionImpl)repository.login(credentials, ws1back.getName()); - - Node node_101 = back1.getRootNode().getNode("node_101"); - assertNotNull(node_101); - assertEquals(tempf.length(), node_101.getProperty("exo:data").getStream().available()); - compareStream(new FileInputStream(tempf), node_101.getProperty("exo:data").getStream()); - - Node node_102 = back1.getRootNode().getNode("node_102"); - assertNotNull(node_102); - assertEquals(tempf.length(), node_102.getProperty("exo:extraData").getStream().available()); - compareStream(new FileInputStream(tempf), node_102.getProperty("exo:extraData").getStream()); - - } - catch (Exception e) - { - e.printStackTrace(); - fail(e.getMessage()); - } - finally - { - if (back1 != null) - back1.logout(); - } - } - else - fail("There are no backup files in " + backDir.getAbsolutePath()); - } - - public void testExistedWorkspaceRestore() throws Exception - { - // backup - File backDir = new File("target/backup/ws1"); - backDir.mkdirs(); - - BackupConfig config = new BackupConfig(); - config.setRepository(repository.getName()); - config.setWorkspace("ws1"); - config.setBackupType(BackupManager.FULL_BACKUP_ONLY); - - config.setBackupDir(backDir); - - backup.startBackup(config); - - BackupChain bch = backup.findBackup(repository.getName(), "ws1"); - - // wait till full backup will be stopped - while (bch.getFullBackupState() != BackupJob.FINISHED) - { - Thread.yield(); - Thread.sleep(50); - } - - // stop fullBackup - - if (bch != null) - backup.stopBackup(bch); - else - fail("Can't get fullBackup chain"); - - // restore - RepositoryEntry re = (RepositoryEntry)ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); - WorkspaceEntry ws1 = null; - for (WorkspaceEntry we : re.getWorkspaceEntries()) - { - if (ws1Session.getWorkspace().getName().equals(we.getName())) - { - ws1 = we; - break; - } - } - - File backLog = new File(bch.getLogFilePath()); - if (backLog.exists()) - { - BackupChainLog bchLog = new BackupChainLog(backLog); - - assertNotNull(bchLog.getStartedTime()); - assertNotNull(bchLog.getFinishedTime()); - - backup.restoreExistingWorkspace(bchLog, re.getName(), ws1, false); - - // check - SessionImpl back1 = null; - try - { - back1 = (SessionImpl)repository.login(credentials, "ws1"); - Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); - assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") - .getProperty("exo:data").getString()); - } - catch (Exception e) - { - e.printStackTrace(); - fail(e.getMessage()); - } - finally - { - if (back1 != null) - back1.logout(); - } - } - else - fail("There are no backup files in " + backDir.getAbsolutePath()); - } - - public void testExistedWorkspaceRestoreAsync() throws Exception - { - // backup - File backDir = new File("target/backup/ws1"); - backDir.mkdirs(); - - BackupConfig config = new BackupConfig(); - config.setRepository(repository.getName()); - config.setWorkspace("ws1"); - config.setBackupType(BackupManager.FULL_BACKUP_ONLY); - - config.setBackupDir(backDir); - - backup.startBackup(config); - - BackupChain bch = backup.findBackup(repository.getName(), "ws1"); - - // wait till full backup will be stopped - while (bch.getFullBackupState() != BackupJob.FINISHED) - { - Thread.yield(); - Thread.sleep(50); - } - - // stop fullBackup - - if (bch != null) - backup.stopBackup(bch); - else - fail("Can't get fullBackup chain"); - - // restore - RepositoryEntry re = (RepositoryEntry)ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); - WorkspaceEntry ws1 = null; - for (WorkspaceEntry we : re.getWorkspaceEntries()) - { - if (ws1Session.getWorkspace().getName().equals(we.getName())) - { - ws1 = we; - break; - } - } - - File backLog = new File(bch.getLogFilePath()); - if (backLog.exists()) - { - BackupChainLog bchLog = new BackupChainLog(backLog); - - assertNotNull(bchLog.getStartedTime()); - assertNotNull(bchLog.getFinishedTime()); - - backup.restoreExistingWorkspace(bchLog, re.getName(), ws1, true); - - while (backup.getLastRestore(repository.getName(), ws1.getName()).getStateRestore() != JobWorkspaceRestore.RESTORE_SUCCESSFUL - && backup.getLastRestore(repository.getName(), ws1.getName()).getStateRestore() != JobWorkspaceRestore.RESTORE_FAIL) - { - Thread.sleep(50); - } - - // check - SessionImpl back1 = null; - try - { - back1 = (SessionImpl)repository.login(credentials, "ws1"); - Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); - assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") - .getProperty("exo:data").getString()); - } - catch (Exception e) - { - e.printStackTrace(); - fail(e.getMessage()); - } - finally - { - if (back1 != null) - back1.logout(); - } - } - else - fail("There are no backup files in " + backDir.getAbsolutePath()); - } - - public void testExistedWorkspaceRestoreAsync2() throws Exception - { - // backup - File backDir = new File("target/backup/ws1"); - backDir.mkdirs(); - - BackupConfig config = new BackupConfig(); - config.setRepository(repository.getName()); - config.setWorkspace("ws1"); - config.setBackupType(BackupManager.FULL_BACKUP_ONLY); - - config.setBackupDir(backDir); - - backup.startBackup(config); - - BackupChain bch = backup.findBackup(repository.getName(), "ws1"); - - // wait till full backup will be stopped - while (bch.getFullBackupState() != BackupJob.FINISHED) - { - Thread.yield(); - Thread.sleep(50); - } - - // stop fullBackup - - if (bch != null) - backup.stopBackup(bch); - else - fail("Can't get fullBackup chain"); - - // restore - RepositoryEntry re = (RepositoryEntry)ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); - WorkspaceEntry ws1 = null; - for (WorkspaceEntry we : re.getWorkspaceEntries()) - { - if (ws1Session.getWorkspace().getName().equals(we.getName())) - { - ws1 = we; - break; - } - } - - File backLog = new File(bch.getLogFilePath()); - if (backLog.exists()) - { - BackupChainLog bchLog = new BackupChainLog(backLog); - - assertNotNull(bchLog.getStartedTime()); - assertNotNull(bchLog.getFinishedTime()); - - backup.restoreExistingWorkspace(bchLog.getBackupId(), re.getName(), ws1, true); - - while (backup.getLastRestore(repository.getName(), ws1.getName()).getStateRestore() != JobWorkspaceRestore.RESTORE_SUCCESSFUL - && backup.getLastRestore(repository.getName(), ws1.getName()).getStateRestore() != JobWorkspaceRestore.RESTORE_FAIL) - { - Thread.sleep(50); - } - - // check - SessionImpl back1 = null; - try - { - back1 = (SessionImpl)repository.login(credentials, "ws1"); - Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); - assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") - .getProperty("exo:data").getString()); - } - catch (Exception e) - { - e.printStackTrace(); - fail(e.getMessage()); - } - finally - { - if (back1 != null) - back1.logout(); - } - } - else - fail("There are no backup files in " + backDir.getAbsolutePath()); - } - - public void testExistedRepositoryRestore() throws Exception - { - RepositoryImpl repositoryDB8 = (RepositoryImpl)repositoryService.getRepository("db8"); - - for (String wsName : repositoryDB8.getWorkspaceNames()) - { - SessionImpl sessionWS = (SessionImpl)repositoryDB8.login(credentials, wsName); - - Node wsTestRoot = sessionWS.getRootNode().addNode("backupTest"); - sessionWS.getRootNode().save(); - addContent(wsTestRoot, 1, 10, 1); - sessionWS.getRootNode().save(); - } - - SessionImpl sessionWS = (SessionImpl)repositoryDB8.login(credentials, WS_NAME); - - // backup - File backDir = new File("target/backup"); - backDir.mkdirs(); - - RepositoryBackupConfig config = new RepositoryBackupConfig(); - config.setRepository(repositoryDB8.getName()); - config.setBackupType(BackupManager.FULL_BACKUP_ONLY); - - config.setBackupDir(backDir); - - backup.startBackup(config); - - RepositoryBackupChain bch = backup.findRepositoryBackup(repositoryDB8.getName()); - - // wait till full backup will be stopped - while (bch.getState() != RepositoryBackupChain.FINISHED) - { - Thread.yield(); - Thread.sleep(50); - } - - // stop fullBackup - - backup.stopBackup(bch); - - // restore - RepositoryEntry baseRE = - (RepositoryEntry)sessionWS.getContainer().getComponentInstanceOfType(RepositoryEntry.class); - RepositoryEntry re = makeRepositoryEntry(baseRE.getName(), baseRE, null, null); - - File backLog = new File(bch.getLogFilePath()); - if (backLog.exists()) - { - RepositoryBackupChainLog bchLog = new RepositoryBackupChainLog(backLog); - - assertNotNull(bchLog.getStartedTime()); - assertNotNull(bchLog.getFinishedTime()); - - backup.restoreExistingRepository(bchLog, re, false); - - assertEquals(JobWorkspaceRestore.RESTORE_SUCCESSFUL, backup.getLastRepositoryRestore(re.getName()) - .getStateRestore()); - - // check - ManageableRepository restoredRepository = repositoryService.getRepository(re.getName()); - - for (String wsName : restoredRepository.getWorkspaceNames()) - { - SessionImpl back1 = null; - try - { - back1 = (SessionImpl)restoredRepository.login(credentials, wsName); - Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); - assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") - .getProperty("exo:data").getString()); - } - catch (Exception e) - { - e.printStackTrace(); - fail(e.getMessage()); - } - finally - { - if (back1 != null) - back1.logout(); - } - } - } - else - fail("There are no backup files in " + backDir.getAbsolutePath()); - } - - public void testExistedRepositoryRestoreMultiDB() throws Exception - { - RepositoryImpl repositoryDB7 = (RepositoryImpl)repositoryService.getRepository("db7"); - - for (String wsName : repositoryDB7.getWorkspaceNames()) - { - SessionImpl sessionWS = (SessionImpl)repositoryDB7.login(credentials, wsName); - - Node wsTestRoot = sessionWS.getRootNode().addNode("backupTest"); - sessionWS.getRootNode().save(); - addContent(wsTestRoot, 1, 10, 1); - sessionWS.getRootNode().save(); - } - - SessionImpl sessionWS = (SessionImpl)repositoryDB7.login(credentials, WS_NAME); - - // backup - File backDir = new File("target/backup"); - backDir.mkdirs(); - - RepositoryBackupConfig config = new RepositoryBackupConfig(); - config.setRepository(repositoryDB7.getName()); - config.setBackupType(BackupManager.FULL_BACKUP_ONLY); - - config.setBackupDir(backDir); - - backup.startBackup(config); - - RepositoryBackupChain bch = backup.findRepositoryBackup(repositoryDB7.getName()); - - // wait till full backup will be stopped - while (bch.getState() != RepositoryBackupChain.FINISHED) - { - Thread.yield(); - Thread.sleep(50); - } - - // stop fullBackup - - backup.stopBackup(bch); - - // restore - RepositoryEntry baseRE = - (RepositoryEntry)sessionWS.getContainer().getComponentInstanceOfType(RepositoryEntry.class); - RepositoryEntry re = makeRepositoryEntry(baseRE.getName(), baseRE, null, null); - - File backLog = new File(bch.getLogFilePath()); - if (backLog.exists()) - { - RepositoryBackupChainLog bchLog = new RepositoryBackupChainLog(backLog); - - assertNotNull(bchLog.getStartedTime()); - assertNotNull(bchLog.getFinishedTime()); - - backup.restoreExistingRepository(bchLog, re, false); - - assertEquals(JobWorkspaceRestore.RESTORE_SUCCESSFUL, backup.getLastRepositoryRestore(re.getName()) - .getStateRestore()); - - // check - ManageableRepository restoredRepository = repositoryService.getRepository(re.getName()); - - for (String wsName : restoredRepository.getWorkspaceNames()) - { - SessionImpl back1 = null; - try - { - back1 = (SessionImpl)restoredRepository.login(credentials, wsName); - Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); - assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") - .getProperty("exo:data").getString()); - } - catch (Exception e) - { - e.printStackTrace(); - fail(e.getMessage()); - } - finally - { - if (back1 != null) - back1.logout(); - } - } - } - else - fail("There are no backup files in " + backDir.getAbsolutePath()); - } - - public void testExistedRepositoryRestoreAsync() throws Exception - { - RepositoryImpl repositoryDB8 = (RepositoryImpl)repositoryService.getRepository("db8"); - - for (String wsName : repositoryDB8.getWorkspaceNames()) - { - SessionImpl sessionWS = (SessionImpl)repositoryDB8.login(credentials, wsName); - - Node wsTestRoot = sessionWS.getRootNode().addNode("backupTest"); - sessionWS.getRootNode().save(); - addContent(wsTestRoot, 1, 10, 1); - sessionWS.getRootNode().save(); - } - - SessionImpl sessionWS = (SessionImpl)repositoryDB8.login(credentials, WS_NAME); - - // backup - File backDir = new File("target/backup"); - backDir.mkdirs(); - - RepositoryBackupConfig config = new RepositoryBackupConfig(); - config.setRepository(repositoryDB8.getName()); - config.setBackupType(BackupManager.FULL_BACKUP_ONLY); - - config.setBackupDir(backDir); - - backup.startBackup(config); - - RepositoryBackupChain bch = backup.findRepositoryBackup(repositoryDB8.getName()); - - // wait till full backup will be stopped - while (bch.getState() != RepositoryBackupChain.FINISHED) - { - Thread.yield(); - Thread.sleep(50); - } - - // stop fullBackup - - backup.stopBackup(bch); - - // restore - RepositoryEntry baseRE = - (RepositoryEntry)sessionWS.getContainer().getComponentInstanceOfType(RepositoryEntry.class); - RepositoryEntry re = makeRepositoryEntry(baseRE.getName(), baseRE, null, null); - - File backLog = new File(bch.getLogFilePath()); - if (backLog.exists()) - { - RepositoryBackupChainLog bchLog = new RepositoryBackupChainLog(backLog); - - assertNotNull(bchLog.getStartedTime()); - assertNotNull(bchLog.getFinishedTime()); - - backup.restoreExistingRepository(bchLog, re, true); - - JobRepositoryRestore job = backup.getLastRepositoryRestore(re.getName()); - - while (job.getStateRestore() != JobRepositoryRestore.REPOSITORY_RESTORE_SUCCESSFUL - && job.getStateRestore() != JobRepositoryRestore.REPOSITORY_RESTORE_FAIL) - { - Thread.sleep(50); - } - - assertEquals(JobRepositoryRestore.REPOSITORY_RESTORE_SUCCESSFUL, backup.getLastRepositoryRestore(re.getName()) - .getStateRestore()); - - // check - ManageableRepository restoredRepository = repositoryService.getRepository(re.getName()); - - for (String wsName : restoredRepository.getWorkspaceNames()) - { - SessionImpl back1 = null; - try - { - back1 = (SessionImpl)restoredRepository.login(credentials, wsName); - Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); - assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") - .getProperty("exo:data").getString()); - } - catch (Exception e) - { - e.printStackTrace(); - fail(e.getMessage()); - } - finally - { - if (back1 != null) - back1.logout(); - } - } - } - else - fail("There are no backup files in " + backDir.getAbsolutePath()); - } - - public void testExistedRepositoryRestoreAsync2() throws Exception - { - RepositoryImpl repositoryDB8 = (RepositoryImpl)repositoryService.getRepository("db8"); - - for (String wsName : repositoryDB8.getWorkspaceNames()) - { - SessionImpl sessionWS = (SessionImpl)repositoryDB8.login(credentials, wsName); - - Node wsTestRoot = sessionWS.getRootNode().addNode("backupTest"); - sessionWS.getRootNode().save(); - addContent(wsTestRoot, 1, 10, 1); - sessionWS.getRootNode().save(); - } - - SessionImpl sessionWS = (SessionImpl)repositoryDB8.login(credentials, WS_NAME); - - // backup - File backDir = new File("target/backup"); - backDir.mkdirs(); - - RepositoryBackupConfig config = new RepositoryBackupConfig(); - config.setRepository(repositoryDB8.getName()); - config.setBackupType(BackupManager.FULL_BACKUP_ONLY); - - config.setBackupDir(backDir); - - backup.startBackup(config); - - RepositoryBackupChain bch = backup.findRepositoryBackup(repositoryDB8.getName()); - - // wait till full backup will be stopped - while (bch.getState() != RepositoryBackupChain.FINISHED) - { - Thread.yield(); - Thread.sleep(50); - } - - // stop fullBackup - - backup.stopBackup(bch); - - // restore - RepositoryEntry baseRE = - (RepositoryEntry)sessionWS.getContainer().getComponentInstanceOfType(RepositoryEntry.class); - RepositoryEntry re = makeRepositoryEntry(baseRE.getName(), baseRE, null, null); - - File backLog = new File(bch.getLogFilePath()); - if (backLog.exists()) - { - RepositoryBackupChainLog bchLog = new RepositoryBackupChainLog(backLog); - - assertNotNull(bchLog.getStartedTime()); - assertNotNull(bchLog.getFinishedTime()); - - backup.restoreExistingRepository(bchLog.getBackupId(), re, true); - - JobRepositoryRestore job = backup.getLastRepositoryRestore(re.getName()); - - while (job.getStateRestore() != JobRepositoryRestore.REPOSITORY_RESTORE_SUCCESSFUL - && job.getStateRestore() != JobRepositoryRestore.REPOSITORY_RESTORE_FAIL) - { - Thread.sleep(50); - } - - assertEquals(JobWorkspaceRestore.RESTORE_SUCCESSFUL, backup.getLastRepositoryRestore(re.getName()) - .getStateRestore()); - - // check - ManageableRepository restoredRepository = repositoryService.getRepository(re.getName()); - - for (String wsName : restoredRepository.getWorkspaceNames()) - { - SessionImpl back1 = null; - try - { - back1 = (SessionImpl)restoredRepository.login(credentials, wsName); - Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); - assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") - .getProperty("exo:data").getString()); - } - catch (Exception e) - { - e.printStackTrace(); - fail(e.getMessage()); - } - finally - { - if (back1 != null) - back1.logout(); - } - } - } - else - fail("There are no backup files in " + backDir.getAbsolutePath()); - } - - public void testExistedWorkspaceRestoreMultiDB() throws Exception - { - RepositoryImpl repositoryDB7 = (RepositoryImpl)repositoryService.getRepository("db7"); - - SessionImpl sessionWS = (SessionImpl)repositoryDB7.login(credentials, "ws1"); - - Node wsTestRoot = sessionWS.getRootNode().addNode("backupTest"); - sessionWS.getRootNode().save(); - addContent(wsTestRoot, 1, 10, 1); - sessionWS.getRootNode().save(); - - // backup - File backDir = new File("target/backup/ws1"); - backDir.mkdirs(); - - BackupConfig config = new BackupConfig(); - config.setRepository(repositoryDB7.getName()); - config.setWorkspace("ws1"); - config.setBackupType(BackupManager.FULL_BACKUP_ONLY); - - config.setBackupDir(backDir); - - backup.startBackup(config); - - BackupChain bch = backup.findBackup(repositoryDB7.getName(), "ws1"); - - // wait till full backup will be stopped - while (bch.getFullBackupState() != BackupJob.FINISHED) - { - Thread.yield(); - Thread.sleep(50); - } - - // stop fullBackup - - if (bch != null) - backup.stopBackup(bch); - else - fail("Can't get fullBackup chain"); - - // restore - RepositoryEntry re = (RepositoryEntry)sessionWS.getContainer().getComponentInstanceOfType(RepositoryEntry.class); - WorkspaceEntry ws1 = null; - for (WorkspaceEntry we : re.getWorkspaceEntries()) - { - if (sessionWS.getWorkspace().getName().equals(we.getName())) - { - ws1 = we; - break; - } - } - - File backLog = new File(bch.getLogFilePath()); - if (backLog.exists()) - { - BackupChainLog bchLog = new BackupChainLog(backLog); - - assertNotNull(bchLog.getStartedTime()); - assertNotNull(bchLog.getFinishedTime()); - - backup.restoreExistingWorkspace(bchLog, re.getName(), ws1, false); - - // check - SessionImpl back1 = null; - try - { - back1 = (SessionImpl)repositoryDB7.login(credentials, "ws1"); - Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); - assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") - .getProperty("exo:data").getString()); - } - catch (Exception e) - { - e.printStackTrace(); - fail(e.getMessage()); - } - finally - { - if (back1 != null) - back1.logout(); - } - } - else - fail("There are no backup files in " + backDir.getAbsolutePath()); - } - - public void testExistedWorkspaceRestoreWithConfig() throws Exception - { - // backup - File backDir = new File("target/backup/ws1"); - backDir.mkdirs(); - - BackupConfig config = new BackupConfig(); - config.setRepository(repository.getName()); - config.setWorkspace("ws1"); - config.setBackupType(BackupManager.FULL_BACKUP_ONLY); - - config.setBackupDir(backDir); - - backup.startBackup(config); - - BackupChain bch = backup.findBackup(repository.getName(), "ws1"); - - // wait till full backup will be stopped - while (bch.getFullBackupState() != BackupJob.FINISHED) - { - Thread.yield(); - Thread.sleep(50); - } - - // stop fullBackup - if (bch != null) - backup.stopBackup(bch); - else - fail("Can't get fullBackup chain"); - - super.tearDown(); - - File backLog = new File(bch.getLogFilePath()); - if (backLog.exists()) - { - BackupChainLog bchLog = new BackupChainLog(backLog); - - assertNotNull(bchLog.getStartedTime()); - assertNotNull(bchLog.getFinishedTime()); - - backup.restoreExistingWorkspace(bchLog.getBackupId(), false); - - // check - SessionImpl back1 = null; - try - { - back1 = (SessionImpl)repository.login(credentials, "ws1"); - Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); - assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") - .getProperty("exo:data").getString()); - } - catch (Exception e) - { - e.printStackTrace(); - fail(e.getMessage()); - } - finally - { - if (back1 != null) - back1.logout(); - } - } - else - fail("There are no backup files in " + backDir.getAbsolutePath()); - } - - public void testExistedRepositoryRestoreWithConfig() throws Exception - { - RepositoryImpl repositoryDB8 = (RepositoryImpl)repositoryService.getRepository("db8"); - - for (String wsName : repositoryDB8.getWorkspaceNames()) - { - SessionImpl sessionWS = (SessionImpl)repositoryDB8.login(credentials, wsName); - - Node wsTestRoot = sessionWS.getRootNode().addNode("backupTest"); - sessionWS.getRootNode().save(); - addContent(wsTestRoot, 1, 10, 1); - sessionWS.getRootNode().save(); - } - - SessionImpl sessionWS = (SessionImpl)repositoryDB8.login(credentials, WS_NAME); - - // backup - File backDir = new File("target/backup/db1"); - backDir.mkdirs(); - - RepositoryBackupConfig config = new RepositoryBackupConfig(); - String repoName = repositoryDB8.getName(); - config.setRepository(repoName); - config.setBackupType(BackupManager.FULL_BACKUP_ONLY); - - config.setBackupDir(backDir); - - backup.startBackup(config); - - RepositoryBackupChain bch = backup.findRepositoryBackup(repositoryDB8.getName()); - - // wait till full backup will be stopped - while (bch.getState() != RepositoryBackupChain.FINISHED) - { - Thread.yield(); - Thread.sleep(50); - } - - // stop fullBackup - backup.stopBackup(bch); - - // check - super.tearDown(); - - // restore - File backLog = new File(bch.getLogFilePath()); - if (backLog.exists()) - { - RepositoryBackupChainLog bchLog = new RepositoryBackupChainLog(backLog); - - assertNotNull(bchLog.getStartedTime()); - assertNotNull(bchLog.getFinishedTime()); - - backup.restoreExistingRepository(bchLog.getBackupId(), false); - - assertEquals(JobWorkspaceRestore.RESTORE_SUCCESSFUL, backup.getLastRepositoryRestore(repoName) - .getStateRestore()); - - // check - ManageableRepository restoredRepository = repositoryService.getRepository(repoName); - - for (String wsName : restoredRepository.getWorkspaceNames()) - { - SessionImpl back1 = null; - try - { - back1 = (SessionImpl)restoredRepository.login(credentials, wsName); - Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); - assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") - .getProperty("exo:data").getString()); - } - catch (Exception e) - { - e.printStackTrace(); - fail(e.getMessage()); - } - finally - { - if (back1 != null) - back1.logout(); - } - } - } - else - fail("There are no backup files in " + backDir.getAbsolutePath()); - } - - public void testWorkspaceRestoreWithConfig() throws Exception - { - // backup - File backDir = new File("target/backup/ws1"); - backDir.mkdirs(); - - BackupConfig config = new BackupConfig(); - config.setRepository(repository.getName()); - config.setWorkspace("ws1"); - config.setBackupType(BackupManager.FULL_BACKUP_ONLY); - - config.setBackupDir(backDir); - - backup.startBackup(config); - - BackupChain bch = backup.findBackup(repository.getName(), "ws1"); - - // wait till full backup will be stopped - while (bch.getFullBackupState() != BackupJob.FINISHED) - { - Thread.yield(); - Thread.sleep(50); - } - - // stop fullBackup - - if (bch != null) - backup.stopBackup(bch); - else - fail("Can't get fullBackup chain"); - - //TODO - super.tearDown(); - removeWorkspaceFully(repository.getName(), "ws1"); - - File backLog = new File(bch.getLogFilePath()); - if (backLog.exists()) - { - BackupChainLog bchLog = new BackupChainLog(backLog); - - assertNotNull(bchLog.getStartedTime()); - assertNotNull(bchLog.getFinishedTime()); - - backup.restoreWorkspace(bchLog.getBackupId(), false); - - // check - SessionImpl back1 = null; - try - { - back1 = (SessionImpl)repository.login(credentials, "ws1"); - Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); - assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") - .getProperty("exo:data").getString()); - } - catch (Exception e) - { - e.printStackTrace(); - fail(e.getMessage()); - } - finally - { - if (back1 != null) - back1.logout(); - } - } - else - fail("There are no backup files in " + backDir.getAbsolutePath()); - } - - public void testRepositoryRestoreWithConfig() throws Exception - { - RepositoryImpl repositoryDB8 = (RepositoryImpl)repositoryService.getRepository("db8"); - - for (String wsName : repositoryDB8.getWorkspaceNames()) - { - SessionImpl sessionWS = (SessionImpl)repositoryDB8.login(credentials, wsName); - - Node wsTestRoot = sessionWS.getRootNode().addNode("backupTest"); - sessionWS.getRootNode().save(); - addContent(wsTestRoot, 1, 10, 1); - sessionWS.getRootNode().save(); - } - - SessionImpl sessionWS = (SessionImpl)repositoryDB8.login(credentials, WS_NAME); - - // backup - File backDir = new File("target/backup"); - backDir.mkdirs(); - - RepositoryBackupConfig config = new RepositoryBackupConfig(); - String repoName = repositoryDB8.getName(); - config.setRepository(repoName); - config.setBackupType(BackupManager.FULL_BACKUP_ONLY); - - config.setBackupDir(backDir); - - backup.startBackup(config); - - RepositoryBackupChain bch = backup.findRepositoryBackup(repositoryDB8.getName()); - - // wait till full backup will be stopped - while (bch.getState() != RepositoryBackupChain.FINISHED) - { - Thread.yield(); - Thread.sleep(50); - } - - // stop fullBackup - - backup.stopBackup(bch); - - //TODO - super.tearDown(); - removeRepositoryFully(repositoryDB8.getName()); - - // restore - File backLog = new File(bch.getLogFilePath()); - if (backLog.exists()) - { - RepositoryBackupChainLog bchLog = new RepositoryBackupChainLog(backLog); - - assertNotNull(bchLog.getStartedTime()); - assertNotNull(bchLog.getFinishedTime()); - - backup.restoreRepository(bchLog.getBackupId(), false); - - assertEquals(JobWorkspaceRestore.RESTORE_SUCCESSFUL, backup.getLastRepositoryRestore(repoName) - .getStateRestore()); - - // check - ManageableRepository restoredRepository = repositoryService.getRepository(repoName); - - for (String wsName : restoredRepository.getWorkspaceNames()) - { - SessionImpl back1 = null; - try - { - back1 = (SessionImpl)restoredRepository.login(credentials, wsName); - Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); - assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") - .getProperty("exo:data").getString()); - } - catch (Exception e) - { - e.printStackTrace(); - fail(e.getMessage()); - } - finally - { - if (back1 != null) - back1.logout(); - } - } - } - else - fail("There are no backup files in " + backDir.getAbsolutePath()); - } - } Modified: jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/TestBackupRestart.java =================================================================== --- jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/TestBackupRestart.java 2010-12-08 09:32:42 UTC (rev 3616) +++ jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/TestBackupRestart.java 2010-12-08 09:35:29 UTC (rev 3617) @@ -18,12 +18,12 @@ */ package org.exoplatform.services.jcr.ext.backup; -import org.exoplatform.services.jcr.ext.backup.impl.BackupScheduler; - import java.io.File; import java.util.Calendar; import java.util.Date; +import org.exoplatform.services.jcr.ext.backup.impl.BackupScheduler; + /** * Created by The eXo Platform SAS * @@ -44,6 +44,11 @@ // empty to be able work after the JVM restart } + protected ExtendedBackupManager getBackupManager() + { + return (ExtendedBackupManager) container.getComponentInstanceOfType(BackupManager.class); + } + /** * 4. startTime, endTime + incrementalPeriod - run during a given period (with incremental backup) */ Modified: jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/TestBackupScheduler.java =================================================================== --- jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/TestBackupScheduler.java 2010-12-08 09:32:42 UTC (rev 3616) +++ jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/TestBackupScheduler.java 2010-12-08 09:35:29 UTC (rev 3617) @@ -18,17 +18,17 @@ */ package org.exoplatform.services.jcr.ext.backup; -import org.exoplatform.services.jcr.ext.backup.impl.BackupMessagesLog; -import org.exoplatform.services.jcr.ext.backup.impl.BackupScheduler; -import org.exoplatform.services.log.ExoLogger; -import org.exoplatform.services.log.Log; - import java.io.File; import java.util.Calendar; import java.util.Date; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; +import org.exoplatform.services.jcr.ext.backup.impl.BackupMessagesLog; +import org.exoplatform.services.jcr.ext.backup.impl.BackupScheduler; +import org.exoplatform.services.log.ExoLogger; +import org.exoplatform.services.log.Log; + /** * Created by The eXo Platform SAS * @@ -42,6 +42,11 @@ private static final Log log = ExoLogger.getLogger("exo.jcr.component.ext.TestBackupScheduler"); + protected ExtendedBackupManager getBackupManager() + { + return (ExtendedBackupManager) container.getComponentInstanceOfType(BackupManager.class); + } + class BackupWaiter implements BackupJobListener { Added: jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/TestRDBMSBackupManager.java =================================================================== --- jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/TestRDBMSBackupManager.java (rev 0) +++ jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/TestRDBMSBackupManager.java 2010-12-08 09:35:29 UTC (rev 3617) @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2003-2010 eXo Platform SAS. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Affero General Public License + * as published by the Free Software Foundation; either version 3 + * of the License, or (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see<http://www.gnu.org/licenses/>;. + */ +package org.exoplatform.services.jcr.ext.backup; + +import org.exoplatform.container.xml.InitParams; +import org.exoplatform.container.xml.PropertiesParam; +import org.exoplatform.services.jcr.ext.backup.impl.BackupManagerImpl; + + +/** + * Created by The eXo Platform SAS. + * + * <br/>Date: 2010 + * + * @author <a href="mailto:alex.reshetnyak@exoplatform.com.ua">Alex Reshetnyak</a> + * @version $Id$ + */ +public class TestRDBMSBackupManager + extends AbstractBackupUseCasesTest +{ + + protected ExtendedBackupManager getBackupManager() + { + InitParams initParams = new InitParams(); + PropertiesParam pps = new PropertiesParam(); + pps.setProperty(BackupManagerImpl.FULL_BACKUP_TYPE, + "org.exoplatform.services.jcr.ext.backup.impl.rdbms.FullBackupJob"); + pps.setProperty(BackupManagerImpl.INCREMENTAL_BACKUP_TYPE, + "org.exoplatform.services.jcr.ext.backup.impl.fs.IncrementalBackupJob"); + pps.setProperty(BackupManagerImpl.BACKUP_DIR, "target/backup_testRDBMSBackupManager"); + pps.setProperty(BackupManagerImpl.DEFAULT_INCREMENTAL_JOB_PERIOD, "3600"); + + initParams.put(BackupManagerImpl.BACKUP_PROPERTIES, pps); + + BackupManagerImpl backupManagerImpl = new BackupManagerImpl(initParams, repositoryService); + backupManagerImpl.start(); + + return backupManagerImpl; + } +} Property changes on: jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/TestRDBMSBackupManager.java ___________________________________________________________________ Name: svn:keywords + Id Name: svn:eol-style + native Modified: jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/TestRdbmsFullBackupJob.java =================================================================== --- jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/TestRdbmsFullBackupJob.java 2010-12-08 09:32:42 UTC (rev 3616) +++ jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/TestRdbmsFullBackupJob.java 2010-12-08 09:35:29 UTC (rev 3617) @@ -18,18 +18,19 @@ */ package org.exoplatform.services.jcr.ext.backup; -import org.exoplatform.services.jcr.ext.backup.impl.rdbms.FullBackupJob; -import org.exoplatform.services.jcr.impl.core.RdbmsWorkspaceInitializer; - import java.io.File; import java.net.URL; import java.util.Calendar; +import org.exoplatform.services.jcr.ext.backup.impl.rdbms.FullBackupJob; +import org.exoplatform.services.jcr.impl.core.RdbmsWorkspaceInitializer; + /** * @author <a href="mailto:anatoliy.bazko@gmail.com">Anatoliy Bazko</a> * @version $Id: TestFullBackupJob.java 34360 2009-07-22 23:58:59Z tolusha $ */ -public class TestRdbmsFullBackupJob extends AbstractBackupTestCase +public class TestRdbmsFullBackupJob + extends BaseRDBMSBackupTest { public void testRDBMSFullBackupJobSystemWorkspace() throws Exception Modified: jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/TestRdbmsWorkspaceInitializer.java =================================================================== --- jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/TestRdbmsWorkspaceInitializer.java 2010-12-08 09:32:42 UTC (rev 3616) +++ jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/TestRdbmsWorkspaceInitializer.java 2010-12-08 09:35:29 UTC (rev 3617) @@ -18,6 +18,17 @@ */ package org.exoplatform.services.jcr.ext.backup; +import java.io.File; +import java.net.URL; +import java.sql.Connection; +import java.sql.Statement; +import java.util.ArrayList; +import java.util.Calendar; +import java.util.List; + +import javax.naming.InitialContext; +import javax.sql.DataSource; + import org.exoplatform.services.jcr.config.SimpleParameterEntry; import org.exoplatform.services.jcr.config.WorkspaceEntry; import org.exoplatform.services.jcr.config.WorkspaceInitializerEntry; @@ -30,22 +41,12 @@ import org.exoplatform.services.jcr.util.IdGenerator; import org.exoplatform.services.jcr.util.TesterConfigurationHelper; -import java.io.File; -import java.net.URL; -import java.sql.Connection; -import java.sql.Statement; -import java.util.ArrayList; -import java.util.Calendar; -import java.util.List; - -import javax.naming.InitialContext; -import javax.sql.DataSource; - /** * @author <a href="mailto:anatoliy.bazko@gmail.com">Anatoliy Bazko</a> * @version $Id: TestFullBackupJob.java 34360 2009-07-22 23:58:59Z tolusha $ */ -public class TestRdbmsWorkspaceInitializer extends AbstractBackupTestCase +public class TestRdbmsWorkspaceInitializer + extends BaseRDBMSBackupTest { TesterConfigurationHelper helper = TesterConfigurationHelper.getInstence(); Modified: jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/repository/creation/TestRepositoryCreationService.java =================================================================== --- jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/repository/creation/TestRepositoryCreationService.java 2010-12-08 09:32:42 UTC (rev 3616) +++ jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/repository/creation/TestRepositoryCreationService.java 2010-12-08 09:35:29 UTC (rev 3617) @@ -16,20 +16,21 @@ */ package org.exoplatform.services.jcr.ext.repository.creation; +import java.io.File; + +import javax.jcr.Node; + 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.core.ManageableRepository; import org.exoplatform.services.jcr.ext.backup.AbstractBackupTestCase; import org.exoplatform.services.jcr.ext.backup.BackupManager; +import org.exoplatform.services.jcr.ext.backup.ExtendedBackupManager; import org.exoplatform.services.jcr.ext.backup.RepositoryBackupChain; import org.exoplatform.services.jcr.ext.backup.RepositoryBackupConfig; import org.exoplatform.services.jcr.impl.core.SessionImpl; -import java.io.File; - -import javax.jcr.Node; - /** * Created by The eXo Platform SAS. * @@ -41,6 +42,11 @@ public class TestRepositoryCreationService extends AbstractBackupTestCase { + protected ExtendedBackupManager getBackupManager() + { + return (ExtendedBackupManager) container.getComponentInstanceOfType(BackupManager.class); + } + public void testCreateRepository() throws Exception {