exo-jcr SVN: r3619 - in kernel/trunk: exo.kernel.component.ext.cache.impl.infinispan.v4 and 1 other directory.
by do-not-reply@jboss.org
Author: nzamosenchuk
Date: 2010-12-09 02:31:10 -0500 (Thu, 09 Dec 2010)
New Revision: 3619
Modified:
kernel/trunk/exo.kernel.component.ext.cache.impl.infinispan.v4/pom.xml
kernel/trunk/pom.xml
Log:
[maven-release-plugin] prepare branch 2.3-IMPR
Modified: kernel/trunk/exo.kernel.component.ext.cache.impl.infinispan.v4/pom.xml
===================================================================
--- kernel/trunk/exo.kernel.component.ext.cache.impl.infinispan.v4/pom.xml 2010-12-08 11:04:20 UTC (rev 3618)
+++ kernel/trunk/exo.kernel.component.ext.cache.impl.infinispan.v4/pom.xml 2010-12-09 07:31:10 UTC (rev 3619)
@@ -1,80 +1,79 @@
-
- <!--
-
- Copyright (C) 2009 eXo Platform SAS. This is free software; you can
- redistribute it and/or modify it under the terms of the GNU Lesser
- General Public License as published by the Free Software Foundation;
- either version 2.1 of the License, or (at your option) any later
- version. This software is distributed in the hope that it will be
- useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details. You should have
- received a copy of the GNU Lesser General Public License along with
- this software; if not, write to the Free Software Foundation, Inc., 51
- Franklin St, Fifth Floor, Boston, MA 02110-1301 USA, or see the FSF
- site: http://www.fsf.org.
- -->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
- <modelVersion>4.0.0</modelVersion>
- <parent>
- <groupId>org.exoplatform.kernel</groupId>
- <artifactId>kernel-parent</artifactId>
- <version>2.3.0-CR1-SNAPSHOT</version>
- </parent>
- <artifactId>exo.kernel.component.ext.cache.impl.infinispan.v4</artifactId>
- <name>eXo Kernel :: Cache Extension :: Infinispan Implementation</name>
- <description>Infinispan Implementation for the Cache Service</description>
- <dependencies>
- <dependency>
- <groupId>org.exoplatform.kernel</groupId>
- <artifactId>exo.kernel.component.cache</artifactId>
- </dependency>
- <dependency>
- <groupId>org.infinispan</groupId>
- <artifactId>infinispan-core</artifactId>
- </dependency>
- <dependency>
- <groupId>org.slf4j</groupId>
- <artifactId>slf4j-log4j12</artifactId>
- </dependency>
- </dependencies>
- <build>
- <plugins>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-surefire-plugin</artifactId>
- <configuration>
- <systemProperties>
- <!--
- We add this system property due to some incompatibility between
- IPv6 and some JVM of Linux distributions such as Ubuntu and
- Fedora
- -->
- <property>
- <name>java.net.preferIPv4Stack</name>
- <value>true</value>
- </property>
- <!-- Avoid the firewall -->
- <property>
- <name>bind.address</name>
- <value>127.0.0.1</value>
- </property>
- <property>
- <name>jgroups.stack</name>
- <value>udp</value>
- </property>
- </systemProperties>
- </configuration>
- </plugin>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-compiler-plugin</artifactId>
- <configuration>
- <source>1.6</source>
- <target>1.6</target>
- </configuration>
- </plugin>
- </plugins>
- </build>
-</project>
+
+ <!--
+
+ Copyright (C) 2009 eXo Platform SAS. This is free software; you can
+ redistribute it and/or modify it under the terms of the GNU Lesser
+ General Public License as published by the Free Software Foundation;
+ either version 2.1 of the License, or (at your option) any later
+ version. This software is distributed in the hope that it will be
+ useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details. You should have
+ received a copy of the GNU Lesser General Public License along with
+ this software; if not, write to the Free Software Foundation, Inc., 51
+ Franklin St, Fifth Floor, Boston, MA 02110-1301 USA, or see the FSF
+ site: http://www.fsf.org.
+ -->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+ <parent>
+ <groupId>org.exoplatform.kernel</groupId>
+ <artifactId>kernel-parent</artifactId>
+ <version>2.3.0-CR1-SNAPSHOT</version>
+ </parent>
+ <artifactId>exo.kernel.component.ext.cache.impl.infinispan.v4</artifactId>
+ <name>eXo Kernel :: Cache Extension :: Infinispan Implementation</name>
+ <description>Infinispan Implementation for the Cache Service</description>
+ <dependencies>
+ <dependency>
+ <groupId>org.exoplatform.kernel</groupId>
+ <artifactId>exo.kernel.component.cache</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.infinispan</groupId>
+ <artifactId>infinispan-core</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-log4j12</artifactId>
+ </dependency>
+ </dependencies>
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-surefire-plugin</artifactId>
+ <configuration>
+ <systemProperties>
+ <!--
+ We add this system property due to some incompatibility between
+ IPv6 and some JVM of Linux distributions such as Ubuntu and
+ Fedora
+ -->
+ <property>
+ <name>java.net.preferIPv4Stack</name>
+ <value>true</value>
+ </property>
+ <!-- Avoid the firewall -->
+ <property>
+ <name>bind.address</name>
+ <value>127.0.0.1</value>
+ </property>
+ <property>
+ <name>jgroups.stack</name>
+ <value>udp</value>
+ </property>
+ </systemProperties>
+ </configuration>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-compiler-plugin</artifactId>
+ <configuration>
+ <source>1.6</source>
+ <target>1.6</target>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+</project>
Modified: kernel/trunk/pom.xml
===================================================================
--- kernel/trunk/pom.xml 2010-12-08 11:04:20 UTC (rev 3618)
+++ kernel/trunk/pom.xml 2010-12-09 07:31:10 UTC (rev 3619)
@@ -43,9 +43,9 @@
</properties>
<scm>
- <connection>scm:svn:http://anonsvn.jboss.org/repos/exo-jcr/kernel/trunk</connection>
- <developerConnection>scm:svn:https://svn.jboss.org/repos/exo-jcr/kernel/trunk</developerConnection>
- <url>http://fisheye.jboss.org/browse/exo-jcr/kernel/trunk</url>
+ <connection>scm:svn:http://anonsvn.jboss.org/repos/exo-jcr/kernel/branches/2.3-IMPR</connection>
+ <developerConnection>scm:svn:https://svn.jboss.org/repos/exo-jcr/kernel/branches/2.3-IMPR</developerConnection>
+ <url>http://fisheye.jboss.org/browse/exo-jcr/kernel/branches/2.3-IMPR</url>
</scm>
<modules>
15 years, 5 months
exo-jcr SVN: r3618 - jcr/trunk/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core.
by do-not-reply@jboss.org
Author: areshetnyak
Date: 2010-12-08 06:04:20 -0500 (Wed, 08 Dec 2010)
New Revision: 3618
Modified:
jcr/trunk/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core/RdbmsWorkspaceInitializer.java
Log:
EXOJCR-1078 : RdbmsWorkspaceInitializer was fixed.
Modified: jcr/trunk/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core/RdbmsWorkspaceInitializer.java
===================================================================
--- jcr/trunk/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core/RdbmsWorkspaceInitializer.java 2010-12-08 09:35:29 UTC (rev 3617)
+++ jcr/trunk/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core/RdbmsWorkspaceInitializer.java 2010-12-08 11:04:20 UTC (rev 3618)
@@ -237,7 +237,7 @@
restoreTable(jdbcConn, table);
st = jdbcConn.createStatement();
- st.execute("ALTER TABLE " + table + " ADD CONSTRAINT " + constraint);
+ st.execute("ALTER TABLE " + table + " ADD " + constraint);
jdbcConn.commit();
}
else
15 years, 5 months
exo-jcr SVN: r3617 - in jcr/trunk/exo.jcr.component.ext: src/main/java/org/exoplatform/services/jcr/ext/backup and 3 other directories.
by do-not-reply@jboss.org
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
{
15 years, 5 months
exo-jcr SVN: r3616 - jcr/trunk/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core.
by do-not-reply@jboss.org
Author: areshetnyak
Date: 2010-12-08 04:32:42 -0500 (Wed, 08 Dec 2010)
New Revision: 3616
Added:
jcr/trunk/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core/RdbmsBackupWorkspaceInitializer.java
Modified:
jcr/trunk/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core/RdbmsWorkspaceInitializer.java
Log:
EXOJCR-1078 : Add RdbmsBackupWorkspaceInitializer.
Added: jcr/trunk/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core/RdbmsBackupWorkspaceInitializer.java
===================================================================
--- jcr/trunk/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core/RdbmsBackupWorkspaceInitializer.java (rev 0)
+++ jcr/trunk/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core/RdbmsBackupWorkspaceInitializer.java 2010-12-08 09:32:42 UTC (rev 3616)
@@ -0,0 +1,89 @@
+/*
+ * 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.impl.core;
+
+import javax.jcr.PathNotFoundException;
+import javax.jcr.RepositoryException;
+
+import org.exoplatform.services.jcr.access.AccessManager;
+import org.exoplatform.services.jcr.config.RepositoryConfigurationException;
+import org.exoplatform.services.jcr.config.RepositoryEntry;
+import org.exoplatform.services.jcr.config.WorkspaceEntry;
+import org.exoplatform.services.jcr.datamodel.NodeData;
+import org.exoplatform.services.jcr.impl.Constants;
+import org.exoplatform.services.jcr.impl.core.nodetype.NodeTypeManagerImpl;
+import org.exoplatform.services.jcr.impl.core.value.ValueFactoryImpl;
+import org.exoplatform.services.jcr.impl.dataflow.persistent.CacheableWorkspaceDataManager;
+import org.exoplatform.services.log.ExoLogger;
+import org.exoplatform.services.log.Log;
+
+/**
+ * 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 RdbmsBackupWorkspaceInitializer
+ extends RdbmsWorkspaceInitializer
+{
+ /**
+ * Logger.
+ */
+ protected static final Log log = ExoLogger.getLogger("exo.jcr.component.core.RdbmsBackupWorkspaceInitializer");
+
+ /**
+ * Constructor RdbmsBackupWorkspaceInitializer.
+ */
+ public RdbmsBackupWorkspaceInitializer(WorkspaceEntry config, RepositoryEntry repConfig,
+ CacheableWorkspaceDataManager dataManager, NamespaceRegistryImpl namespaceRegistry,
+ LocationFactory locationFactory, NodeTypeManagerImpl nodeTypeManager, ValueFactoryImpl valueFactory,
+ AccessManager accessManager) throws RepositoryConfigurationException, PathNotFoundException,
+ RepositoryException
+ {
+ super(config, repConfig, dataManager, namespaceRegistry, locationFactory, nodeTypeManager, valueFactory,
+ accessManager);
+ }
+
+
+ /**
+ * {@inheritDoc}
+ */
+ public NodeData initWorkspace() throws RepositoryException
+ {
+ if (isWorkspaceInitialized())
+ {
+ return (NodeData) dataManager.getItemData(Constants.ROOT_UUID);
+ }
+
+ long start = System.currentTimeMillis();
+
+ rdbmsRestore();
+
+ // restore from incremental backup
+ incrementalRead();
+
+ final NodeData root = (NodeData) dataManager.getItemData(Constants.ROOT_UUID);
+
+ log.info("Workspace [" + workspaceName + "] restored from storage " + restorePath + " in "
+ + (System.currentTimeMillis() - start) * 1d / 1000 + "sec");
+
+ return root;
+ }
+
+}
Property changes on: jcr/trunk/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core/RdbmsBackupWorkspaceInitializer.java
___________________________________________________________________
Name: svn:keywords
+ Id
Name: svn:eol-style
+ native
Modified: jcr/trunk/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core/RdbmsWorkspaceInitializer.java
===================================================================
--- jcr/trunk/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core/RdbmsWorkspaceInitializer.java 2010-12-07 15:38:28 UTC (rev 3615)
+++ jcr/trunk/exo.jcr.component.core/src/main/java/org/exoplatform/services/jcr/impl/core/RdbmsWorkspaceInitializer.java 2010-12-08 09:32:42 UTC (rev 3616)
@@ -18,6 +18,28 @@
*/
package org.exoplatform.services.jcr.impl.core;
+import java.io.ByteArrayInputStream;
+import java.io.EOFException;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.security.PrivilegedExceptionAction;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.sql.Types;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.jcr.PathNotFoundException;
+import javax.jcr.RepositoryException;
+import javax.naming.InitialContext;
+import javax.naming.NameNotFoundException;
+import javax.naming.NamingException;
+import javax.sql.DataSource;
+
import org.exoplatform.commons.utils.PrivilegedFileHelper;
import org.exoplatform.commons.utils.SecurityHelper;
import org.exoplatform.services.jcr.access.AccessManager;
@@ -41,33 +63,12 @@
import org.exoplatform.services.log.ExoLogger;
import org.exoplatform.services.log.Log;
-import java.io.ByteArrayInputStream;
-import java.io.EOFException;
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.security.PrivilegedExceptionAction;
-import java.sql.Connection;
-import java.sql.PreparedStatement;
-import java.sql.SQLException;
-import java.sql.Statement;
-import java.sql.Types;
-import java.util.ArrayList;
-import java.util.List;
-
-import javax.jcr.PathNotFoundException;
-import javax.jcr.RepositoryException;
-import javax.naming.InitialContext;
-import javax.naming.NameNotFoundException;
-import javax.naming.NamingException;
-import javax.sql.DataSource;
-
/**
* @author <a href="mailto:anatoliy.bazko@gmail.com">Anatoliy Bazko</a>
* @version $Id: RdbmsWorkspaceInitializer.java 34360 2009-07-22 23:58:59Z tolusha $
*/
-public class RdbmsWorkspaceInitializer extends BackupWorkspaceInitializer
+public class RdbmsWorkspaceInitializer
+ extends BackupWorkspaceInitializer
{
/**
* Logger.
@@ -139,7 +140,6 @@
/**
* {@inheritDoc}
*/
- @Override
public NodeData initWorkspace() throws RepositoryException
{
if (isWorkspaceInitialized())
@@ -147,13 +147,25 @@
return (NodeData)dataManager.getItemData(Constants.ROOT_UUID);
}
+ long start = System.currentTimeMillis();
+
+ rdbmsRestore();
+
+ final NodeData root = (NodeData) dataManager.getItemData(Constants.ROOT_UUID);
+
+ log.info("Workspace [" + workspaceName + "] restored from storage " + restorePath + " in "
+ + (System.currentTimeMillis() - start) * 1d / 1000 + "sec");
+
+ return root;
+ }
+
+ protected void rdbmsRestore() throws RepositoryException
+ {
Connection jdbcConn = null;
Integer transactionIsolation = null;
Statement st = null;
try
{
- long start = System.currentTimeMillis();
-
String dsName = workspaceEntry.getContainer().getParameterValue(JDBCWorkspaceDataContainer.SOURCE_NAME);
if (dsName == null)
{
@@ -248,17 +260,6 @@
restoreValueStorage();
restoreIndex();
-
- // restore from incremental backup
- incrementalRead();
-
- final NodeData root = (NodeData)dataManager.getItemData(Constants.ROOT_UUID);
-
- log.info("Workspace [" + workspaceName + "] restored from storage " + restorePath + " in "
- + (System.currentTimeMillis() - start) * 1d / 1000 + "sec");
-
- return root;
-
}
catch (RepositoryConfigurationException e)
{
15 years, 5 months
exo-jcr SVN: r3615 - jcr/trunk/exo.jcr.docs/exo.jcr.docs.developer/en/src/main/docbook/en-US/modules/jcr/other.
by do-not-reply@jboss.org
Author: sergiykarpenko
Date: 2010-12-07 10:38:28 -0500 (Tue, 07 Dec 2010)
New Revision: 3615
Modified:
jcr/trunk/exo.jcr.docs/exo.jcr.docs.developer/en/src/main/docbook/en-US/modules/jcr/other/acl.xml
Log:
EXOJCR-1086: access control documentation updated
Modified: jcr/trunk/exo.jcr.docs/exo.jcr.docs.developer/en/src/main/docbook/en-US/modules/jcr/other/acl.xml
===================================================================
--- jcr/trunk/exo.jcr.docs/exo.jcr.docs.developer/en/src/main/docbook/en-US/modules/jcr/other/acl.xml 2010-12-07 15:37:44 UTC (rev 3614)
+++ jcr/trunk/exo.jcr.docs/exo.jcr.docs.developer/en/src/main/docbook/en-US/modules/jcr/other/acl.xml 2010-12-07 15:38:28 UTC (rev 3615)
@@ -399,20 +399,20 @@
<itemizedlist>
<listitem>
<para><emphasis role="bold">read node</emphasis>: check read
- permission on target node. </para>
+ permission on target node.</para>
<para>For example. Read /node1/<emphasis
role="bold">subnode</emphasis> node - jcr will check "read"
- permission exactly on subnode.</para>
+ permission exactly on "subnode".</para>
</listitem>
<listitem>
<para><emphasis role="bold">read property</emphasis> : check read
- permission on parent node. </para>
+ permission on parent node.</para>
<para>For example. Read /<emphasis
role="bold">node1</emphasis>/myprop - jcr will check "read"
- permission on node1-node.</para>
+ permission on "node1".</para>
</listitem>
<listitem>
@@ -421,7 +421,7 @@
<para>For example. Try to add /<emphasis
role="bold">node1</emphasis>/sybnode node - jcr will check
- "add_node" permission on node1-node.</para>
+ "add_node" permission on "node1".</para>
</listitem>
<listitem>
@@ -430,7 +430,7 @@
<para>For example. Try to set /<emphasis
role="bold">node1</emphasis>/myprop property - jcr will check
- "set_property" permission on node1-node.</para>
+ "set_property" permission on "node1".</para>
</listitem>
<listitem>
@@ -439,7 +439,7 @@
<para>For example. Try to remove /node1/<emphasis
role="bold">subnode</emphasis> node - jcr will check "remove"
- permission on subnode-node.</para>
+ permission on "subnode".</para>
</listitem>
<listitem>
@@ -448,9 +448,23 @@
<para>For example. Try to remove /<emphasis
role="bold">node1</emphasis>/myprop property - jcr will check
- "remove" permission on node1-node.</para>
+ "remove" permission on "node1".</para>
</listitem>
</itemizedlist>
+
+ <para>Behavior of the permission "remove" has changed since JCR
+ 1.12.6-GA. The old behavior is:</para>
+
+ <para><itemizedlist>
+ <listitem>
+ <para><emphasis role="bold">remove node</emphasis>: check remove
+ permission on parent node</para>
+
+ <para>For example. Try to remove /<emphasis
+ role="bold">node1</emphasis>/subnode node - jcr will check
+ "remove" permission on "node1".</para>
+ </listitem>
+ </itemizedlist></para>
</section>
</section>
15 years, 5 months
exo-jcr SVN: r3614 - jcr/branches/1.12.x/exo.jcr.docs/exo.jcr.docs.developer/en/src/main/docbook/en-US/modules/jcr/other.
by do-not-reply@jboss.org
Author: sergiykarpenko
Date: 2010-12-07 10:37:44 -0500 (Tue, 07 Dec 2010)
New Revision: 3614
Modified:
jcr/branches/1.12.x/exo.jcr.docs/exo.jcr.docs.developer/en/src/main/docbook/en-US/modules/jcr/other/acl.xml
Log:
EXOJCR-1086: access control documentation updated
Modified: jcr/branches/1.12.x/exo.jcr.docs/exo.jcr.docs.developer/en/src/main/docbook/en-US/modules/jcr/other/acl.xml
===================================================================
--- jcr/branches/1.12.x/exo.jcr.docs/exo.jcr.docs.developer/en/src/main/docbook/en-US/modules/jcr/other/acl.xml 2010-12-07 15:25:41 UTC (rev 3613)
+++ jcr/branches/1.12.x/exo.jcr.docs/exo.jcr.docs.developer/en/src/main/docbook/en-US/modules/jcr/other/acl.xml 2010-12-07 15:37:44 UTC (rev 3614)
@@ -399,20 +399,20 @@
<itemizedlist>
<listitem>
<para><emphasis role="bold">read node</emphasis>: check read
- permission on target node. </para>
+ permission on target node.</para>
<para>For example. Read /node1/<emphasis
role="bold">subnode</emphasis> node - jcr will check "read"
- permission exactly on subnode.</para>
+ permission exactly on "subnode".</para>
</listitem>
<listitem>
<para><emphasis role="bold">read property</emphasis> : check read
- permission on parent node. </para>
+ permission on parent node.</para>
<para>For example. Read /<emphasis
role="bold">node1</emphasis>/myprop - jcr will check "read"
- permission on node1-node.</para>
+ permission on "node1".</para>
</listitem>
<listitem>
@@ -421,7 +421,7 @@
<para>For example. Try to add /<emphasis
role="bold">node1</emphasis>/sybnode node - jcr will check
- "add_node" permission on node1-node.</para>
+ "add_node" permission on "node1".</para>
</listitem>
<listitem>
@@ -430,7 +430,7 @@
<para>For example. Try to set /<emphasis
role="bold">node1</emphasis>/myprop property - jcr will check
- "set_property" permission on node1-node.</para>
+ "set_property" permission on "node1".</para>
</listitem>
<listitem>
@@ -439,7 +439,7 @@
<para>For example. Try to remove /node1/<emphasis
role="bold">subnode</emphasis> node - jcr will check "remove"
- permission on subnode-node.</para>
+ permission on "subnode".</para>
</listitem>
<listitem>
@@ -448,9 +448,23 @@
<para>For example. Try to remove /<emphasis
role="bold">node1</emphasis>/myprop property - jcr will check
- "remove" permission on node1-node.</para>
+ "remove" permission on "node1".</para>
</listitem>
</itemizedlist>
+
+ <para>Behavior of the permission "remove" has changed since JCR
+ 1.12.6-GA. The old behavior is:</para>
+
+ <para><itemizedlist>
+ <listitem>
+ <para><emphasis role="bold">remove node</emphasis>: check remove
+ permission on parent node</para>
+
+ <para>For example. Try to remove /<emphasis
+ role="bold">node1</emphasis>/subnode node - jcr will check
+ "remove" permission on "node1".</para>
+ </listitem>
+ </itemizedlist></para>
</section>
</section>
15 years, 5 months
exo-jcr SVN: r3613 - jcr/trunk/exo.jcr.docs/exo.jcr.docs.developer/en/src/main/docbook/en-US/modules/jcr/other.
by do-not-reply@jboss.org
Author: sergiykarpenko
Date: 2010-12-07 10:25:41 -0500 (Tue, 07 Dec 2010)
New Revision: 3613
Modified:
jcr/trunk/exo.jcr.docs/exo.jcr.docs.developer/en/src/main/docbook/en-US/modules/jcr/other/acl.xml
Log:
EXOJCR-1086: access control documentation updated
Modified: jcr/trunk/exo.jcr.docs/exo.jcr.docs.developer/en/src/main/docbook/en-US/modules/jcr/other/acl.xml
===================================================================
--- jcr/trunk/exo.jcr.docs/exo.jcr.docs.developer/en/src/main/docbook/en-US/modules/jcr/other/acl.xml 2010-12-07 15:16:30 UTC (rev 3612)
+++ jcr/trunk/exo.jcr.docs/exo.jcr.docs.developer/en/src/main/docbook/en-US/modules/jcr/other/acl.xml 2010-12-07 15:25:41 UTC (rev 3613)
@@ -57,17 +57,26 @@
<para>For example :</para>
- <para>session.checkPermission("/Groups/organization",
- "add_node,set_property") will check if the session is allowed to add a
- child node to "organization" and to modify its properties. If one of the
- two permissions is denied, an AccessDeniedException is thrown.</para>
-
<itemizedlist>
<listitem>
+ <para>session.checkPermission("/Groups/organization",
+ "add_node,set_property") will check if the session is allowed to add a
+ child node to "organization" and to modify its properties. If one of
+ the two permissions is denied, an AccessDeniedException is
+ thrown.</para>
+ </listitem>
+
+ <listitem>
<para>session.checkPermission("/Groups/organization/exo:name",
"read,set_property") will check if the session is allowed to read and
change the "exo:name" property of the "organization" node.</para>
</listitem>
+
+ <listitem>
+ <para>session.checkPermission("/Groups/organization/exo:name",
+ "remove") will check if the session allowed to remove "exo:name"
+ property or node.</para>
+ </listitem>
</itemizedlist>
</section>
@@ -99,7 +108,7 @@
<itemizedlist>
<listitem>
<para><emphasis role="bold">any</emphasis> : represents any
- authenticated session. </para>
+ authenticated session.</para>
</listitem>
<listitem>
@@ -380,6 +389,69 @@
</imageobject>
</mediaobject>
</section>
+
+ <section>
+ <title>Permission validation</title>
+
+ <para>There is a description how permission is validated for different
+ jcr actions</para>
+
+ <itemizedlist>
+ <listitem>
+ <para><emphasis role="bold">read node</emphasis>: check read
+ permission on target node. </para>
+
+ <para>For example. Read /node1/<emphasis
+ role="bold">subnode</emphasis> node - jcr will check "read"
+ permission exactly on subnode.</para>
+ </listitem>
+
+ <listitem>
+ <para><emphasis role="bold">read property</emphasis> : check read
+ permission on parent node. </para>
+
+ <para>For example. Read /<emphasis
+ role="bold">node1</emphasis>/myprop - jcr will check "read"
+ permission on node1-node.</para>
+ </listitem>
+
+ <listitem>
+ <para><emphasis role="bold">add node</emphasis>: check add_node on
+ parent node</para>
+
+ <para>For example. Try to add /<emphasis
+ role="bold">node1</emphasis>/sybnode node - jcr will check
+ "add_node" permission on node1-node.</para>
+ </listitem>
+
+ <listitem>
+ <para><emphasis role="bold">set property</emphasis>: set_property
+ on parent node</para>
+
+ <para>For example. Try to set /<emphasis
+ role="bold">node1</emphasis>/myprop property - jcr will check
+ "set_property" permission on node1-node.</para>
+ </listitem>
+
+ <listitem>
+ <para><emphasis role="bold">remove node</emphasis>: check remove
+ permission on target node.</para>
+
+ <para>For example. Try to remove /node1/<emphasis
+ role="bold">subnode</emphasis> node - jcr will check "remove"
+ permission on subnode-node.</para>
+ </listitem>
+
+ <listitem>
+ <para><emphasis role="bold">remove property</emphasis>: check
+ remove permission on parent node</para>
+
+ <para>For example. Try to remove /<emphasis
+ role="bold">node1</emphasis>/myprop property - jcr will check
+ "remove" permission on node1-node.</para>
+ </listitem>
+ </itemizedlist>
+ </section>
</section>
<section>
15 years, 5 months
exo-jcr SVN: r3612 - jcr/branches/1.12.x/exo.jcr.docs/exo.jcr.docs.developer/en/src/main/docbook/en-US/modules/jcr/other.
by do-not-reply@jboss.org
Author: sergiykarpenko
Date: 2010-12-07 10:16:30 -0500 (Tue, 07 Dec 2010)
New Revision: 3612
Modified:
jcr/branches/1.12.x/exo.jcr.docs/exo.jcr.docs.developer/en/src/main/docbook/en-US/modules/jcr/other/acl.xml
Log:
JCR-1533: access control documentation updated
Modified: jcr/branches/1.12.x/exo.jcr.docs/exo.jcr.docs.developer/en/src/main/docbook/en-US/modules/jcr/other/acl.xml
===================================================================
--- jcr/branches/1.12.x/exo.jcr.docs/exo.jcr.docs.developer/en/src/main/docbook/en-US/modules/jcr/other/acl.xml 2010-12-07 13:55:13 UTC (rev 3611)
+++ jcr/branches/1.12.x/exo.jcr.docs/exo.jcr.docs.developer/en/src/main/docbook/en-US/modules/jcr/other/acl.xml 2010-12-07 15:16:30 UTC (rev 3612)
@@ -57,17 +57,26 @@
<para>For example :</para>
- <para>session.checkPermission("/Groups/organization",
- "add_node,set_property") will check if the session is allowed to add a
- child node to "organization" and to modify its properties. If one of the
- two permissions is denied, an AccessDeniedException is thrown.</para>
-
<itemizedlist>
<listitem>
+ <para>session.checkPermission("/Groups/organization",
+ "add_node,set_property") will check if the session is allowed to add a
+ child node to "organization" and to modify its properties. If one of
+ the two permissions is denied, an AccessDeniedException is
+ thrown.</para>
+ </listitem>
+
+ <listitem>
<para>session.checkPermission("/Groups/organization/exo:name",
"read,set_property") will check if the session is allowed to read and
change the "exo:name" property of the "organization" node.</para>
</listitem>
+
+ <listitem>
+ <para>session.checkPermission("/Groups/organization/exo:name",
+ "remove") will check if the session allowed to remove "exo:name"
+ property or node.</para>
+ </listitem>
</itemizedlist>
</section>
@@ -99,7 +108,7 @@
<itemizedlist>
<listitem>
<para><emphasis role="bold">any</emphasis> : represents any
- authenticated session. </para>
+ authenticated session.</para>
</listitem>
<listitem>
@@ -380,6 +389,69 @@
</imageobject>
</mediaobject>
</section>
+
+ <section>
+ <title>Permission validation</title>
+
+ <para>There is a description how permission is validated for different
+ jcr actions</para>
+
+ <itemizedlist>
+ <listitem>
+ <para><emphasis role="bold">read node</emphasis>: check read
+ permission on target node. </para>
+
+ <para>For example. Read /node1/<emphasis
+ role="bold">subnode</emphasis> node - jcr will check "read"
+ permission exactly on subnode.</para>
+ </listitem>
+
+ <listitem>
+ <para><emphasis role="bold">read property</emphasis> : check read
+ permission on parent node. </para>
+
+ <para>For example. Read /<emphasis
+ role="bold">node1</emphasis>/myprop - jcr will check "read"
+ permission on node1-node.</para>
+ </listitem>
+
+ <listitem>
+ <para><emphasis role="bold">add node</emphasis>: check add_node on
+ parent node</para>
+
+ <para>For example. Try to add /<emphasis
+ role="bold">node1</emphasis>/sybnode node - jcr will check
+ "add_node" permission on node1-node.</para>
+ </listitem>
+
+ <listitem>
+ <para><emphasis role="bold">set property</emphasis>: set_property
+ on parent node</para>
+
+ <para>For example. Try to set /<emphasis
+ role="bold">node1</emphasis>/myprop property - jcr will check
+ "set_property" permission on node1-node.</para>
+ </listitem>
+
+ <listitem>
+ <para><emphasis role="bold">remove node</emphasis>: check remove
+ permission on target node.</para>
+
+ <para>For example. Try to remove /node1/<emphasis
+ role="bold">subnode</emphasis> node - jcr will check "remove"
+ permission on subnode-node.</para>
+ </listitem>
+
+ <listitem>
+ <para><emphasis role="bold">remove property</emphasis>: check
+ remove permission on parent node</para>
+
+ <para>For example. Try to remove /<emphasis
+ role="bold">node1</emphasis>/myprop property - jcr will check
+ "remove" permission on node1-node.</para>
+ </listitem>
+ </itemizedlist>
+ </section>
</section>
<section>
15 years, 5 months
exo-jcr SVN: r3611 - in jcr/trunk/exo.jcr.component.webdav/src/main/java/org/exoplatform/services/jcr/webdav/command: dasl and 4 other directories.
by do-not-reply@jboss.org
Author: dkuleshov
Date: 2010-12-07 08:55:13 -0500 (Tue, 07 Dec 2010)
New Revision: 3611
Modified:
jcr/trunk/exo.jcr.component.webdav/src/main/java/org/exoplatform/services/jcr/webdav/command/LockCommand.java
jcr/trunk/exo.jcr.component.webdav/src/main/java/org/exoplatform/services/jcr/webdav/command/dasl/SearchResultResponseEntity.java
jcr/trunk/exo.jcr.component.webdav/src/main/java/org/exoplatform/services/jcr/webdav/command/deltav/report/VersionTreeResponseEntity.java
jcr/trunk/exo.jcr.component.webdav/src/main/java/org/exoplatform/services/jcr/webdav/command/order/OrderPatchResponseEntity.java
jcr/trunk/exo.jcr.component.webdav/src/main/java/org/exoplatform/services/jcr/webdav/command/propfind/PropFindResponseEntity.java
jcr/trunk/exo.jcr.component.webdav/src/main/java/org/exoplatform/services/jcr/webdav/command/proppatch/PropPatchResponseEntity.java
Log:
EXOJCR-1095: removed default namespace from response bodies
Modified: jcr/trunk/exo.jcr.component.webdav/src/main/java/org/exoplatform/services/jcr/webdav/command/LockCommand.java
===================================================================
--- jcr/trunk/exo.jcr.component.webdav/src/main/java/org/exoplatform/services/jcr/webdav/command/LockCommand.java 2010-12-07 13:51:45 UTC (rev 3610)
+++ jcr/trunk/exo.jcr.component.webdav/src/main/java/org/exoplatform/services/jcr/webdav/command/LockCommand.java 2010-12-07 13:55:13 UTC (rev 3611)
@@ -209,7 +209,6 @@
XMLStreamWriter xmlStreamWriter =
XMLOutputFactory.newInstance().createXMLStreamWriter(stream, Constants.DEFAULT_ENCODING);
xmlStreamWriter.setNamespaceContext(nsContext);
- xmlStreamWriter.setDefaultNamespace("DAV:");
xmlStreamWriter.writeStartDocument();
Modified: jcr/trunk/exo.jcr.component.webdav/src/main/java/org/exoplatform/services/jcr/webdav/command/dasl/SearchResultResponseEntity.java
===================================================================
--- jcr/trunk/exo.jcr.component.webdav/src/main/java/org/exoplatform/services/jcr/webdav/command/dasl/SearchResultResponseEntity.java 2010-12-07 13:51:45 UTC (rev 3610)
+++ jcr/trunk/exo.jcr.component.webdav/src/main/java/org/exoplatform/services/jcr/webdav/command/dasl/SearchResultResponseEntity.java 2010-12-07 13:55:13 UTC (rev 3611)
@@ -118,7 +118,6 @@
XMLOutputFactory.newInstance().createXMLStreamWriter(outStream, Constants.DEFAULT_ENCODING);
xmlStreamWriter.setNamespaceContext(nsContext);
- xmlStreamWriter.setDefaultNamespace("DAV:");
xmlStreamWriter.writeStartDocument();
xmlStreamWriter.writeStartElement("D", "multistatus", "DAV:");
Modified: jcr/trunk/exo.jcr.component.webdav/src/main/java/org/exoplatform/services/jcr/webdav/command/deltav/report/VersionTreeResponseEntity.java
===================================================================
--- jcr/trunk/exo.jcr.component.webdav/src/main/java/org/exoplatform/services/jcr/webdav/command/deltav/report/VersionTreeResponseEntity.java 2010-12-07 13:51:45 UTC (rev 3610)
+++ jcr/trunk/exo.jcr.component.webdav/src/main/java/org/exoplatform/services/jcr/webdav/command/deltav/report/VersionTreeResponseEntity.java 2010-12-07 13:55:13 UTC (rev 3611)
@@ -101,7 +101,6 @@
this.xmlStreamWriter =
XMLOutputFactory.newInstance().createXMLStreamWriter(outputStream, Constants.DEFAULT_ENCODING);
xmlStreamWriter.setNamespaceContext(namespaceContext);
- xmlStreamWriter.setDefaultNamespace("DAV:");
xmlStreamWriter.writeStartDocument();
xmlStreamWriter.writeStartElement("D", "multistatus", "DAV:");
Modified: jcr/trunk/exo.jcr.component.webdav/src/main/java/org/exoplatform/services/jcr/webdav/command/order/OrderPatchResponseEntity.java
===================================================================
--- jcr/trunk/exo.jcr.component.webdav/src/main/java/org/exoplatform/services/jcr/webdav/command/order/OrderPatchResponseEntity.java 2010-12-07 13:51:45 UTC (rev 3610)
+++ jcr/trunk/exo.jcr.component.webdav/src/main/java/org/exoplatform/services/jcr/webdav/command/order/OrderPatchResponseEntity.java 2010-12-07 13:55:13 UTC (rev 3611)
@@ -96,7 +96,6 @@
XMLStreamWriter xmlStreamWriter =
XMLOutputFactory.newInstance().createXMLStreamWriter(outputStream, Constants.DEFAULT_ENCODING);
xmlStreamWriter.setNamespaceContext(nsContext);
- xmlStreamWriter.setDefaultNamespace("DAV:");
xmlStreamWriter.writeStartDocument();
xmlStreamWriter.writeStartElement("D", "multistatus", "DAV:");
Modified: jcr/trunk/exo.jcr.component.webdav/src/main/java/org/exoplatform/services/jcr/webdav/command/propfind/PropFindResponseEntity.java
===================================================================
--- jcr/trunk/exo.jcr.component.webdav/src/main/java/org/exoplatform/services/jcr/webdav/command/propfind/PropFindResponseEntity.java 2010-12-07 13:51:45 UTC (rev 3610)
+++ jcr/trunk/exo.jcr.component.webdav/src/main/java/org/exoplatform/services/jcr/webdav/command/propfind/PropFindResponseEntity.java 2010-12-07 13:55:13 UTC (rev 3611)
@@ -132,7 +132,6 @@
this.xmlStreamWriter =
XMLOutputFactory.newInstance().createXMLStreamWriter(outputStream, Constants.DEFAULT_ENCODING);
xmlStreamWriter.setNamespaceContext(namespaceContext);
- xmlStreamWriter.setDefaultNamespace("DAV:");
xmlStreamWriter.writeStartDocument();
xmlStreamWriter.writeStartElement("D", "multistatus", "DAV:");
Modified: jcr/trunk/exo.jcr.component.webdav/src/main/java/org/exoplatform/services/jcr/webdav/command/proppatch/PropPatchResponseEntity.java
===================================================================
--- jcr/trunk/exo.jcr.component.webdav/src/main/java/org/exoplatform/services/jcr/webdav/command/proppatch/PropPatchResponseEntity.java 2010-12-07 13:51:45 UTC (rev 3610)
+++ jcr/trunk/exo.jcr.component.webdav/src/main/java/org/exoplatform/services/jcr/webdav/command/proppatch/PropPatchResponseEntity.java 2010-12-07 13:55:13 UTC (rev 3611)
@@ -146,7 +146,6 @@
XMLOutputFactory.newInstance().createXMLStreamWriter(outStream, Constants.DEFAULT_ENCODING);
xmlStreamWriter.setNamespaceContext(nsContext);
- xmlStreamWriter.setDefaultNamespace("DAV:");
xmlStreamWriter.writeStartDocument();
xmlStreamWriter.writeStartElement("D", "multistatus", "DAV:");
15 years, 5 months
exo-jcr SVN: r3610 - in ws/trunk/exo.ws.rest.ext/src: test/java/org/exoplatform/services/rest/ext/filter and 1 other directory.
by do-not-reply@jboss.org
Author: dkuleshov
Date: 2010-12-07 08:51:45 -0500 (Tue, 07 Dec 2010)
New Revision: 3610
Added:
ws/trunk/exo.ws.rest.ext/src/test/java/org/exoplatform/services/rest/ext/filter/HierarchicalPropertyEntityProviderTest.java
Modified:
ws/trunk/exo.ws.rest.ext/src/main/java/org/exoplatform/services/rest/ext/provider/HierarchicalPropertyEntityProvider.java
Log:
EXOJCR-1095: from now filteredReader is used instead of reader while parsing request XML body
Modified: ws/trunk/exo.ws.rest.ext/src/main/java/org/exoplatform/services/rest/ext/provider/HierarchicalPropertyEntityProvider.java
===================================================================
--- ws/trunk/exo.ws.rest.ext/src/main/java/org/exoplatform/services/rest/ext/provider/HierarchicalPropertyEntityProvider.java 2010-12-07 13:33:22 UTC (rev 3609)
+++ ws/trunk/exo.ws.rest.ext/src/main/java/org/exoplatform/services/rest/ext/provider/HierarchicalPropertyEntityProvider.java 2010-12-07 13:51:45 UTC (rev 3610)
@@ -29,16 +29,18 @@
import java.io.OutputStream;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
-import java.util.Stack;
+import java.util.LinkedList;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.MultivaluedMap;
import javax.xml.namespace.QName;
+import javax.xml.stream.EventFilter;
import javax.xml.stream.FactoryConfigurationError;
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.events.Characters;
import javax.xml.stream.events.StartElement;
import javax.xml.stream.events.XMLEvent;
import javax.xml.transform.TransformerException;
@@ -77,33 +79,41 @@
WebApplicationException
{
HierarchicalProperty rootProperty = null;
- Stack<HierarchicalProperty> curProperty = new Stack<HierarchicalProperty>();
+ LinkedList<HierarchicalProperty> curProperty = new LinkedList<HierarchicalProperty>();
try
{
XMLInputFactory factory = XMLInputFactory.newInstance();
XMLEventReader reader = factory.createXMLEventReader(entityStream);
- while (reader.hasNext())
+ XMLEventReader fReader = factory.createFilteredReader(reader, new EventFilter()
{
- XMLEvent event = reader.nextEvent();
+
+ public boolean accept(XMLEvent event)
+ {
+ return !(event.isCharacters() && ((Characters)event).isWhiteSpace());
+ }
+ });
+ while (fReader.hasNext())
+ {
+ XMLEvent event = fReader.nextEvent();
switch (event.getEventType())
{
case XMLEvent.START_ELEMENT :
StartElement element = event.asStartElement();
QName name = element.getName();
HierarchicalProperty prop = new HierarchicalProperty(name);
- if (!curProperty.empty())
- curProperty.peek().addChild(prop);
+ if (!curProperty.isEmpty())
+ curProperty.getLast().addChild(prop);
else
rootProperty = prop;
- curProperty.push(prop);
+ curProperty.addLast(prop);
break;
case XMLEvent.END_ELEMENT :
- curProperty.pop();
+ curProperty.removeLast();
break;
case XMLEvent.CHARACTERS :
String chars = event.asCharacters().getData();
- curProperty.peek().setValue(chars);
+ curProperty.getLast().setValue(chars);
break;
default :
break;
@@ -119,9 +129,23 @@
catch (XMLStreamException e)
{
if (LOG.isDebugEnabled())
- e.printStackTrace();
+ LOG.debug("An XMLStreamException occurs", e);
return null;
}
+ catch (RuntimeException re)
+ {
+ String reName = re.getClass().getName();
+ if (reName.equals("com.ctc.wstx.exc.WstxLazyException"))
+ {
+ if (LOG.isDebugEnabled())
+ LOG.error(re.getMessage(), re);
+ return null;
+ }
+ else
+ {
+ throw re;
+ }
+ }
}
/**
Added: ws/trunk/exo.ws.rest.ext/src/test/java/org/exoplatform/services/rest/ext/filter/HierarchicalPropertyEntityProviderTest.java
===================================================================
--- ws/trunk/exo.ws.rest.ext/src/test/java/org/exoplatform/services/rest/ext/filter/HierarchicalPropertyEntityProviderTest.java (rev 0)
+++ ws/trunk/exo.ws.rest.ext/src/test/java/org/exoplatform/services/rest/ext/filter/HierarchicalPropertyEntityProviderTest.java 2010-12-07 13:51:45 UTC (rev 3610)
@@ -0,0 +1,21 @@
+package org.exoplatform.services.rest.ext.filter;
+
+import junit.framework.TestCase;
+
+import org.exoplatform.common.util.HierarchicalProperty;
+import org.exoplatform.services.rest.ext.provider.HierarchicalPropertyEntityProvider;
+
+import java.io.ByteArrayInputStream;
+
+public class HierarchicalPropertyEntityProviderTest extends TestCase
+{
+ public void testRequestBodyXMLParsing() throws Exception
+ {
+ String s = "\n<root>\n <l1>\n\t<l2>hel\nlo</l2>\n </l1> \n</root>\n";
+ System.out.println(s);
+ HierarchicalProperty hp =
+ new HierarchicalPropertyEntityProvider().readFrom(HierarchicalProperty.class, null, null, null, null,
+ new ByteArrayInputStream(s.getBytes()));
+ assertTrue(hp.getChild(0).getChild(0).getValue().equals("hel\nlo"));
+ }
+}
\ No newline at end of file
Property changes on: ws/trunk/exo.ws.rest.ext/src/test/java/org/exoplatform/services/rest/ext/filter/HierarchicalPropertyEntityProviderTest.java
___________________________________________________________________
Name: svn:eol-style
+ native
15 years, 5 months