Author: tolusha Date: 2011-01-26 11:19:28 -0500 (Wed, 26 Jan 2011) New Revision: 3891 Added: jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/JobExistedRepositoryRestoreSameConfig.java jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/JobExistedWorkspaceRestoreSameConfig.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/impl/BackupManagerImpl.java jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/JobExistedRepositoryRestore.java jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/JobExistedWorkspaceRestore.java jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/JobRepositoryRestore.java jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/JobWorkspaceRestore.java jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/fs/IncrementalBackupJob.java jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/rdbms/FullBackupJob.java jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/rdbms/RdbmsBackupWorkspaceInitializer.java jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/rdbms/RdbmsWorkspaceInitializer.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/AbstractBackupUseCasesTest.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/backup/load/TestLoadBackup.java jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/server/HTTPBackupAgentTest.java jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/impl/core/TesterRdbmsWorkspaceInitializer.java Log: EXOJCR-1153: Support atomic restore EXOJCR-1147: Make backup/restore to be cluster aware Modified: jcr/trunk/exo.jcr.component.ext/pom.xml =================================================================== --- jcr/trunk/exo.jcr.component.ext/pom.xml 2011-01-26 16:18:11 UTC (rev 3890) +++ jcr/trunk/exo.jcr.component.ext/pom.xml 2011-01-26 16:19:28 UTC (rev 3891) @@ -1,192 +1,192 @@ -<?xml version="1.0" encoding="UTF-8"?> -<!-- - - 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.jcr</groupId> - <artifactId>jcr-parent</artifactId> - <version>1.14.0-CR1-SNAPSHOT</version> - </parent> - <artifactId>exo.jcr.component.ext</artifactId> - <name>eXo JCR :: Component :: Extension Service</name> - <description>eXo JCR Services extension</description> - <dependencies> - <dependency> - <groupId>org.exoplatform.kernel</groupId> - <artifactId>exo.kernel.commons</artifactId> - </dependency> - <dependency> - <groupId>org.exoplatform.kernel</groupId> - <artifactId>exo.kernel.container</artifactId> - </dependency> - <dependency> - <groupId>org.exoplatform.kernel</groupId> - <artifactId>exo.kernel.component.command</artifactId> - </dependency> - <dependency> - <groupId>org.exoplatform.kernel</groupId> - <artifactId>exo.kernel.commons.test</artifactId> - </dependency> - <dependency> - <groupId>org.exoplatform.core</groupId> - <artifactId>exo.core.component.database</artifactId> - </dependency> - <dependency> - <groupId>org.exoplatform.core</groupId> - <artifactId>exo.core.component.document</artifactId> - </dependency> - <dependency> - <groupId>org.exoplatform.core</groupId> - <artifactId>exo.core.component.organization.api</artifactId> - </dependency> - <dependency> - <groupId>org.exoplatform.core</groupId> - <artifactId>exo.core.component.security.core</artifactId> - </dependency> - <dependency> - <groupId>org.exoplatform.jcr</groupId> - <artifactId>exo.jcr.component.core</artifactId> - <exclusions> - <exclusion> - <groupId>xerces</groupId> - <artifactId>xerces</artifactId> - </exclusion> - </exclusions> - </dependency> - <dependency> - <groupId>org.exoplatform.core</groupId> - <artifactId>exo.core.component.script.groovy</artifactId> - </dependency> - <dependency> - <groupId>org.exoplatform.ws</groupId> - <artifactId>exo.ws.rest.core</artifactId> - </dependency> - <dependency> - <groupId>org.exoplatform.ws</groupId> - <artifactId>exo.ws.rest.ext</artifactId> - </dependency> - <dependency> - <groupId>org.exoplatform.ws</groupId> - <artifactId>exo.ws.commons</artifactId> - </dependency> - <dependency> - <groupId>org.exoplatform.ws</groupId> - <artifactId>exo.ws.frameworks.json</artifactId> - </dependency> - <dependency> - <groupId>javax.jcr</groupId> - <artifactId>jcr</artifactId> - </dependency> - <dependency> - <groupId>org.slf4j</groupId> - <artifactId>slf4j-log4j12</artifactId> - </dependency> - <dependency> - <groupId>javax.annotation</groupId> - <artifactId>jsr250-api</artifactId> - </dependency> - <dependency> - <groupId>commons-chain</groupId> - <artifactId>commons-chain</artifactId> - </dependency> - <dependency> - <groupId>org.jgroups</groupId> - <artifactId>jgroups</artifactId> - </dependency> - <dependency> - <groupId>javax.ws.rs</groupId> - <artifactId>jsr311-api</artifactId> - </dependency> - <dependency> - <groupId>commons-fileupload</groupId> - <artifactId>commons-fileupload</artifactId> - </dependency> - <dependency> - <groupId>picocontainer</groupId> - <artifactId>picocontainer</artifactId> - </dependency> - <dependency> - <groupId>xml-apis</groupId> - <artifactId>xml-apis</artifactId> - </dependency> - <dependency> - <groupId>javax.xml.stream</groupId> - <artifactId>stax-api</artifactId> - </dependency> - <dependency> - <groupId>commons-collections</groupId> - <artifactId>commons-collections</artifactId> - </dependency> - - <dependency> - <groupId>hsqldb</groupId> - <artifactId>hsqldb</artifactId> - <scope>test</scope> - </dependency> - </dependencies> - - <build> - <testResources> - <testResource> - <directory>src/test/resources</directory> - <includes> - <include>**/*.pdf</include> - <include>**/*.xml</include> - <include>**/*.xls</include> - <include>**/*.groovy</include> - <include>**/login.conf</include> - </includes> - </testResource> - </testResources> - <plugins> - <plugin> - <groupId>org.apache.maven.plugins</groupId> - <artifactId>maven-jar-plugin</artifactId> - <configuration> - <archive> - <manifest> - <addClasspath>true</addClasspath> - </manifest> - </archive> - </configuration> - </plugin> - <plugin> - <groupId>org.apache.maven.plugins</groupId> - <artifactId>maven-surefire-plugin</artifactId> - <configuration> - <argLine>${env.MAVEN_OPTS} -Djava.security.manager=org.exoplatform.commons.test.TestSecurityManager -Djava.security.policy=${project.build.directory}/test-classes/test.policy</argLine> - <includes> - <include>**/actions/*Test.java</include> - <include>**/metadata/*Test.java</include> - <include>**/owner/*Test.java</include> - <include>**/registry/*Test.java</include> - <include>**/app/*Test.java</include> - <include>**/resource/*Test.java</include> - <include>**/groovy/*Test.java</include> - <include>**/replication/*.java</include> - <include>**/replication/external/*.java</include> - <include>**/replication/async/**/*.java</include> +<?xml version="1.0" encoding="UTF-8"?> +<!-- + + 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.jcr</groupId> + <artifactId>jcr-parent</artifactId> + <version>1.14.0-CR1-SNAPSHOT</version> + </parent> + <artifactId>exo.jcr.component.ext</artifactId> + <name>eXo JCR :: Component :: Extension Service</name> + <description>eXo JCR Services extension</description> + <dependencies> + <dependency> + <groupId>org.exoplatform.kernel</groupId> + <artifactId>exo.kernel.commons</artifactId> + </dependency> + <dependency> + <groupId>org.exoplatform.kernel</groupId> + <artifactId>exo.kernel.container</artifactId> + </dependency> + <dependency> + <groupId>org.exoplatform.kernel</groupId> + <artifactId>exo.kernel.component.command</artifactId> + </dependency> + <dependency> + <groupId>org.exoplatform.kernel</groupId> + <artifactId>exo.kernel.commons.test</artifactId> + </dependency> + <dependency> + <groupId>org.exoplatform.core</groupId> + <artifactId>exo.core.component.database</artifactId> + </dependency> + <dependency> + <groupId>org.exoplatform.core</groupId> + <artifactId>exo.core.component.document</artifactId> + </dependency> + <dependency> + <groupId>org.exoplatform.core</groupId> + <artifactId>exo.core.component.organization.api</artifactId> + </dependency> + <dependency> + <groupId>org.exoplatform.core</groupId> + <artifactId>exo.core.component.security.core</artifactId> + </dependency> + <dependency> + <groupId>org.exoplatform.jcr</groupId> + <artifactId>exo.jcr.component.core</artifactId> + <exclusions> + <exclusion> + <groupId>xerces</groupId> + <artifactId>xerces</artifactId> + </exclusion> + </exclusions> + </dependency> + <dependency> + <groupId>org.exoplatform.core</groupId> + <artifactId>exo.core.component.script.groovy</artifactId> + </dependency> + <dependency> + <groupId>org.exoplatform.ws</groupId> + <artifactId>exo.ws.rest.core</artifactId> + </dependency> + <dependency> + <groupId>org.exoplatform.ws</groupId> + <artifactId>exo.ws.rest.ext</artifactId> + </dependency> + <dependency> + <groupId>org.exoplatform.ws</groupId> + <artifactId>exo.ws.commons</artifactId> + </dependency> + <dependency> + <groupId>org.exoplatform.ws</groupId> + <artifactId>exo.ws.frameworks.json</artifactId> + </dependency> + <dependency> + <groupId>javax.jcr</groupId> + <artifactId>jcr</artifactId> + </dependency> + <dependency> + <groupId>org.slf4j</groupId> + <artifactId>slf4j-log4j12</artifactId> + </dependency> + <dependency> + <groupId>javax.annotation</groupId> + <artifactId>jsr250-api</artifactId> + </dependency> + <dependency> + <groupId>commons-chain</groupId> + <artifactId>commons-chain</artifactId> + </dependency> + <dependency> + <groupId>org.jgroups</groupId> + <artifactId>jgroups</artifactId> + </dependency> + <dependency> + <groupId>javax.ws.rs</groupId> + <artifactId>jsr311-api</artifactId> + </dependency> + <dependency> + <groupId>commons-fileupload</groupId> + <artifactId>commons-fileupload</artifactId> + </dependency> + <dependency> + <groupId>picocontainer</groupId> + <artifactId>picocontainer</artifactId> + </dependency> + <dependency> + <groupId>xml-apis</groupId> + <artifactId>xml-apis</artifactId> + </dependency> + <dependency> + <groupId>javax.xml.stream</groupId> + <artifactId>stax-api</artifactId> + </dependency> + <dependency> + <groupId>commons-collections</groupId> + <artifactId>commons-collections</artifactId> + </dependency> + <dependency> + <groupId>hsqldb</groupId> + <artifactId>hsqldb</artifactId> + <scope>test</scope> + </dependency> + </dependencies> + + <build> + <testResources> + <testResource> + <directory>src/test/resources</directory> + <includes> + <include>**/*.pdf</include> + <include>**/*.xml</include> + <include>**/*.xls</include> + <include>**/*.groovy</include> + <include>**/login.conf</include> + </includes> + </testResource> + </testResources> + <plugins> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-jar-plugin</artifactId> + <configuration> + <archive> + <manifest> + <addClasspath>true</addClasspath> + </manifest> + </archive> + </configuration> + </plugin> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-surefire-plugin</artifactId> + <configuration> + <argLine>${env.MAVEN_OPTS} -Djava.security.manager=org.exoplatform.commons.test.TestSecurityManager -Djava.security.policy=${project.build.directory}/test-classes/test.policy</argLine> + <includes> + <include>**/actions/*Test.java</include> + <include>**/metadata/*Test.java</include> + <include>**/owner/*Test.java</include> + <include>**/registry/*Test.java</include> + <include>**/app/*Test.java</include> + <include>**/resource/*Test.java</include> + <include>**/groovy/*Test.java</include> + <include>**/replication/*.java</include> + <include>**/replication/external/*.java</include> + <include>**/replication/async/**/*.java</include> + <include>**/backup/load/TestLoadBackup.java</include> <include>**/backup/*.java</include> - <include>**/backup/server/*.java</include> + <include>**/backup/server/*.java</include> </includes> <excludes> <exclude>**/BaseStandaloneTest.java</exclude> 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 2011-01-26 16:18:11 UTC (rev 3890) +++ jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/BackupManagerImpl.java 2011-01-26 16:19:28 UTC (rev 3891) @@ -31,12 +31,6 @@ import org.exoplatform.services.jcr.config.WorkspaceEntry; import org.exoplatform.services.jcr.config.WorkspaceInitializerEntry; import org.exoplatform.services.jcr.core.WorkspaceContainerFacade; -import org.exoplatform.services.jcr.dataflow.ChangesLogIterator; -import org.exoplatform.services.jcr.dataflow.ItemState; -import org.exoplatform.services.jcr.dataflow.PlainChangesLog; -import org.exoplatform.services.jcr.dataflow.PlainChangesLogImpl; -import org.exoplatform.services.jcr.dataflow.TransactionChangesLog; -import org.exoplatform.services.jcr.datamodel.ItemData; import org.exoplatform.services.jcr.ext.backup.BackupChain; import org.exoplatform.services.jcr.ext.backup.BackupChainLog; import org.exoplatform.services.jcr.ext.backup.BackupConfig; @@ -57,32 +51,26 @@ 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.backup.JCRRestor; import org.exoplatform.services.jcr.impl.core.RepositoryImpl; -import org.exoplatform.services.jcr.impl.core.SessionImpl; import org.exoplatform.services.jcr.impl.core.SysViewWorkspaceInitializer; import org.exoplatform.services.jcr.impl.dataflow.persistent.WorkspacePersistentDataManager; -import org.exoplatform.services.jcr.impl.storage.JCRInvalidItemStateException; -import org.exoplatform.services.jcr.impl.storage.JCRItemExistsException; import org.exoplatform.services.jcr.impl.util.io.FileCleaner; -import org.exoplatform.services.jcr.impl.util.io.SpoolFile; -import org.exoplatform.services.jcr.observation.ExtendedEvent; import org.exoplatform.services.jcr.util.IdGenerator; import org.exoplatform.services.log.ExoLogger; import org.exoplatform.services.log.Log; +import org.exoplatform.ws.frameworks.json.impl.JsonException; +import org.exoplatform.ws.frameworks.json.impl.JsonGeneratorImpl; import org.picocontainer.Startable; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.xml.sax.SAXException; import java.io.ByteArrayOutputStream; -import java.io.EOFException; import java.io.File; import java.io.FileFilter; import java.io.FileNotFoundException; -import java.io.FileOutputStream; import java.io.IOException; -import java.io.ObjectInputStream; import java.io.PrintWriter; import java.security.PrivilegedExceptionAction; import java.util.ArrayList; @@ -949,211 +937,14 @@ throws RepositoryException, RepositoryConfigurationException, BackupOperationException, FileNotFoundException, IOException, ClassNotFoundException { - SessionImpl sesion = (SessionImpl)repoService.getRepository(repositoryName).getSystemSession(workspaceName); WorkspacePersistentDataManager dataManager = - (WorkspacePersistentDataManager)sesion.getContainer().getComponentInstanceOfType( - WorkspacePersistentDataManager.class); + (WorkspacePersistentDataManager)repoService.getRepository(repositoryName).getWorkspaceContainer(workspaceName) + .getComponent(WorkspacePersistentDataManager.class); - ObjectInputStream ois = null; - File backupFile = null; - try - { - backupFile = new File(pathBackupFile); - ois = new ObjectInputStream(PrivilegedFileHelper.fileInputStream(backupFile)); - - while (true) - { - TransactionChangesLog changesLog = readExternal(ois); - - ChangesLogIterator cli = changesLog.getLogIterator(); - while (cli.hasNextLog()) - { - if (cli.nextLog().getEventType() == ExtendedEvent.LOCK) - cli.removeLog(); - } - - saveChangesLog(dataManager, changesLog); - } - } - catch (EOFException ioe) - { - // ok - reading all data from backup file; - } - finally - { - if (sesion != null) - sesion.logout(); - } + JCRRestor restorer = new JCRRestor(dataManager, fileCleaner); + restorer.incrementalRestore(new File(pathBackupFile)); } - private void saveChangesLog(WorkspacePersistentDataManager dataManager, TransactionChangesLog changesLog) - throws RepositoryException, BackupOperationException - { - try - { - dataManager.save(changesLog); - } - catch (JCRInvalidItemStateException e) - { - TransactionChangesLog normalizeChangesLog = - getNormalizedChangesLog(e.getIdentifier(), e.getState(), changesLog); - if (normalizeChangesLog != null) - saveChangesLog(dataManager, normalizeChangesLog); - else - throw new BackupOperationException( - "Collisions found during save of restore changes log, but caused item is not found by ID " - + e.getIdentifier() + ". " + e, e); - } - catch (JCRItemExistsException e) - { - TransactionChangesLog normalizeChangesLog = - getNormalizedChangesLog(e.getIdentifier(), e.getState(), changesLog); - if (normalizeChangesLog != null) - saveChangesLog(dataManager, normalizeChangesLog); - else - throw new RepositoryException( - "Collisions found during save of restore changes log, but caused item is not found by ID " - + e.getIdentifier() + ". " + e, e); - } - - } - - private TransactionChangesLog getNormalizedChangesLog(String collisionID, int state, TransactionChangesLog changesLog) - { - ItemState citem = changesLog.getItemState(collisionID); - - if (citem != null) - { - - TransactionChangesLog result = new TransactionChangesLog(); - result.setSystemId(changesLog.getSystemId()); - - ChangesLogIterator cli = changesLog.getLogIterator(); - while (cli.hasNextLog()) - { - ArrayList<ItemState> normalized = new ArrayList<ItemState>(); - PlainChangesLog next = cli.nextLog(); - for (ItemState change : next.getAllStates()) - { - if (state == change.getState()) - { - ItemData item = change.getData(); - // targeted state - if (citem.isNode()) - { - // Node... by ID and desc path - if (!item.getIdentifier().equals(collisionID) - && !item.getQPath().isDescendantOf(citem.getData().getQPath())) - normalized.add(change); - } - else if (!item.getIdentifier().equals(collisionID)) - { - // Property... by ID - normalized.add(change); - } - } - else - // another state - normalized.add(change); - } - - PlainChangesLog plog = new PlainChangesLogImpl(normalized, next.getSessionId(), next.getEventType()); - result.addLog(plog); - } - - return result; - } - - return null; - } - - private TransactionChangesLog readExternal(ObjectInputStream in) throws IOException, ClassNotFoundException - { - int changesLogType = in.readInt(); - - TransactionChangesLog transactionChangesLog = null; - - if (changesLogType == PendingChangesLog.Type.CHANGESLOG_WITH_STREAM) - { - - // read ChangesLog - transactionChangesLog = (TransactionChangesLog)in.readObject(); - - // read FixupStream count - int iFixupStream = in.readInt(); - - ArrayList<FixupStream> listFixupStreams = new ArrayList<FixupStream>(); - - for (int i = 0; i < iFixupStream; i++) - { - FixupStream fs = new FixupStream(); - fs.readExternal(in); - listFixupStreams.add(fs); - } - // listFixupStreams.add((FixupStream) in.readObject()); - - // read stream data - int iStreamCount = in.readInt(); - ArrayList<File> listFiles = new ArrayList<File>(); - - for (int i = 0; i < iStreamCount; i++) - { - - // read file size - long fileSize = in.readLong(); - - // read content file - File contentFile = getAsFile(in, fileSize); - listFiles.add(contentFile); - } - - PendingChangesLog pendingChangesLog = - new PendingChangesLog(transactionChangesLog, listFixupStreams, listFiles, fileCleaner); - - pendingChangesLog.restore(); - - TransactionChangesLog log = pendingChangesLog.getItemDataChangesLog(); - - } - else if (changesLogType == PendingChangesLog.Type.CHANGESLOG_WITHOUT_STREAM) - { - transactionChangesLog = (TransactionChangesLog)in.readObject(); - } - - return transactionChangesLog; - } - - private File getAsFile(ObjectInputStream ois, long fileSize) throws IOException - { - int bufferSize = /* 8191 */1024 * 8; - byte[] buf = new byte[bufferSize]; - - File tempFile = SpoolFile.createTempFile("" + System.currentTimeMillis(), ".stmp", tempDir); - FileOutputStream fos = PrivilegedFileHelper.fileOutputStream(tempFile); - long readBytes = fileSize; - - while (readBytes > 0) - { - // long longTemp = readByte - bufferSize; - if (readBytes >= bufferSize) - { - ois.readFully(buf); - fos.write(buf); - } - else if (readBytes < bufferSize) - { - ois.readFully(buf, 0, (int)readBytes); - fos.write(buf, 0, (int)readBytes); - } - readBytes -= bufferSize; - } - - fos.flush(); - fos.close(); - - return tempFile; - } - /** * Write parameters to RegistryService. * @@ -1695,7 +1486,7 @@ * {@inheritDoc} */ public void restoreExistingRepository(RepositoryBackupChainLog rblog, RepositoryEntry repositoryEntry, - boolean asynchronous) throws BackupOperationException, BackupConfigurationException + boolean asynchronous) throws BackupOperationException, BackupConfigurationException { try { @@ -1748,9 +1539,48 @@ } } - JobExistedRepositoryRestore jobExistedRepositoryRestore = - new JobExistedRepositoryRestore(repoService, this, repositoryEntry, workspacesMapping, rblog); + // check if need to restore with same configuration or not + boolean isSameConfig = false; + try + { + String newConf = new JsonGeneratorImpl().createJsonObject(repositoryEntry).toString(); + String currnetConf = + new JsonGeneratorImpl().createJsonObject( + repoService.getRepository(repositoryEntry.getName()).getConfiguration()).toString(); + isSameConfig = newConf.equals(currnetConf); + } + catch (JsonException e) + { + this.log.error("Can't get JSON object from wokrspace configuration", e); + } + catch (RepositoryException e) + { + this.log.error(e); + } + catch (RepositoryConfigurationException e) + { + this.log.error(e); + } + + // check if we have deal with RDBMS backup + boolean isRDBMSBackup = false; + try + { + isRDBMSBackup = + (Class.forName(workspacesMapping.get(repositoryEntry.getWorkspaceEntries().get(0).getName()) + .getFullBackupType()).equals(org.exoplatform.services.jcr.ext.backup.impl.rdbms.FullBackupJob.class)); + } + catch (ClassNotFoundException e) + { + this.log.error(e); + } + + JobRepositoryRestore jobExistedRepositoryRestore = + isSameConfig && isRDBMSBackup ? new JobExistedRepositoryRestoreSameConfig(repoService, this, repositoryEntry, + workspacesMapping, rblog) : new JobExistedRepositoryRestore(repoService, this, repositoryEntry, + workspacesMapping, rblog); + restoreRepositoryJobs.add(jobExistedRepositoryRestore); if (asynchronous) { @@ -1760,7 +1590,6 @@ { jobExistedRepositoryRestore.restore(); } - } /** @@ -1793,7 +1622,7 @@ * {@inheritDoc} */ public void restoreExistingWorkspace(BackupChainLog log, String repositoryName, WorkspaceEntry workspaceEntry, - boolean asynchronous) throws BackupOperationException, BackupConfigurationException + boolean asynchronous) throws BackupOperationException, BackupConfigurationException { try { @@ -1814,20 +1643,73 @@ { throw new WorkspaceRestoreException("Repository \"" + repositoryName + "\" should be existed", e); } - - JobExistedWorkspaceRestore jobRestore = - new JobExistedWorkspaceRestore(repoService, this, repositoryName, log, workspaceEntry); + + // check if need to restore with same configuration or not + boolean isSameConfig = false; + try + { + WorkspaceEntry currentWsEntry = null; + for (WorkspaceEntry wsEntry : repoService.getRepository(repositoryName).getConfiguration().getWorkspaceEntries()) + { + if (wsEntry.getName().equals(workspaceEntry.getName())) + { + currentWsEntry = wsEntry; + break; + } + } + + String newConf = new JsonGeneratorImpl().createJsonObject(workspaceEntry).toString(); + String currnetConf = new JsonGeneratorImpl().createJsonObject(currentWsEntry).toString(); + + isSameConfig = newConf.equals(currnetConf); + } + catch (JsonException e) + { + this.log.error("Can't get JSON object from wokrspace configuration", e); + } + catch (RepositoryException e) + { + this.log.error(e); + } + catch (RepositoryConfigurationException e) + { + this.log.error(e); + } + + // check if we have deal with RDBMS backup + boolean isRDBMSBackup = false; + try + { + isRDBMSBackup = + (Class.forName(log.getFullBackupType()) + .equals(org.exoplatform.services.jcr.ext.backup.impl.rdbms.FullBackupJob.class)); + } + catch (ClassNotFoundException e) + { + this.log.error(e); + } + + JobWorkspaceRestore jobRestore = + isSameConfig && isRDBMSBackup ? new JobExistedWorkspaceRestoreSameConfig(repoService, this, repositoryName, + log, workspaceEntry) : new JobExistedWorkspaceRestore(repoService, this, repositoryName, log, + workspaceEntry); restoreJobs.add(jobRestore); - + if (asynchronous) { jobRestore.start(); } else { - jobRestore.restore(); + try + { + jobRestore.restore(); + } + catch (Throwable e) + { + throw new BackupOperationException(e); + } } - } /** Modified: jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/JobExistedRepositoryRestore.java =================================================================== --- jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/JobExistedRepositoryRestore.java 2011-01-26 16:18:11 UTC (rev 3890) +++ jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/JobExistedRepositoryRestore.java 2011-01-26 16:19:28 UTC (rev 3891) @@ -26,9 +26,8 @@ import org.exoplatform.services.jcr.ext.backup.RepositoryBackupChainLog; import org.exoplatform.services.jcr.ext.backup.RepositoryRestoreExeption; import org.exoplatform.services.jcr.impl.RepositoryServiceImpl; +import org.exoplatform.services.jcr.impl.backup.Backupable; import org.exoplatform.services.jcr.impl.core.SessionRegistry; -import org.exoplatform.services.jcr.impl.storage.jdbc.backup.Backupable; -import org.exoplatform.services.jcr.impl.storage.jdbc.backup.DataCleaner; import java.util.ArrayList; import java.util.List; @@ -48,16 +47,6 @@ { /** - * Value storage cleaner. - */ - private final ValueStorageCleanHelper valueStorageCleanHelper; - - /** - * Index storage cleaner. - */ - private final IndexCleanHelper indexCleanHelper; - - /** * JobExistedRepositoryRestore constructor. */ public JobExistedRepositoryRestore(RepositoryService repoService, BackupManagerImpl backupManagerImpl, @@ -65,9 +54,6 @@ RepositoryBackupChainLog backupChainLog) { super(repoService, backupManagerImpl, repositoryEntry, workspacesMapping, backupChainLog); - - this.valueStorageCleanHelper = new ValueStorageCleanHelper(); - this.indexCleanHelper = new IndexCleanHelper(); } @Override @@ -76,6 +62,9 @@ */ protected void restoreRepository() throws RepositoryRestoreExeption { + // list of components to clean + List<Backupable> backupable = new ArrayList<Backupable>(); + try { // get current repository configuration @@ -91,32 +80,24 @@ boolean isDefault = repositoryService.getDefaultRepository().getConfiguration().getName().equals(repositoryEntry.getName()); + String systemWsName = + repositoryService.getRepository(this.repositoryEntry.getName()).getConfiguration().getSystemWorkspaceName(); + //Create local copy of WorkspaceEntry for all workspaces ArrayList<WorkspaceEntry> workspaceList = new ArrayList<WorkspaceEntry>(); workspaceList.addAll(repositoryEntry.getWorkspaceEntries()); - //close all session + // get all backupable components for (WorkspaceEntry wEntry : workspaceList) { - forceCloseSession(repositoryEntry.getName(), wEntry.getName()); + backupable.addAll(repositoryService.getRepository(this.repositoryEntry.getName()) + .getWorkspaceContainer(wEntry.getName()).getComponentInstancesOfType(Backupable.class)); } - List<DataCleaner> dataCleaners = new ArrayList<DataCleaner>(); - - // collect all DataCleaners + //close all session for (WorkspaceEntry wEntry : workspaceList) { forceCloseSession(repositoryEntry.getName(), wEntry.getName()); - - List<Backupable> backupable = - repositoryService.getRepository(this.repositoryEntry.getName()).getWorkspaceContainer(wEntry.getName()) - .getComponentInstancesOfType(Backupable.class); - - - for (Backupable component : backupable) - { - dataCleaners.add(component.getDataCleaner()); - } } //remove repository @@ -129,25 +110,12 @@ repositoryService.removeRepository(repositoryEntry.getName()); } - //clean database - for (DataCleaner cleaner : dataCleaners) + // clean + for (Backupable component : backupable) { - cleaner.clean(); + component.clean(); } - //clean index - for (WorkspaceEntry wEntry : workspaceList) - { - indexCleanHelper.removeWorkspaceIndex(wEntry, - repositoryEntry.getSystemWorkspaceName().equals(wEntry.getName())); - } - - //clean value storage - for (WorkspaceEntry wEntry : workspaceList) - { - valueStorageCleanHelper.removeWorkspaceValueStorage(wEntry); - } - super.restoreRepository(); } catch (Throwable t) @@ -157,7 +125,16 @@ } /** - * forceCloseSession. Close sessions on specific workspace. + * {@inheritDoc} + */ + @Override + protected void removeRepository(RepositoryService repositoryService, String repositoryName) + throws RepositoryException, RepositoryConfigurationException + { + } + + /** + * Close sessions on specific workspace. * * @param repositoryName * repository name @@ -179,5 +156,4 @@ return sessionRegistry.closeSessions(workspaceName); } - } Added: jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/JobExistedRepositoryRestoreSameConfig.java =================================================================== --- jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/JobExistedRepositoryRestoreSameConfig.java (rev 0) +++ jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/JobExistedRepositoryRestoreSameConfig.java 2011-01-26 16:19:28 UTC (rev 3891) @@ -0,0 +1,236 @@ +/* + * 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.impl; + +import org.exoplatform.commons.utils.SecurityHelper; +import org.exoplatform.services.jcr.RepositoryService; +import org.exoplatform.services.jcr.config.RepositoryEntry; +import org.exoplatform.services.jcr.config.WorkspaceEntry; +import org.exoplatform.services.jcr.dataflow.DataManager; +import org.exoplatform.services.jcr.ext.backup.BackupChainLog; +import org.exoplatform.services.jcr.ext.backup.RepositoryBackupChainLog; +import org.exoplatform.services.jcr.ext.backup.RepositoryRestoreExeption; +import org.exoplatform.services.jcr.impl.backup.BackupException; +import org.exoplatform.services.jcr.impl.backup.Backupable; +import org.exoplatform.services.jcr.impl.backup.DataRestor; +import org.exoplatform.services.jcr.impl.backup.JCRRestor; +import org.exoplatform.services.jcr.impl.backup.ResumeException; +import org.exoplatform.services.jcr.impl.backup.Suspendable; +import org.exoplatform.services.jcr.impl.dataflow.persistent.WorkspacePersistentDataManager; +import org.exoplatform.services.jcr.impl.storage.jdbc.JDBCWorkspaceDataContainer; +import org.exoplatform.services.jcr.impl.util.io.FileCleanerHolder; + +import java.io.File; +import java.security.PrivilegedExceptionAction; +import java.sql.Connection; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +import javax.naming.InitialContext; +import javax.naming.NameNotFoundException; +import javax.sql.DataSource; + +/** + * Created by The eXo Platform SAS. + * + * Date: 24 01 2011 + * + * @author <a href="mailto:anatoliy.bazko@exoplatform.com.ua">Anatoliy Bazko</a> + * @version $Id: JobExistedRepositoryRestoreSameConfig.java 34360 2010-11-11 11:11:11Z tolusha $ + */ +public class JobExistedRepositoryRestoreSameConfig extends JobRepositoryRestore +{ + + /** + * JobExistedRepositoryRestoreSameConfig constructor. + */ + public JobExistedRepositoryRestoreSameConfig(RepositoryService repoService, BackupManagerImpl backupManagerImpl, + RepositoryEntry repositoryEntry, Map<String, BackupChainLog> workspacesMapping, + RepositoryBackupChainLog backupChainLog) + { + super(repoService, backupManagerImpl, repositoryEntry, workspacesMapping, backupChainLog); + } + + /** + * {@inheritDoc} + */ + @Override + protected void restoreRepository() throws RepositoryRestoreExeption + { + // list of data restorers + List<DataRestor> dataRestorer = new ArrayList<DataRestor>(); + + // the list of components to resume + List<Suspendable> resumeComponents = new ArrayList<Suspendable>(); + + try + { + WorkspaceEntry wsEntry = repositoryEntry.getWorkspaceEntries().get(0); + + // define one common connection for all restores and cleaners for single db case + Connection jdbcConn = null; + if (!Boolean.parseBoolean(wsEntry.getContainer().getParameterValue(JDBCWorkspaceDataContainer.MULTIDB))) + { + String dsName = wsEntry.getContainer().getParameterValue(JDBCWorkspaceDataContainer.SOURCE_NAME); + + final DataSource ds = (DataSource)new InitialContext().lookup(dsName); + if (ds == null) + { + throw new NameNotFoundException("Data source " + dsName + " not found"); + } + + jdbcConn = SecurityHelper.doPrivilegedSQLExceptionAction(new PrivilegedExceptionAction<Connection>() + { + public Connection run() throws Exception + { + return ds.getConnection(); + + } + }); + jdbcConn.setAutoCommit(false); + } + + // suspend all components + for (WorkspaceEntry wEntry : repositoryEntry.getWorkspaceEntries()) + { + List<Suspendable> suspendableComponents = + repositoryService.getRepository(this.repositoryEntry.getName()).getWorkspaceContainer(wEntry.getName()) + .getComponentInstancesOfType(Suspendable.class); + + for (Suspendable component : suspendableComponents) + { + component.suspend(); + resumeComponents.add(component); + } + } + + // collect all restorers + for (WorkspaceEntry wEntry : repositoryEntry.getWorkspaceEntries()) + { + // get all backupable components + List<Backupable> backupable = + repositoryService.getRepository(this.repositoryEntry.getName()).getWorkspaceContainer(wEntry.getName()) + .getComponentInstancesOfType(Backupable.class); + + File fullBackupDir = + JCRRestor.getFullBackupFile(workspacesMapping.get(wEntry.getName()).getBackupConfig().getBackupDir()); + + for (Backupable component : backupable) + { + dataRestorer.add(component.getDataRestorer(fullBackupDir, jdbcConn)); + } + } + + for (DataRestor restorer : dataRestorer) + { + restorer.clean(); + } + + for (DataRestor restorer : dataRestorer) + { + restorer.restore(); + } + + for (DataRestor restorer : dataRestorer) + { + restorer.commit(); + } + + // resume components + for (int i = 0; i < resumeComponents.size() - 1; i++) + { + try + { + resumeComponents.remove(i).resume(); + } + catch (ResumeException e) + { + log.error("Can't resume component", e); + } + } + + // incremental restore + for (WorkspaceEntry wEntry : repositoryEntry.getWorkspaceEntries()) + { + repositoryService.getRepository(this.repositoryEntry.getName()).getWorkspaceContainer(wEntry.getName()) + .getComponentInstancesOfType(Backupable.class); + + DataManager dataManager = + (WorkspacePersistentDataManager)repositoryService.getRepository(this.repositoryEntry.getName()) + .getWorkspaceContainer(wEntry.getName()).getComponent(WorkspacePersistentDataManager.class); + + FileCleanerHolder fileCleanHolder = + (FileCleanerHolder)repositoryService.getRepository(this.repositoryEntry.getName()) + .getWorkspaceContainer(wEntry.getName()).getComponent(FileCleanerHolder.class); + + File storageDir = + JCRRestor.getFullBackupFile(workspacesMapping.get(wEntry.getName()).getBackupConfig().getBackupDir()); + + JCRRestor restorer = new JCRRestor(dataManager, fileCleanHolder.getFileCleaner()); + for (File incrBackupFile : JCRRestor.getIncrementalFiles(storageDir)) + { + restorer.incrementalRestore(incrBackupFile); + } + } + } + catch (Throwable t) + { + // rollback + for (DataRestor restorer : dataRestorer) + { + try + { + restorer.rollback(); + } + catch (BackupException e) + { + log.error("Can't rollback changes", e); + } + } + + throw new RepositoryRestoreExeption("Repository " + repositoryEntry.getName() + " was not restored", t); + } + finally + { + // close + for (DataRestor restorer : dataRestorer) + { + try + { + restorer.close(); + } + catch (BackupException e) + { + log.error("Can't close restorer", e); + } + } + + for (Suspendable component : resumeComponents) + { + try + { + component.resume(); + } + catch (ResumeException e) + { + log.error("Can't resume component " + component.getClass(), e); + } + } + } + } +} Modified: jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/JobExistedWorkspaceRestore.java =================================================================== --- jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/JobExistedWorkspaceRestore.java 2011-01-26 16:18:11 UTC (rev 3890) +++ jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/JobExistedWorkspaceRestore.java 2011-01-26 16:19:28 UTC (rev 3891) @@ -24,13 +24,11 @@ import org.exoplatform.services.jcr.ext.backup.BackupChainLog; import org.exoplatform.services.jcr.ext.backup.BackupManager; import org.exoplatform.services.jcr.ext.backup.WorkspaceRestoreException; +import org.exoplatform.services.jcr.impl.backup.Backupable; import org.exoplatform.services.jcr.impl.core.SessionRegistry; -import org.exoplatform.services.jcr.impl.storage.jdbc.backup.Backupable; -import org.exoplatform.services.jcr.impl.storage.jdbc.backup.DataCleaner; import org.exoplatform.services.log.ExoLogger; import org.exoplatform.services.log.Log; -import java.util.ArrayList; import java.util.List; import javax.jcr.RepositoryException; @@ -51,25 +49,12 @@ private static Log log = ExoLogger.getLogger("exo.jcr.component.ext.JobExistedWorkspaceRestore"); /** - * Value storage cleaner. - */ - private final ValueStorageCleanHelper valueStorageCleaner; - - /** - * Index cleaner. - */ - private final IndexCleanHelper indexCleanHelper; - - /** * JobExistedWorkspaceRestore constructor. */ public JobExistedWorkspaceRestore(RepositoryService repositoryService, BackupManager backupManager, String repositoryName, BackupChainLog log, WorkspaceEntry wEntry) { super(repositoryService, backupManager, repositoryName, log, wEntry); - - this.valueStorageCleaner = new ValueStorageCleanHelper(); - this.indexCleanHelper = new IndexCleanHelper(); } /** @@ -98,38 +83,22 @@ + " did not found in current repository " + repositoryName + " configuration"); } - boolean isSystem = - repositoryService.getRepository(repositoryName).getConfiguration().getSystemWorkspaceName() - .equals(wEntry.getName()); - - List<DataCleaner> dataCleaners = new ArrayList<DataCleaner>(); - + // get all backupable components List<Backupable> backupable = repositoryService.getRepository(repositoryName).getWorkspaceContainer(wEntry.getName()) .getComponentInstancesOfType(Backupable.class); - for (Backupable component : backupable) - { - dataCleaners.add(component.getDataCleaner()); - } - - //close all session + // close all session forceCloseSession(repositoryName, wEntry.getName()); repositoryService.getRepository(repositoryName).removeWorkspace(wEntry.getName()); - //clean database - for (DataCleaner cleaner : dataCleaners) + // clean + for (Backupable component : backupable) { - cleaner.clean(); + component.clean(); } - //clean index - indexCleanHelper.removeWorkspaceIndex(wEntry, isSystem); - - //clean value storage - valueStorageCleaner.removeWorkspaceValueStorage(wEntry); - super.restore(); } catch (Throwable t) @@ -139,7 +108,15 @@ } /** - * forceCloseSession. Close sessions on specific workspace. + * {@inheritDoc} + */ + @Override + protected void removeWorkspace(ManageableRepository mr, String workspaceName) throws RepositoryException + { + } + + /** + * Close sessions on specific workspace. * * @param repositoryName * repository name Added: jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/JobExistedWorkspaceRestoreSameConfig.java =================================================================== --- jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/JobExistedWorkspaceRestoreSameConfig.java (rev 0) +++ jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/JobExistedWorkspaceRestoreSameConfig.java 2011-01-26 16:19:28 UTC (rev 3891) @@ -0,0 +1,190 @@ +/* + * 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.impl; + +import org.exoplatform.services.jcr.RepositoryService; +import org.exoplatform.services.jcr.config.WorkspaceEntry; +import org.exoplatform.services.jcr.dataflow.DataManager; +import org.exoplatform.services.jcr.ext.backup.BackupChainLog; +import org.exoplatform.services.jcr.ext.backup.BackupManager; +import org.exoplatform.services.jcr.ext.backup.WorkspaceRestoreException; +import org.exoplatform.services.jcr.impl.backup.BackupException; +import org.exoplatform.services.jcr.impl.backup.Backupable; +import org.exoplatform.services.jcr.impl.backup.DataRestor; +import org.exoplatform.services.jcr.impl.backup.JCRRestor; +import org.exoplatform.services.jcr.impl.backup.ResumeException; +import org.exoplatform.services.jcr.impl.backup.Suspendable; +import org.exoplatform.services.jcr.impl.dataflow.persistent.WorkspacePersistentDataManager; +import org.exoplatform.services.jcr.impl.util.io.FileCleanerHolder; +import org.exoplatform.services.log.ExoLogger; +import org.exoplatform.services.log.Log; + +import java.io.File; +import java.util.ArrayList; +import java.util.List; + +/** + * Created by The eXo Platform SAS. + * + * Date: 24 01 2011 + * + * @author <a href="mailto:anatoliy.bazko@exoplatform.com.ua">Anatoliy Bazko</a> + * @version $Id: JobExistedWorkspaceRestoreSameConfig.java 34360 2010-11-11 11:11:11Z tolusha $ + */ +public class JobExistedWorkspaceRestoreSameConfig extends JobWorkspaceRestore +{ + /** + * The logger. + */ + private static Log log = ExoLogger.getLogger("exo.jcr.component.ext.JobExistedWorkspaceRestoreSameConfig"); + + /** + * JobExistedWorkspaceRestore constructor. + */ + public JobExistedWorkspaceRestoreSameConfig(RepositoryService repositoryService, BackupManager backupManager, + String repositoryName, BackupChainLog log, WorkspaceEntry wEntry) + { + super(repositoryService, backupManager, repositoryName, log, wEntry); + } + + /** + * {@inheritDoc} + */ + @Override + protected void restore() throws WorkspaceRestoreException + { + // list of data restorers + List<DataRestor> dataRestorer = new ArrayList<DataRestor>(); + + // the list of components to resume + List<Suspendable> resumeComponents = new ArrayList<Suspendable>(); + + try + { + // suspend all components + List<Suspendable> suspendableComponents = + repositoryService.getRepository(repositoryName).getWorkspaceContainer(wEntry.getName()) + .getComponentInstancesOfType(Suspendable.class); + + for (Suspendable component : suspendableComponents) + { + component.suspend(); + resumeComponents.add(component); + } + + // get all restorers + List<Backupable> backupable = + repositoryService.getRepository(repositoryName).getWorkspaceContainer(wEntry.getName()) + .getComponentInstancesOfType(Backupable.class); + + File storageDir = backupChainLog.getBackupConfig().getBackupDir(); + + for (Backupable component : backupable) + { + File fullBackupDir = JCRRestor.getFullBackupFile(storageDir); + dataRestorer.add(component.getDataRestorer(fullBackupDir, null)); + } + + for (DataRestor restorer : dataRestorer) + { + restorer.clean(); + } + + for (DataRestor restorer : dataRestorer) + { + restorer.restore(); + } + + for (DataRestor restorer : dataRestorer) + { + restorer.commit(); + } + + // resume components + for (int i = 0; i < resumeComponents.size() - 1; i++) + { + try + { + resumeComponents.remove(i).resume(); + } + catch (ResumeException e) + { + log.error("Can't resume component", e); + } + } + + // incremental restore + DataManager dataManager = + (WorkspacePersistentDataManager)repositoryService.getRepository(repositoryName) + .getWorkspaceContainer(wEntry.getName()).getComponent(WorkspacePersistentDataManager.class); + + FileCleanerHolder fileCleanHolder = + (FileCleanerHolder)repositoryService.getRepository(repositoryName).getWorkspaceContainer(wEntry.getName()) + .getComponent(FileCleanerHolder.class); + + JCRRestor restorer = new JCRRestor(dataManager, fileCleanHolder.getFileCleaner()); + for (File incrBackupFile : JCRRestor.getIncrementalFiles(storageDir)) + { + restorer.incrementalRestore(incrBackupFile); + } + } + catch (Throwable t) + { + // rollback + for (DataRestor restorer : dataRestorer) + { + try + { + restorer.rollback(); + } + catch (BackupException e) + { + log.error("Can't rollback changes", e); + } + } + + throw new WorkspaceRestoreException("Workspace " + wEntry.getName() + " was not restored", t); + } + finally + { + // close + for (DataRestor restorer : dataRestorer) + { + try + { + restorer.close(); + } + catch (BackupException e) + { + log.error("Can't close restorer", e); + } + } + + for (Suspendable component : resumeComponents) + { + try + { + component.resume(); + } + catch (ResumeException e) + { + log.error("Can't resume component", e); + } + } + } + } +} Modified: jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/JobRepositoryRestore.java =================================================================== --- jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/JobRepositoryRestore.java 2011-01-26 16:18:11 UTC (rev 3890) +++ jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/JobRepositoryRestore.java 2011-01-26 16:19:28 UTC (rev 3891) @@ -19,6 +19,7 @@ import org.exoplatform.services.jcr.RepositoryService; +import org.exoplatform.services.jcr.config.RepositoryConfigurationException; import org.exoplatform.services.jcr.config.RepositoryEntry; import org.exoplatform.services.jcr.config.SimpleParameterEntry; import org.exoplatform.services.jcr.config.WorkspaceEntry; @@ -60,7 +61,7 @@ /** * The apache logger. */ - private static Log log = ExoLogger.getLogger("exo.jcr.component.ext.JobRepositoryRestore"); + protected static Log log = ExoLogger.getLogger("exo.jcr.component.ext.JobRepositoryRestore"); /** * REPOSITORY_RESTORE_STARTED. The state of start restore. @@ -108,7 +109,7 @@ protected RepositoryEntry repositoryEntry; - private Map<String, BackupChainLog> workspacesMapping; + protected Map<String, BackupChainLog> workspacesMapping; private RepositoryBackupChainLog repositoryBackupChainLog; @@ -245,23 +246,7 @@ { try { - ManageableRepository mr = null; - - try - { - mr = repositoryService.getRepository(repositoryEntry.getName()); - } - catch (RepositoryException e) - { - // The repository not exist. - } - - if (mr != null) - { - closeAllSession(mr); - repositoryService.removeRepository(repositoryEntry.getName()); - repositoryService.getConfig().retain(); // save configuration to persistence (file or persister) - } + removeRepository(repositoryService, repositoryEntry.getName()); } catch (Throwable thr) { @@ -272,6 +257,40 @@ } } + /** + * Remove repository. + * + * @param repositoryService + * RepositoryService, the repository service + * @param repositoryName + * String, the repository name + * @throws RepositoryException + * will be generated the RepositoryException + * @throws RepositoryConfigurationException + */ + protected void removeRepository(RepositoryService repositoryService, String repositoryName) + throws RepositoryException, + RepositoryConfigurationException + { + ManageableRepository mr = null; + + try + { + mr = repositoryService.getRepository(repositoryName); + } + catch (RepositoryException e) + { + // The repository not exist. + } + + if (mr != null) + { + closeAllSession(mr); + repositoryService.removeRepository(repositoryName); + repositoryService.getConfig().retain(); // save configuration to persistence (file or persister) + } + } + private WorkspaceInitializerEntry getWorkspaceInitializerEntry(BackupChainLog systemBackupChainLog) throws BackupOperationException, ClassNotFoundException { Modified: jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/JobWorkspaceRestore.java =================================================================== --- jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/JobWorkspaceRestore.java 2011-01-26 16:18:11 UTC (rev 3890) +++ jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/JobWorkspaceRestore.java 2011-01-26 16:19:28 UTC (rev 3891) @@ -115,7 +115,7 @@ /** * The BackupChainLog for restore. */ - private final BackupChainLog backupChainLog; + protected final BackupChainLog backupChainLog; /** * JobWorkspaceRestore constructor. @@ -145,6 +145,7 @@ /** * {@inheritDoc} */ + @Override public void run() { try @@ -210,11 +211,10 @@ } } } - } /** - * removeWorkspace. + * Remove workspace. * * @param mr * ManageableRepository, the manageable repository @@ -223,7 +223,7 @@ * @throws RepositoryException * will be generated the RepositoryException */ - private void removeWorkspace(ManageableRepository mr, String workspaceName) throws RepositoryException + protected void removeWorkspace(ManageableRepository mr, String workspaceName) throws RepositoryException { boolean isExists = false; Modified: jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/fs/IncrementalBackupJob.java =================================================================== --- jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/fs/IncrementalBackupJob.java 2011-01-26 16:18:11 UTC (rev 3890) +++ jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/fs/IncrementalBackupJob.java 2011-01-26 16:19:28 UTC (rev 3891) @@ -124,8 +124,7 @@ } } - public void writeExternal(ObjectOutputStream out, TransactionChangesLog changesLog, - FileCleaner fileCleaner) + public void writeExternal(ObjectOutputStream out, TransactionChangesLog changesLog, FileCleaner fileCleaner) throws IOException { Modified: jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/rdbms/FullBackupJob.java =================================================================== --- jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/rdbms/FullBackupJob.java 2011-01-26 16:18:11 UTC (rev 3890) +++ jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/rdbms/FullBackupJob.java 2011-01-26 16:19:28 UTC (rev 3891) @@ -19,35 +19,29 @@ package org.exoplatform.services.jcr.ext.backup.impl.rdbms; import org.exoplatform.commons.utils.PrivilegedFileHelper; -import org.exoplatform.services.jcr.config.QueryHandlerParams; -import org.exoplatform.services.jcr.config.RepositoryConfigurationException; -import org.exoplatform.services.jcr.config.ValueStorageEntry; import org.exoplatform.services.jcr.config.WorkspaceEntry; import org.exoplatform.services.jcr.core.ManageableRepository; import org.exoplatform.services.jcr.ext.backup.BackupConfig; -import org.exoplatform.services.jcr.ext.backup.BackupOperationException; import org.exoplatform.services.jcr.ext.backup.impl.AbstractFullBackupJob; import org.exoplatform.services.jcr.ext.backup.impl.FileNameProducer; -import org.exoplatform.services.jcr.impl.core.query.SystemSearchManager; -import org.exoplatform.services.jcr.impl.storage.jdbc.backup.BackupException; -import org.exoplatform.services.jcr.impl.storage.jdbc.backup.Backupable; -import org.exoplatform.services.jcr.impl.storage.jdbc.backup.ResumeException; -import org.exoplatform.services.jcr.impl.storage.jdbc.backup.SuspendException; -import org.exoplatform.services.jcr.impl.storage.jdbc.backup.Suspendable; -import org.exoplatform.services.jcr.impl.storage.value.fs.FileValueStorage; +import org.exoplatform.services.jcr.impl.backup.BackupException; +import org.exoplatform.services.jcr.impl.backup.Backupable; +import org.exoplatform.services.jcr.impl.backup.ResumeException; +import org.exoplatform.services.jcr.impl.backup.SuspendException; +import org.exoplatform.services.jcr.impl.backup.Suspendable; import org.exoplatform.services.log.ExoLogger; import org.exoplatform.services.log.Log; import java.io.File; import java.io.FileNotFoundException; import java.io.IOException; -import java.io.InputStream; import java.net.URL; +import java.util.ArrayList; import java.util.Calendar; import java.util.List; -import java.util.zip.ZipEntry; -import java.util.zip.ZipOutputStream; +import javax.jcr.RepositoryException; + /** * Created by The eXo Platform SARL Author : Alex Reshetnyak alex.reshetnyak(a)exoplatform.com.ua Nov * 21, 2007 @@ -55,26 +49,16 @@ public class FullBackupJob extends AbstractFullBackupJob { /** - * Index directory in full backup storage. - */ - public static final String INDEX_DIR = "index"; + * Logger. + */ + protected static Log log = ExoLogger.getLogger("exo.jcr.component.ext.FullBackupJob"); /** - * System index directory in full backup storage. + * Workspace configuration. */ - public static final String SYSTEM_INDEX_DIR = INDEX_DIR + "_" + SystemSearchManager.INDEX_DIR_SUFFIX; + private WorkspaceEntry workspaceEntry; /** - * Value storage directory in full backup storage. - */ - public static final String VALUE_STORAGE_DIR = "values"; - - /** - * Logger. - */ - protected static Log log = ExoLogger.getLogger("exo.jcr.component.ext.FullBackupJob"); - - /** * {@inheritDoc} */ @Override @@ -120,15 +104,14 @@ { notifyListeners(); - List<Backupable> backupableComponents = - repository.getWorkspaceContainer(workspaceName).getComponentInstancesOfType(Backupable.class); - List<Suspendable> suspendableComponents = repository.getWorkspaceContainer(workspaceName).getComponentInstancesOfType(Suspendable.class); + // the list of components to resume + List<Suspendable> resumeComponents = new ArrayList<Suspendable>(); + try { - WorkspaceEntry workspaceEntry = null; for (WorkspaceEntry entry : repository.getConfiguration().getWorkspaceEntries()) { if (entry.getName().equals(workspaceName)) @@ -140,30 +123,25 @@ if (workspaceEntry == null) { - throw new RepositoryConfigurationException("Workpace name " + workspaceName - + " not found in repository configuration"); + throw new RepositoryException("Workpace [" + workspaceName + "] is absent in repository configuration"); } // suspend all components for (Suspendable component : suspendableComponents) { component.suspend(); + resumeComponents.add(component); } + List<Backupable> backupableComponents = + repository.getWorkspaceContainer(workspaceName).getComponentInstancesOfType(Backupable.class); + // backup all components for (Backupable component : backupableComponents) { component.backup(new File(getStorageURL().getFile())); } - - backupValueStorage(workspaceEntry); - backupIndex(workspaceEntry); } - catch (RepositoryConfigurationException e) - { - log.error("Full backup failed " + getStorageURL().getPath(), e); - notifyError("Full backup failed", e); - } catch (SuspendException e) { log.error("Full backup failed " + getStorageURL().getPath(), e); @@ -174,19 +152,14 @@ log.error("Full backup failed " + getStorageURL().getPath(), e); notifyError("Full backup failed", e); } - catch (BackupOperationException e) + catch (RepositoryException e) { log.error("Full backup failed " + getStorageURL().getPath(), e); notifyError("Full backup failed", e); } - catch (IOException e) - { - log.error("Full backup failed " + getStorageURL().getPath(), e); - notifyError("Full backup failed", e); - } finally { - for (Suspendable component : suspendableComponents) + for (Suspendable component : resumeComponents) { try { @@ -205,147 +178,10 @@ } /** - * Backup index files. - * - * @param workspaceEntry - * @throws RepositoryConfigurationException - * @throws BackupOperationException - * @throws IOException - */ - protected void backupIndex(WorkspaceEntry workspaceEntry) throws RepositoryConfigurationException, - BackupOperationException, IOException - { - if (workspaceEntry.getQueryHandler() != null) - { - File srcDir = new File(workspaceEntry.getQueryHandler().getParameterValue(QueryHandlerParams.PARAM_INDEX_DIR)); - if (!PrivilegedFileHelper.exists(srcDir)) - { - throw new BackupOperationException("Can't backup index. Directory " + srcDir.getName() + " doesn't exists"); - } - else - { - File destDir = new File(getStorageURL().getFile(), INDEX_DIR); - copyDirectory(srcDir, destDir); - } - - if (repository.getConfiguration().getSystemWorkspaceName().equals(workspaceName)) - { - srcDir = - new File(PrivilegedFileHelper.getCanonicalPath(srcDir) + "_" + SystemSearchManager.INDEX_DIR_SUFFIX); - if (!PrivilegedFileHelper.exists(srcDir)) - { - throw new BackupOperationException("Can't backup system index. Directory " + srcDir.getName() - + " doesn't exists"); - } - else - { - File destDir = new File(getStorageURL().getFile(), SYSTEM_INDEX_DIR); - copyDirectory(srcDir, destDir); - } - } - } - } - - /** - * Backup value storage files. - * - * @param workspaceEntry - * @throws RepositoryConfigurationException - * @throws BackupOperationException - * @throws IOException - */ - protected void backupValueStorage(WorkspaceEntry workspaceEntry) throws RepositoryConfigurationException, - BackupOperationException, IOException - { - if (workspaceEntry.getContainer().getValueStorages() != null) - { - for (ValueStorageEntry valueStorage : workspaceEntry.getContainer().getValueStorages()) - { - File srcDir = new File(valueStorage.getParameterValue(FileValueStorage.PATH)); - if (!PrivilegedFileHelper.exists(srcDir)) - { - throw new BackupOperationException("Can't backup value storage. Directory " + srcDir.getName() - + " doesn't exists"); - } - else - { - File destValuesDir = new File(getStorageURL().getFile(), VALUE_STORAGE_DIR); - File destDir = new File(destValuesDir, valueStorage.getId()); - - copyDirectory(srcDir, destDir); - } - } - } - } - - /** * {@inheritDoc} */ public void stop() { log.info("Stop requested " + getStorageURL().getPath()); } - - /** - * Copy directory. - * - * @param srcPath - * source path - * @param dstPath - * destination path - * @throws IOException - * if any exception occurred - */ - private void copyDirectory(File srcPath, File dstPath) throws IOException - { - if (PrivilegedFileHelper.isDirectory(srcPath)) - { - if (!PrivilegedFileHelper.exists(dstPath)) - { - PrivilegedFileHelper.mkdirs(dstPath); - } - - String files[] = PrivilegedFileHelper.list(srcPath); - for (int i = 0; i < files.length; i++) - { - copyDirectory(new File(srcPath, files[i]), new File(dstPath, files[i])); - } - } - else - { - InputStream in = null; - ZipOutputStream out = null; - - try - { - in = PrivilegedFileHelper.fileInputStream(srcPath); - out = PrivilegedFileHelper.zipOutputStream(dstPath); - out.putNextEntry(new ZipEntry(srcPath.getName())); - - // Transfer bytes from in to out - byte[] buf = new byte[2048]; - - int len; - - while ((len = in.read(buf)) > 0) - { - out.write(buf, 0, len); - } - } - finally - { - if (in != null) - { - in.close(); - } - - if (out != null) - { - out.flush(); - out.closeEntry(); - out.close(); - } - } - } - } -} +} \ No newline at end of file Modified: jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/rdbms/RdbmsBackupWorkspaceInitializer.java =================================================================== --- jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/rdbms/RdbmsBackupWorkspaceInitializer.java 2011-01-26 16:18:11 UTC (rev 3890) +++ jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/rdbms/RdbmsBackupWorkspaceInitializer.java 2011-01-26 16:19:28 UTC (rev 3891) @@ -21,18 +21,18 @@ 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.backup.JCRRestor; import org.exoplatform.services.jcr.impl.core.LocationFactory; import org.exoplatform.services.jcr.impl.core.NamespaceRegistryImpl; 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.jcr.impl.storage.jdbc.backup.CleanException; import org.exoplatform.services.jcr.impl.util.io.FileCleanerHolder; import org.exoplatform.services.log.ExoLogger; import org.exoplatform.services.log.Log; +import java.io.File; +import java.io.FileNotFoundException; import java.io.IOException; import javax.jcr.PathNotFoundException; @@ -59,62 +59,42 @@ public RdbmsBackupWorkspaceInitializer(WorkspaceEntry config, RepositoryEntry repConfig, CacheableWorkspaceDataManager dataManager, NamespaceRegistryImpl namespaceRegistry, LocationFactory locationFactory, NodeTypeManagerImpl nodeTypeManager, ValueFactoryImpl valueFactory, - AccessManager accessManager, RepositoryService repositoryService, FileCleanerHolder cleanerHolder) - throws RepositoryConfigurationException, - PathNotFoundException, RepositoryException + AccessManager accessManager, RepositoryService repositoryService, FileCleanerHolder cleanerHolder) + throws RepositoryConfigurationException, PathNotFoundException, RepositoryException { super(config, repConfig, dataManager, namespaceRegistry, locationFactory, nodeTypeManager, valueFactory, - accessManager, repositoryService, cleanerHolder); + accessManager, repositoryService, cleanerHolder); } /** * {@inheritDoc} */ @Override - public NodeData initWorkspace() throws RepositoryException + protected void restoreAction() throws RepositoryException { - if (isWorkspaceInitialized()) - { - return (NodeData)dataManager.getItemData(Constants.ROOT_UUID); - } + // restore from full rdbms backup + fullRdbmsRestore(); - long start = System.currentTimeMillis(); - - try + // restore from incremental backup + JCRRestor restorer = new JCRRestor(dataManager, fileCleaner); + for (File incrBackupFile : JCRRestor.getIncrementalFiles(new File(restoreDir))) { - // restore from full rdbms backup - fullRdbmsRestore(); - - // restore from incremental backup - incrementalRead(); - } - catch (Throwable e) - { try { - rollback(); + restorer.incrementalRestore(incrBackupFile); } - catch (RepositoryConfigurationException e1) + catch (FileNotFoundException e) { - log.error("Can't rollback changes", e1); + throw new RepositoryException(e); } - catch (CleanException e1) + catch (IOException e) { - log.error("Can't rollback changes", e1); + throw new RepositoryException(e); } - catch (IOException e1) + catch (ClassNotFoundException e) { - log.error("Can't rollback changes", e1); + throw new RepositoryException(e); } - throw new RepositoryException(e); } - - 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; } - } Modified: jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/rdbms/RdbmsWorkspaceInitializer.java =================================================================== --- jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/rdbms/RdbmsWorkspaceInitializer.java 2011-01-26 16:18:11 UTC (rev 3890) +++ jcr/trunk/exo.jcr.component.ext/src/main/java/org/exoplatform/services/jcr/ext/backup/impl/rdbms/RdbmsWorkspaceInitializer.java 2011-01-26 16:19:28 UTC (rev 3891) @@ -18,41 +18,30 @@ */ package org.exoplatform.services.jcr.ext.backup.impl.rdbms; -import org.exoplatform.commons.utils.PrivilegedFileHelper; import org.exoplatform.services.jcr.RepositoryService; import org.exoplatform.services.jcr.access.AccessManager; -import org.exoplatform.services.jcr.config.QueryHandlerParams; import org.exoplatform.services.jcr.config.RepositoryConfigurationException; import org.exoplatform.services.jcr.config.RepositoryEntry; -import org.exoplatform.services.jcr.config.ValueStorageEntry; import org.exoplatform.services.jcr.config.WorkspaceEntry; import org.exoplatform.services.jcr.core.ManageableRepository; -import org.exoplatform.services.jcr.core.WorkspaceContainerFacade; import org.exoplatform.services.jcr.datamodel.NodeData; -import org.exoplatform.services.jcr.ext.backup.impl.IndexCleanHelper; -import org.exoplatform.services.jcr.ext.backup.impl.ValueStorageCleanHelper; import org.exoplatform.services.jcr.impl.Constants; +import org.exoplatform.services.jcr.impl.backup.BackupException; +import org.exoplatform.services.jcr.impl.backup.Backupable; +import org.exoplatform.services.jcr.impl.backup.DataRestor; import org.exoplatform.services.jcr.impl.core.BackupWorkspaceInitializer; import org.exoplatform.services.jcr.impl.core.LocationFactory; import org.exoplatform.services.jcr.impl.core.NamespaceRegistryImpl; -import org.exoplatform.services.jcr.impl.core.SessionRegistry; import org.exoplatform.services.jcr.impl.core.nodetype.NodeTypeManagerImpl; -import org.exoplatform.services.jcr.impl.core.query.SystemSearchManager; import org.exoplatform.services.jcr.impl.core.value.ValueFactoryImpl; import org.exoplatform.services.jcr.impl.dataflow.persistent.CacheableWorkspaceDataManager; -import org.exoplatform.services.jcr.impl.storage.jdbc.backup.Backupable; -import org.exoplatform.services.jcr.impl.storage.jdbc.backup.CleanException; -import org.exoplatform.services.jcr.impl.storage.jdbc.backup.RestoreException; -import org.exoplatform.services.jcr.impl.storage.value.fs.FileValueStorage; import org.exoplatform.services.jcr.impl.util.io.FileCleanerHolder; import org.exoplatform.services.log.ExoLogger; import org.exoplatform.services.log.Log; import java.io.File; -import java.io.IOException; -import java.io.OutputStream; +import java.util.ArrayList; import java.util.List; -import java.util.zip.ZipInputStream; import javax.jcr.PathNotFoundException; import javax.jcr.RepositoryException; @@ -73,19 +62,17 @@ */ protected final RepositoryService repositoryService; - /** * Constructor RdbmsWorkspaceInitializer. */ public RdbmsWorkspaceInitializer(WorkspaceEntry config, RepositoryEntry repConfig, CacheableWorkspaceDataManager dataManager, NamespaceRegistryImpl namespaceRegistry, LocationFactory locationFactory, NodeTypeManagerImpl nodeTypeManager, ValueFactoryImpl valueFactory, - AccessManager accessManager, RepositoryService repositoryService, FileCleanerHolder cleanerHolder) - throws RepositoryConfigurationException, - PathNotFoundException, RepositoryException + AccessManager accessManager, RepositoryService repositoryService, FileCleanerHolder cleanerHolder) + throws RepositoryConfigurationException, PathNotFoundException, RepositoryException { super(config, repConfig, dataManager, namespaceRegistry, locationFactory, nodeTypeManager, valueFactory, - accessManager, cleanerHolder); + accessManager, cleanerHolder); this.repositoryService = repositoryService; } @@ -103,30 +90,7 @@ long start = System.currentTimeMillis(); - try - { - fullRdbmsRestore(); - } - catch (Throwable e) - { - try - { - rollback(); - } - catch (RepositoryConfigurationException e1) - { - log.error("Can't rollback changes", e1); - } - catch (CleanException e1) - { - log.error("Can't rollback changes", e1); - } - catch (IOException e1) - { - log.error("Can't rollback changes", e1); - } - throw new RepositoryException(e); - } + restoreAction(); final NodeData root = (NodeData)dataManager.getItemData(Constants.ROOT_UUID); @@ -137,10 +101,22 @@ } /** + * Calls restoring methods. + * + * @throws RepositoryException if any Exception is occurred + */ + protected void restoreAction() throws RepositoryException + { + fullRdbmsRestore(); + } + + /** * Restore from full rdbms backup. */ protected void fullRdbmsRestore() throws RepositoryException { + List<DataRestor> dataRestorers = new ArrayList<DataRestor>(); + ManageableRepository repository = null; try { @@ -159,240 +135,47 @@ // restore all components for (Backupable component : backupableComponents) { - component.restore(new File(restorePath)); + dataRestorers.add(component.getDataRestorer(new File(restorePath), null)); } - restoreValueStorage(); - restoreIndex(); - } - catch (RestoreException e) - { - throw new RepositoryException(e); - } - catch (RepositoryConfigurationException e) - { - throw new RepositoryException(e); - } - catch (IOException e) - { - throw new RepositoryException(e); - } - } - - /** - * Restore index from backup. - */ - protected void restoreIndex() throws RepositoryConfigurationException, IOException - { - File indexDir = new File(restorePath, FullBackupJob.INDEX_DIR); - File systemIndexDir = new File(restorePath, FullBackupJob.SYSTEM_INDEX_DIR); - - if (workspaceEntry.getQueryHandler() != null) - { - if (!PrivilegedFileHelper.exists(indexDir)) + for (DataRestor restorer : dataRestorers) { - throw new RepositoryConfigurationException("Can't restore index. Directory " + indexDir.getName() - + " doesn't exists"); + restorer.restore(); } - else - { - File destDir = - new File(workspaceEntry.getQueryHandler().getParameterValue(QueryHandlerParams.PARAM_INDEX_DIR)); - copyDirectory(indexDir, destDir); - } - // try to restore system index - if (repositoryEntry.getSystemWorkspaceName().equals(workspaceName)) + for (DataRestor restorer : dataRestorers) { - if (!PrivilegedFileHelper.exists(systemIndexDir)) - { - throw new RepositoryConfigurationException("Can't restore system index. Directory " - + systemIndexDir.getName() + " doesn't exists"); - } - else - { - File destDir = - new File(workspaceEntry.getQueryHandler().getParameterValue(QueryHandlerParams.PARAM_INDEX_DIR) + "_" - + SystemSearchManager.INDEX_DIR_SUFFIX); - copyDirectory(systemIndexDir, destDir); - } + restorer.commit(); } - else if (PrivilegedFileHelper.exists(systemIndexDir)) - { - throw new RepositoryConfigurationException("Workspace [" + workspaceName - + "] is not a system in repository configuration but system index backup files exist"); - } } - else + catch (Throwable e) { - if (PrivilegedFileHelper.exists(indexDir) || PrivilegedFileHelper.exists(systemIndexDir)) + for (DataRestor restorer : dataRestorers) { - throw new RepositoryConfigurationException("Query handler didn't configure in workspace [" + workspaceName - + "] configuration but index backup files exist"); - } - } - } - - /** - * Rollback changes due to errors. - * - * @throws RepositoryConfigurationException - * @throws RepositoryException - * @throws CleanException - * @throws IOException - */ - protected void rollback() throws RepositoryException, RepositoryConfigurationException, CleanException, - IOException - { - boolean isSystem = - repositoryService.getRepository(repositoryEntry.getName()).getConfiguration().getSystemWorkspaceName() - .equals(workspaceEntry.getName()); - - //close all session - forceCloseSession(repositoryEntry.getName(), workspaceEntry.getName()); - - List<Backupable> backupable = - repositoryService.getRepository(repositoryEntry.getName()).getWorkspaceContainer(workspaceEntry.getName()) - .getComponentInstancesOfType(Backupable.class); - - //clean database - for (Backupable component : backupable) - { - component.getDataCleaner().clean(); - } - - //clean index - new IndexCleanHelper().removeWorkspaceIndex(workspaceEntry, isSystem); - - //clean value storage - new ValueStorageCleanHelper().removeWorkspaceValueStorage(workspaceEntry); - } - - /** - * Close sessions on specific workspace. - * - * @param repositoryName - * repository name - * @param workspaceName - * workspace name - * @return int return the how many sessions was closed - * @throws RepositoryConfigurationException - * will be generate RepositoryConfigurationException - * @throws RepositoryException - * will be generate RepositoryException - */ - private int forceCloseSession(String repositoryName, String workspaceName) throws RepositoryException, - RepositoryConfigurationException - { - ManageableRepository mr = repositoryService.getRepository(repositoryName); - WorkspaceContainerFacade wc = mr.getWorkspaceContainer(workspaceName); - - SessionRegistry sessionRegistry = (SessionRegistry)wc.getComponent(SessionRegistry.class); - - return sessionRegistry.closeSessions(workspaceName); - } - - /** - * Restoring value storage from backup. - */ - protected void restoreValueStorage() throws RepositoryConfigurationException, IOException - { - File backupValueStorageDir = new File(restorePath, FullBackupJob.VALUE_STORAGE_DIR); - if (workspaceEntry.getContainer().getValueStorages() != null) - { - List<ValueStorageEntry> valueStorages = workspaceEntry.getContainer().getValueStorages(); - String[] valueStoragesFiles = PrivilegedFileHelper.list(backupValueStorageDir); - - if ((valueStoragesFiles == null && valueStorages.size() != 0) - || (valueStoragesFiles != null && valueStoragesFiles.length != valueStorages.size())) - { - throw new RepositoryConfigurationException("Workspace configuration [" + workspaceName - + "] has a different amount of value storages than exist in backup"); - } - - for (ValueStorageEntry valueStorage : valueStorages) - { - File srcDir = new File(backupValueStorageDir, valueStorage.getId()); - if (!PrivilegedFileHelper.exists(srcDir)) + try { - throw new RepositoryConfigurationException("Can't restore value storage. Directory " + srcDir.getName() - + " doesn't exists"); + restorer.rollback(); } - else + catch (BackupException e1) { - File destDir = new File(valueStorage.getParameterValue(FileValueStorage.PATH)); - - copyDirectory(srcDir, destDir); + log.error("Can't rollback restorer", e); } } - } - else - { - if (PrivilegedFileHelper.exists(backupValueStorageDir)) - { - throw new RepositoryConfigurationException("Value storage didn't configure in workspace [" + workspaceName - + "] configuration but value storage backup files exist"); - } - } - } - /** - * Copy directory. - * - * @param srcPath - * source path - * @param dstPath - * destination path - * @throws IOException - * if any exception occurred - */ - private void copyDirectory(File srcPath, File dstPath) throws IOException - { - if (PrivilegedFileHelper.isDirectory(srcPath)) - { - if (!PrivilegedFileHelper.exists(dstPath)) - { - PrivilegedFileHelper.mkdirs(dstPath); - } - - String files[] = PrivilegedFileHelper.list(srcPath); - for (int i = 0; i < files.length; i++) - { - copyDirectory(new File(srcPath, files[i]), new File(dstPath, files[i])); - } + throw new RepositoryException(e); } - else + finally { - ZipInputStream in = null; - OutputStream out = null; - - try + for (DataRestor restorer : dataRestorers) { - in = PrivilegedFileHelper.zipInputStream(srcPath); - in.getNextEntry(); - out = PrivilegedFileHelper.fileOutputStream(dstPath); - - // Transfer bytes from in to out - byte[] buf = new byte[2048]; - - int len; - - while ((len = in.read(buf)) > 0) + try { - out.write(buf, 0, len); + restorer.close(); } - } - finally - { - if (in != null) + catch (BackupException e) { - in.close(); + log.error("Can't close restorer", e); } - - if (out != null) - { - out.close(); - } } } } 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 2011-01-26 16:18:11 UTC (rev 3890) +++ jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/AbstractBackupTestCase.java 2011-01-26 16:19:28 UTC (rev 3891) @@ -18,6 +18,7 @@ */ package org.exoplatform.services.jcr.ext.backup; +import org.exoplatform.commons.utils.PrivilegedFileHelper; import org.exoplatform.services.jcr.config.ContainerEntry; import org.exoplatform.services.jcr.config.QueryHandlerEntry; import org.exoplatform.services.jcr.config.QueryHandlerParams; @@ -30,25 +31,24 @@ import org.exoplatform.services.jcr.core.ManageableRepository; import org.exoplatform.services.jcr.core.WorkspaceContainerFacade; import org.exoplatform.services.jcr.ext.BaseStandaloneTest; -import org.exoplatform.services.jcr.ext.backup.impl.IndexCleanHelper; -import org.exoplatform.services.jcr.ext.backup.impl.ValueStorageCleanHelper; import org.exoplatform.services.jcr.impl.RepositoryServiceImpl; +import org.exoplatform.services.jcr.impl.clean.rdbms.DBCleanService; import org.exoplatform.services.jcr.impl.core.RepositoryImpl; import org.exoplatform.services.jcr.impl.core.SessionImpl; import org.exoplatform.services.jcr.impl.core.SessionRegistry; +import org.exoplatform.services.jcr.impl.core.query.SystemSearchManager; import org.exoplatform.services.jcr.impl.storage.jdbc.JDBCWorkspaceDataContainer; -import org.exoplatform.services.jcr.impl.storage.jdbc.backup.Backupable; -import org.exoplatform.services.jcr.impl.storage.jdbc.backup.DataCleaner; +import org.exoplatform.services.jcr.impl.storage.value.fs.FileValueStorage; import java.io.File; import java.io.FileFilter; +import java.io.IOException; import java.sql.Connection; import java.sql.Statement; import java.util.ArrayList; import java.util.Calendar; import java.util.Date; import java.util.Iterator; -import java.util.List; import java.util.Map; import javax.jcr.ItemExistsException; @@ -94,16 +94,6 @@ protected String workspaceNameToRestore = "ws1backup"; - /** - * Value storage cleaner. - */ - private ValueStorageCleanHelper valueStorageCleanHelper = new ValueStorageCleanHelper(); - - /** - * Index storage cleaner. - */ - private IndexCleanHelper indexCleanHelper = new IndexCleanHelper(); - class LogFilter implements FileFilter { @@ -521,11 +511,24 @@ conn.close(); } - //clean index - indexCleanHelper.removeWorkspaceIndex(wEntry, isSystem); + if (wEntry.getContainer().getValueStorages() != null) + { + for (ValueStorageEntry valueStorage : wEntry.getContainer().getValueStorages()) + { + removeDirectory(new File(valueStorage.getParameterValue(FileValueStorage.PATH))); + } + } - //clean value storage - valueStorageCleanHelper.removeWorkspaceValueStorage(wEntry); + if (wEntry.getQueryHandler() != null) + { + removeDirectory(new File(wEntry.getQueryHandler().getParameterValue(QueryHandlerParams.PARAM_INDEX_DIR, null))); + if (isSystem) + { + removeDirectory(new File(wEntry.getQueryHandler().getParameterValue(QueryHandlerParams.PARAM_INDEX_DIR, + null) + + "_" + SystemSearchManager.INDEX_DIR_SUFFIX)); + } + } } protected void removeWorkspaceFullySingleDB(String repositoryName, String workspaceName) throws Exception @@ -552,33 +555,31 @@ repositoryService.getRepository(repositoryName).getConfiguration().getSystemWorkspaceName() .equals(wEntry.getName()); - List<DataCleaner> dataCleaners = new ArrayList<DataCleaner>(); - - List<Backupable> backupable = - repositoryService.getRepository(repositoryName).getWorkspaceContainer(wEntry.getName()) - .getComponentInstancesOfType(Backupable.class); - - for (Backupable component : backupable) - { - dataCleaners.add(component.getDataCleaner()); - } - //close all session forceCloseSession(repositoryName, wEntry.getName()); repositoryService.getRepository(repositoryName).removeWorkspace(wEntry.getName()); - //clean database - for (DataCleaner cleaner : dataCleaners) + DBCleanService.cleanWorkspaceData(wEntry); + + if (wEntry.getContainer().getValueStorages() != null) { - cleaner.clean(); + for (ValueStorageEntry valueStorage : wEntry.getContainer().getValueStorages()) + { + removeDirectory(new File(valueStorage.getParameterValue(FileValueStorage.PATH))); + } } - //clean index - indexCleanHelper.removeWorkspaceIndex(wEntry, isSystem); - - //clean value storage - valueStorageCleanHelper.removeWorkspaceValueStorage(wEntry); + if (wEntry.getQueryHandler() != null) + { + removeDirectory(new File(wEntry.getQueryHandler().getParameterValue(QueryHandlerParams.PARAM_INDEX_DIR, null))); + if (isSystem) + { + removeDirectory(new File(wEntry.getQueryHandler().getParameterValue(QueryHandlerParams.PARAM_INDEX_DIR, + null) + + "_" + SystemSearchManager.INDEX_DIR_SUFFIX)); + } + } } protected void removeRepositoryFully(String repositoryName) throws Exception @@ -604,52 +605,45 @@ forceCloseSession(repositoryEntry.getName(), wEntry.getName()); } - List<DataCleaner> dataCleaners = new ArrayList<DataCleaner>(); + String systemWorkspaceName = + repositoryService.getRepository(repositoryName).getConfiguration().getSystemWorkspaceName(); - // collect all DataCleaners - for (WorkspaceEntry wEntry : workspaceList) - { - forceCloseSession(repositoryEntry.getName(), wEntry.getName()); - - List<Backupable> backupable = - repositoryService.getRepository(repositoryEntry.getName()).getWorkspaceContainer(wEntry.getName()) - .getComponentInstancesOfType(Backupable.class); - - for (Backupable component : backupable) - { - dataCleaners.add(component.getDataCleaner()); - } - } - //remove repository if (isDefault) { - ((RepositoryServiceImpl) repositoryService).removeDefaultRepository(); + ((RepositoryServiceImpl)repositoryService).removeDefaultRepository(); } else { repositoryService.removeRepository(repositoryEntry.getName()); } - //clean database - for (DataCleaner cleaner : dataCleaners) - { - cleaner.clean(); - } - - //clean index for (WorkspaceEntry wEntry : workspaceList) { - indexCleanHelper.removeWorkspaceIndex(wEntry, repositoryEntry.getSystemWorkspaceName() - .equals(wEntry.getName())); - } + DBCleanService.cleanWorkspaceData(wEntry); - //clean value storage - for (WorkspaceEntry wEntry : workspaceList) - { - valueStorageCleanHelper.removeWorkspaceValueStorage(wEntry); + if (wEntry.getContainer().getValueStorages() != null) + { + for (ValueStorageEntry valueStorage : wEntry.getContainer().getValueStorages()) + { + removeDirectory(new File(valueStorage.getParameterValue(FileValueStorage.PATH))); + } + } + + boolean isSystem = systemWorkspaceName.equals(wEntry.getName()); + + if (wEntry.getQueryHandler() != null) + { + removeDirectory(new File(wEntry.getQueryHandler().getParameterValue(QueryHandlerParams.PARAM_INDEX_DIR, + null))); + if (isSystem) + { + removeDirectory(new File(wEntry.getQueryHandler().getParameterValue(QueryHandlerParams.PARAM_INDEX_DIR, + null) + + "_" + SystemSearchManager.INDEX_DIR_SUFFIX)); + } + } } - } /** @@ -676,4 +670,34 @@ return sessionRegistry.closeSessions(workspaceName); } + /** + * Remove directory. + * + * @param dir + * directory to remove + * @throws IOException + * if any exception occurred + */ + private void removeDirectory(File dir) throws IOException + { + if (PrivilegedFileHelper.isDirectory(dir)) + { + for (File subFile : PrivilegedFileHelper.listFiles(dir)) + { + removeDirectory(subFile); + } + + if (!PrivilegedFileHelper.delete(dir)) + { + throw new IOException("Can't remove folder : " + PrivilegedFileHelper.getCanonicalPath(dir)); + } + } + else + { + if (!PrivilegedFileHelper.delete(dir)) + { + throw new IOException("Can't remove file : " + PrivilegedFileHelper.getCanonicalPath(dir)); + } + } + } } Modified: 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 2011-01-26 16:18:11 UTC (rev 3890) +++ jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/AbstractBackupUseCasesTest.java 2011-01-26 16:19:28 UTC (rev 3891) @@ -44,8 +44,7 @@ * @author <a href="mailto:alex.reshetnyak@exoplatform.com.ua">Alex Reshetnyak</a> * @version $Id$ */ -public abstract class AbstractBackupUseCasesTest - extends AbstractBackupTestCase +public abstract class AbstractBackupUseCasesTest extends AbstractBackupTestCase { private static volatile long uuIndex; @@ -87,8 +86,7 @@ fail("Can't get fullBackup chain"); // restore - RepositoryEntry re = - (RepositoryEntry) ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); + RepositoryEntry re = (RepositoryEntry)ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); WorkspaceEntry ws1back = makeWorkspaceEntry(workspaceNameToRestore, dataSourceToWorkspaceRestore); // BackupChainLog bchLog = new BackupChainLog(backDir, rconfig); @@ -106,10 +104,10 @@ SessionImpl back1 = null; try { - back1 = (SessionImpl) getReposityToBackup().login(credentials, workspaceNameToRestore); + back1 = (SessionImpl)getReposityToBackup().login(credentials, workspaceNameToRestore); Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") - .getProperty("exo:data").getString()); + .getProperty("exo:data").getString()); } catch (Exception e) { @@ -168,8 +166,7 @@ fail("Can't get fullBackup chain"); // restore - RepositoryEntry re = - (RepositoryEntry) ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); + RepositoryEntry re = (RepositoryEntry)ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); WorkspaceEntry ws1back = makeWorkspaceEntry(workspaceNameToRestore, dataSourceToWorkspaceRestore); File backLog = new File(bch.getLogFilePath()); @@ -186,16 +183,16 @@ SessionImpl back1 = null; try { - back1 = (SessionImpl) getReposityToBackup().login(credentials, workspaceNameToRestore); + back1 = (SessionImpl)getReposityToBackup().login(credentials, workspaceNameToRestore); 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()); + .getProperty("exo:data").getString()); assertEquals("Restored content should be same", "property #5", ws1backTestRoot.getNode("node #5") - .getProperty("exo:extraData").getString()); + .getProperty("exo:extraData").getString()); assertFalse("Proeprty should be removed", ws1backTestRoot.getNode("node #5").hasProperty("exo:data")); } @@ -252,12 +249,12 @@ // 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", (Value) null); // remove property + ws1TestRoot.getNode("node_2").setProperty("exo:data", (Value)null); // remove property ws1TestRoot.getNode("node_3").setProperty("exo:data", new ByteArrayInputStream("aaa".getBytes())); // set // aaa // bytes @@ -268,7 +265,7 @@ 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.getNode("node_5").getPath() + "/node #53"); ws1TestRoot.save(); // log here via listener ws1TestRoot.getNode("node_6").addMixin("mix:referenceable"); @@ -276,8 +273,8 @@ 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 + ws1TestRoot.getSession().getWorkspace() + .move(ws1TestRoot.getNode("node_6").getPath(), ws1TestRoot.getPath() + "/node_4"); // in place of // 4 removed // stop all @@ -287,8 +284,7 @@ fail("Can't get fullBackup chain"); // restore - RepositoryEntry re = - (RepositoryEntry) ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); + RepositoryEntry re = (RepositoryEntry)ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); WorkspaceEntry ws1back = makeWorkspaceEntry(workspaceNameToRestore, dataSourceToWorkspaceRestore); File backLog = new File(bch.getLogFilePath()); @@ -305,12 +301,12 @@ SessionImpl back1 = null; try { - back1 = (SessionImpl) getReposityToBackup().login(credentials, workspaceNameToRestore); + back1 = (SessionImpl)getReposityToBackup().login(credentials, workspaceNameToRestore); 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")); + .hasProperty("node #53/exo:extraData")); assertTrue("Node should exists", ws1backTestRoot.hasNode("node_7")); assertTrue("Property should exists", ws1backTestRoot.hasProperty("node_5/exo:data")); @@ -318,20 +314,20 @@ assertTrue("Node should exists", ws1backTestRoot.hasNode("node_102")); compareStream(new FileInputStream(tempf), ws1backTestRoot.getNode("node_5").getProperty("exo:data") - .getStream()); + .getStream()); compareStream(new FileInputStream(tempf), ws1backTestRoot.getNode("node_1").getProperty("exo:extraData") - .getStream()); + .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()); + 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()); + assertEquals("Node should be mix:referenceable and UUID should be " + id6, id6, + ws1backTestRoot.getNode("node_4").getUUID()); } catch (Exception e) { @@ -350,9 +346,9 @@ public void testFullBackupRestoreAsync() throws Exception { - SessionImpl sessionWS1 = (SessionImpl) getReposityToBackup().login(credentials, workspaceNameToBackup); - sessionWS1.getRootNode().getNode("backupTest").getNode("node_5").setProperty("exo:data", - "Restored content should be same"); + SessionImpl sessionWS1 = (SessionImpl)getReposityToBackup().login(credentials, workspaceNameToBackup); + sessionWS1.getRootNode().getNode("backupTest").getNode("node_5") + .setProperty("exo:data", "Restored content should be same"); sessionWS1.save(); // backup @@ -398,23 +394,23 @@ backup.restore(bchLog, repositoryNameToBackup, ws1back, true); while (backup.getLastRestore(repositoryNameToBackup, workspaceNameToRestore).getStateRestore() != JobWorkspaceRestore.RESTORE_SUCCESSFUL - && backup.getLastRestore(repositoryNameToBackup, workspaceNameToRestore).getStateRestore() != JobWorkspaceRestore.RESTORE_FAIL) + && backup.getLastRestore(repositoryNameToBackup, workspaceNameToRestore).getStateRestore() != JobWorkspaceRestore.RESTORE_FAIL) { Thread.sleep(50); } if (backup.getLastRestore(repositoryNameToBackup, workspaceNameToRestore).getStateRestore() == JobWorkspaceRestore.RESTORE_FAIL) - throw (Exception) backup.getLastRestore(repositoryNameToBackup, workspaceNameToRestore) - .getRestoreException(); + throw (Exception)backup.getLastRestore(repositoryNameToBackup, workspaceNameToRestore) + .getRestoreException(); // check SessionImpl back1 = null; try { - back1 = (SessionImpl) getReposityToBackup().login(credentials, workspaceNameToRestore); + back1 = (SessionImpl)getReposityToBackup().login(credentials, workspaceNameToRestore); Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); - assertEquals("Restored content should be same", "Restored content should be same", ws1backTestRoot.getNode( - "node_5").getProperty("exo:data").getString()); + assertEquals("Restored content should be same", "Restored content should be same", + ws1backTestRoot.getNode("node_5").getProperty("exo:data").getString()); } catch (Exception e) { @@ -527,10 +523,10 @@ public void testTwoRestores() throws Exception { { - SessionImpl sessionWS1 = (SessionImpl) getReposityToBackup().login(credentials, workspaceNameToBackup); + SessionImpl sessionWS1 = (SessionImpl)getReposityToBackup().login(credentials, workspaceNameToBackup); - sessionWS1.getRootNode().addNode("asdasdasda", "nt:unstructured").setProperty("data", - new FileInputStream(createBLOBTempFile(1024))); + sessionWS1.getRootNode().addNode("asdasdasda", "nt:unstructured") + .setProperty("data", new FileInputStream(createBLOBTempFile(1024))); sessionWS1.save(); // 1-st backup @@ -563,12 +559,12 @@ backup.restore(bchLog, repositoryNameToBackup, ws1_restore_1, false); // check - SessionImpl back1 = (SessionImpl) getReposityToBackup().login(credentials, workspaceNameToRestore); + SessionImpl back1 = (SessionImpl)getReposityToBackup().login(credentials, workspaceNameToRestore); 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.getRootNode().addNode("gdfgrghfhf", "nt:unstructured") + .setProperty("data", new FileInputStream(createBLOBTempFile(1024))); back1.save(); } else @@ -608,7 +604,7 @@ backup.restore(bchLog, repositoryNameToBackup, ws1_restore_2, false); // check - SessionImpl back2 = (SessionImpl) getReposityToBackup().login(credentials, workspaceNameToRestore); + SessionImpl back2 = (SessionImpl)getReposityToBackup().login(credentials, workspaceNameToRestore); assertNotNull(back2.getRootNode().getNode("gdfgrghfhf").getProperty("data")); } else @@ -723,8 +719,7 @@ fail("Can't get fullBackup chain"); // restore - RepositoryEntry re = - (RepositoryEntry) ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); + RepositoryEntry re = (RepositoryEntry)ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); WorkspaceEntry ws1back = makeWorkspaceEntry(workspaceNameToRestore, dataSourceToWorkspaceRestore + "NOT_EXIST"); File backLog = new File(bch.getLogFilePath()); @@ -750,10 +745,10 @@ SessionImpl back1 = null; try { - back1 = (SessionImpl) getReposityToBackup().login(credentials, workspaceNameToRestore); + back1 = (SessionImpl)getReposityToBackup().login(credentials, workspaceNameToRestore); Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") - .getProperty("exo:data").getString()); + .getProperty("exo:data").getString()); } catch (Exception e) { @@ -799,8 +794,8 @@ // restore RepositoryEntry newRepositoryEntry = - makeRepositoryEntry(repositoryNameToRestore, getReposityToBackup().getConfiguration(), - dataSourceToRepositoryRestore, null); + makeRepositoryEntry(repositoryNameToRestore, getReposityToBackup().getConfiguration(), + dataSourceToRepositoryRestore, null); File backLog = new File(bch.getLogFilePath()); if (backLog.exists()) @@ -811,8 +806,8 @@ assertNotNull(bchLog.getFinishedTime()); backup.restore(bchLog, newRepositoryEntry, false); - assertEquals(JobWorkspaceRestore.RESTORE_SUCCESSFUL, backup.getLastRepositoryRestore( - newRepositoryEntry.getName()).getStateRestore()); + assertEquals(JobWorkspaceRestore.RESTORE_SUCCESSFUL, + backup.getLastRepositoryRestore(newRepositoryEntry.getName()).getStateRestore()); // check ManageableRepository restoredRepository = repositoryService.getRepository(repositoryNameToRestore); @@ -822,10 +817,10 @@ SessionImpl back1 = null; try { - back1 = (SessionImpl) restoredRepository.login(credentials, wsName); + 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()); + .getProperty("exo:data").getString()); } catch (Exception e) { @@ -870,8 +865,8 @@ //will be saved in incremental backup //will be saved in incremental backup Session wsSession = getReposityToBackup().login(credentials, "ws"); - wsSession.getRootNode().getNode("backupTest").addNode("binary_data").setProperty("data", - new FileInputStream(createBLOBTempFile(500))); + wsSession.getRootNode().getNode("backupTest").addNode("binary_data") + .setProperty("data", new FileInputStream(createBLOBTempFile(500))); wsSession.save(); // stop fullBackup @@ -879,8 +874,8 @@ // restore RepositoryEntry newRepositoryEntry = - makeRepositoryEntry(repositoryNameToRestore, getReposityToBackup().getConfiguration(), - dataSourceToRepositoryRestore, null); + makeRepositoryEntry(repositoryNameToRestore, getReposityToBackup().getConfiguration(), + dataSourceToRepositoryRestore, null); File backLog = new File(bch.getLogFilePath()); if (backLog.exists()) @@ -900,10 +895,10 @@ SessionImpl back1 = null; try { - back1 = (SessionImpl) restoredRepository.login(credentials, wsName); + 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()); + .getProperty("exo:data").getString()); if (wsName.equals("ws")) { @@ -956,8 +951,8 @@ // restore RepositoryEntry newRepositoryEntry = - makeRepositoryEntry(repositoryNameToRestore, getReposityToBackup().getConfiguration(), - dataSourceToRepositoryRestore, null); + makeRepositoryEntry(repositoryNameToRestore, getReposityToBackup().getConfiguration(), + dataSourceToRepositoryRestore, null); File backLog = new File(bch.getLogFilePath()); if (backLog.exists()) @@ -972,7 +967,7 @@ JobRepositoryRestore job = backup.getLastRepositoryRestore(repositoryNameToRestore); while (job.getStateRestore() != JobRepositoryRestore.REPOSITORY_RESTORE_SUCCESSFUL - || job.getStateRestore() == JobRepositoryRestore.REPOSITORY_RESTORE_FAIL) + || job.getStateRestore() == JobRepositoryRestore.REPOSITORY_RESTORE_FAIL) { Thread.yield(); Thread.sleep(50); @@ -986,10 +981,10 @@ SessionImpl back1 = null; try { - back1 = (SessionImpl) restoredRepository.login(credentials, wsName); + 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()); + .getProperty("exo:data").getString()); } catch (Exception e) { @@ -1036,8 +1031,8 @@ // restore RepositoryEntry newRepositoryEntry = - makeRepositoryEntry(repositoryNameToRestore, getReposityToBackup().getConfiguration(), - dataSourceToRepositoryRestore, null); + makeRepositoryEntry(repositoryNameToRestore, getReposityToBackup().getConfiguration(), + dataSourceToRepositoryRestore, null); // create workspace mappingS Map<String, String> workspaceMapping = new HashedMap(); @@ -1072,7 +1067,7 @@ JobRepositoryRestore job = backup.getLastRepositoryRestore(repositoryNameToRestore); while (job.getStateRestore() != JobRepositoryRestore.REPOSITORY_RESTORE_SUCCESSFUL - || job.getStateRestore() == JobRepositoryRestore.REPOSITORY_RESTORE_FAIL) + || job.getStateRestore() == JobRepositoryRestore.REPOSITORY_RESTORE_FAIL) { Thread.yield(); Thread.sleep(50); @@ -1086,10 +1081,10 @@ SessionImpl back1 = null; try { - back1 = (SessionImpl) restoredRepository.login(credentials, workspaceMapping.get(wsName)); + 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()); + .getProperty("exo:data").getString()); } catch (Exception e) { @@ -1167,8 +1162,7 @@ // restore RepositoryEntry newRepositoryEntry = - makeRepositoryEntry(repoName, getReposityToBackup().getConfiguration(), dataSourceToRepositoryRestore, - null); + makeRepositoryEntry(repoName, getReposityToBackup().getConfiguration(), dataSourceToRepositoryRestore, null); //create broken system workspaceEntry newRepositoryEntry.getWorkspaceEntries().get(0).getQueryHandler().setType("gg"); @@ -1261,7 +1255,7 @@ SessionImpl back1 = null; try { - back1 = (SessionImpl) getReposityToBackup().login(credentials, workspaceNameToRestore); + back1 = (SessionImpl)getReposityToBackup().login(credentials, workspaceNameToRestore); Node node_101 = back1.getRootNode().getNode("node_101"); assertNotNull(node_101); @@ -1328,8 +1322,7 @@ fail("Can't get fullBackup chain"); // restore - RepositoryEntry re = - (RepositoryEntry) ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); + RepositoryEntry re = (RepositoryEntry)ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); WorkspaceEntry ws1 = null; for (WorkspaceEntry we : re.getWorkspaceEntries()) { @@ -1373,9 +1366,9 @@ fail("There are no backup files in " + backDir.getAbsolutePath()); } - public void testExistedWorkspaceRestore() throws Exception + public void ExistedWorkspaceRestore() throws Exception { - SessionImpl ws1Session = (SessionImpl) repositoryService.getRepository("db7").login(credentials, "ws1"); + SessionImpl ws1Session = (SessionImpl)repositoryService.getRepository("db7").login(credentials, "ws1"); // backup File backDir = new File("target/backup/" + getUUIndex()); @@ -1407,8 +1400,7 @@ fail("Can't get fullBackup chain"); // restore - RepositoryEntry re = - (RepositoryEntry) ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); + RepositoryEntry re = (RepositoryEntry)ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); WorkspaceEntry ws1 = null; for (WorkspaceEntry we : re.getWorkspaceEntries()) { @@ -1433,10 +1425,10 @@ SessionImpl back1 = null; try { - back1 = (SessionImpl) repositoryService.getRepository("db7").login(credentials, "ws1"); + back1 = (SessionImpl)repositoryService.getRepository("db7").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()); + .getProperty("exo:data").getString()); } catch (Exception e) { @@ -1485,8 +1477,7 @@ fail("Can't get fullBackup chain"); // restore - RepositoryEntry re = - (RepositoryEntry) ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); + RepositoryEntry re = (RepositoryEntry)ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); WorkspaceEntry ws1 = null; for (WorkspaceEntry we : re.getWorkspaceEntries()) { @@ -1508,7 +1499,7 @@ backup.restoreExistingWorkspace(bchLog, repositoryNameToBackup, ws1, true); while (backup.getLastRestore(repositoryNameToBackup, ws1.getName()).getStateRestore() != JobWorkspaceRestore.RESTORE_SUCCESSFUL - && backup.getLastRestore(repositoryNameToBackup, ws1.getName()).getStateRestore() != JobWorkspaceRestore.RESTORE_FAIL) + && backup.getLastRestore(repositoryNameToBackup, ws1.getName()).getStateRestore() != JobWorkspaceRestore.RESTORE_FAIL) { Thread.sleep(50); } @@ -1518,11 +1509,11 @@ try { back1 = - (SessionImpl) repositoryService.getRepository(repositoryNameToBackup).login(credentials, - workspaceNameToBackup); + (SessionImpl)repositoryService.getRepository(repositoryNameToBackup).login(credentials, + workspaceNameToBackup); Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") - .getProperty("exo:data").getString()); + .getProperty("exo:data").getString()); } catch (Exception e) { @@ -1572,8 +1563,7 @@ fail("Can't get fullBackup chain"); // restore - RepositoryEntry re = - (RepositoryEntry) ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); + RepositoryEntry re = (RepositoryEntry)ws1Session.getContainer().getComponentInstanceOfType(RepositoryEntry.class); WorkspaceEntry ws1 = null; for (WorkspaceEntry we : re.getWorkspaceEntries()) { @@ -1595,7 +1585,7 @@ backup.restoreExistingWorkspace(bchLog.getBackupId(), repositoryNameToBackup, ws1, true); while (backup.getLastRestore(repositoryNameToBackup, ws1.getName()).getStateRestore() != JobWorkspaceRestore.RESTORE_SUCCESSFUL - && backup.getLastRestore(repositoryNameToBackup, ws1.getName()).getStateRestore() != JobWorkspaceRestore.RESTORE_FAIL) + && backup.getLastRestore(repositoryNameToBackup, ws1.getName()).getStateRestore() != JobWorkspaceRestore.RESTORE_FAIL) { Thread.sleep(50); } @@ -1605,11 +1595,11 @@ try { back1 = - (SessionImpl) repositoryService.getRepository(repositoryNameToBackup).login(credentials, - workspaceNameToBackup); + (SessionImpl)repositoryService.getRepository(repositoryNameToBackup).login(credentials, + workspaceNameToBackup); Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") - .getProperty("exo:data").getString()); + .getProperty("exo:data").getString()); } catch (Exception e) { @@ -1655,7 +1645,7 @@ // restore RepositoryEntry re = - makeRepositoryEntry(repositoryNameToBackup, getReposityToBackup().getConfiguration(), null, null); + makeRepositoryEntry(repositoryNameToBackup, getReposityToBackup().getConfiguration(), null, null); File backLog = new File(bch.getLogFilePath()); if (backLog.exists()) @@ -1668,7 +1658,7 @@ backup.restoreExistingRepository(bchLog, re, false); assertEquals(JobWorkspaceRestore.RESTORE_SUCCESSFUL, backup.getLastRepositoryRestore(repositoryNameToBackup) - .getStateRestore()); + .getStateRestore()); // check ManageableRepository restoredRepository = repositoryService.getRepository(repositoryNameToBackup); @@ -1678,10 +1668,10 @@ SessionImpl back1 = null; try { - back1 = (SessionImpl) restoredRepository.login(credentials, wsName); + 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()); + .getProperty("exo:data").getString()); } catch (Exception e) { @@ -1701,8 +1691,8 @@ public void testExistedRepositoryRestoreSingelDB() throws Exception { - RepositoryImpl repositoryDB7 = (RepositoryImpl) repositoryService.getRepository(repositoryNameToBackupSingleDB); - SessionImpl sessionWS = (SessionImpl) repositoryDB7.login(credentials, workspaceNameToBackup); + RepositoryImpl repositoryDB7 = (RepositoryImpl)repositoryService.getRepository(repositoryNameToBackupSingleDB); + SessionImpl sessionWS = (SessionImpl)repositoryDB7.login(credentials, workspaceNameToBackup); // backup File backDir = new File("target/backup/" + getUUIndex()); @@ -1731,7 +1721,7 @@ // restore RepositoryEntry baseRE = - (RepositoryEntry) sessionWS.getContainer().getComponentInstanceOfType(RepositoryEntry.class); + (RepositoryEntry)sessionWS.getContainer().getComponentInstanceOfType(RepositoryEntry.class); RepositoryEntry re = makeRepositoryEntry(baseRE.getName(), baseRE, null, null); File backLog = new File(bch.getLogFilePath()); @@ -1745,7 +1735,7 @@ backup.restoreExistingRepository(bchLog, re, false); assertEquals(JobWorkspaceRestore.RESTORE_SUCCESSFUL, backup.getLastRepositoryRestore(re.getName()) - .getStateRestore()); + .getStateRestore()); // check ManageableRepository restoredRepository = repositoryService.getRepository(repositoryNameToBackupSingleDB); @@ -1755,10 +1745,10 @@ SessionImpl back1 = null; try { - back1 = (SessionImpl) restoredRepository.login(credentials, wsName); + 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()); + .getProperty("exo:data").getString()); } catch (Exception e) { @@ -1805,7 +1795,7 @@ // restore RepositoryEntry re = - makeRepositoryEntry(repositoryNameToBackup, getReposityToBackup().getConfiguration(), null, null); + makeRepositoryEntry(repositoryNameToBackup, getReposityToBackup().getConfiguration(), null, null); File backLog = new File(bch.getLogFilePath()); if (backLog.exists()) @@ -1820,13 +1810,13 @@ JobRepositoryRestore job = backup.getLastRepositoryRestore(repositoryNameToBackup); while (job.getStateRestore() != JobRepositoryRestore.REPOSITORY_RESTORE_SUCCESSFUL - && job.getStateRestore() != JobRepositoryRestore.REPOSITORY_RESTORE_FAIL) + && job.getStateRestore() != JobRepositoryRestore.REPOSITORY_RESTORE_FAIL) { Thread.sleep(50); } - assertEquals(JobRepositoryRestore.REPOSITORY_RESTORE_SUCCESSFUL, backup.getLastRepositoryRestore( - repositoryNameToBackup).getStateRestore()); + assertEquals(JobRepositoryRestore.REPOSITORY_RESTORE_SUCCESSFUL, + backup.getLastRepositoryRestore(repositoryNameToBackup).getStateRestore()); // check ManageableRepository restoredRepository = repositoryService.getRepository(repositoryNameToBackup); @@ -1836,10 +1826,10 @@ SessionImpl back1 = null; try { - back1 = (SessionImpl) restoredRepository.login(credentials, wsName); + 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()); + .getProperty("exo:data").getString()); } catch (Exception e) { @@ -1886,7 +1876,7 @@ // restore RepositoryEntry re = - makeRepositoryEntry(repositoryNameToBackup, getReposityToBackup().getConfiguration(), null, null); + makeRepositoryEntry(repositoryNameToBackup, getReposityToBackup().getConfiguration(), null, null); File backLog = new File(bch.getLogFilePath()); if (backLog.exists()) @@ -1901,13 +1891,13 @@ JobRepositoryRestore job = backup.getLastRepositoryRestore(repositoryNameToBackup); while (job.getStateRestore() != JobRepositoryRestore.REPOSITORY_RESTORE_SUCCESSFUL - && job.getStateRestore() != JobRepositoryRestore.REPOSITORY_RESTORE_FAIL) + && job.getStateRestore() != JobRepositoryRestore.REPOSITORY_RESTORE_FAIL) { Thread.sleep(50); } assertEquals(JobWorkspaceRestore.RESTORE_SUCCESSFUL, backup.getLastRepositoryRestore(repositoryNameToBackup) - .getStateRestore()); + .getStateRestore()); // check ManageableRepository restoredRepository = repositoryService.getRepository(repositoryNameToBackup); @@ -1917,10 +1907,10 @@ SessionImpl back1 = null; try { - back1 = (SessionImpl) restoredRepository.login(credentials, wsName); + 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()); + .getProperty("exo:data").getString()); } catch (Exception e) { @@ -1940,8 +1930,8 @@ public void testExistedWorkspaceRestoreSingelDB() throws Exception { - RepositoryImpl repositoryDB7 = (RepositoryImpl) repositoryService.getRepository(repositoryNameToBackupSingleDB); - SessionImpl sessionWS = (SessionImpl) repositoryDB7.login(credentials, workspaceNameToBackup); + RepositoryImpl repositoryDB7 = (RepositoryImpl)repositoryService.getRepository(repositoryNameToBackupSingleDB); + SessionImpl sessionWS = (SessionImpl)repositoryDB7.login(credentials, workspaceNameToBackup); // backup File backDir = new File("target/backup/" + getUUIndex()); @@ -1973,7 +1963,7 @@ fail("Can't get fullBackup chain"); // restore - RepositoryEntry re = (RepositoryEntry) sessionWS.getContainer().getComponentInstanceOfType(RepositoryEntry.class); + RepositoryEntry re = (RepositoryEntry)sessionWS.getContainer().getComponentInstanceOfType(RepositoryEntry.class); WorkspaceEntry ws1 = null; for (WorkspaceEntry we : re.getWorkspaceEntries()) { @@ -1998,11 +1988,11 @@ SessionImpl back1 = null; try { - repositoryDB7 = (RepositoryImpl) repositoryService.getRepository(repositoryNameToBackupSingleDB); - back1 = (SessionImpl) repositoryDB7.login(credentials, workspaceNameToBackup); + repositoryDB7 = (RepositoryImpl)repositoryService.getRepository(repositoryNameToBackupSingleDB); + back1 = (SessionImpl)repositoryDB7.login(credentials, workspaceNameToBackup); Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") - .getProperty("exo:data").getString()); + .getProperty("exo:data").getString()); } catch (Exception e) { @@ -2066,11 +2056,11 @@ try { back1 = - (SessionImpl) repositoryService.getRepository(repositoryNameToBackup).login(credentials, - workspaceNameToBackup); + (SessionImpl)repositoryService.getRepository(repositoryNameToBackup).login(credentials, + workspaceNameToBackup); Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") - .getProperty("exo:data").getString()); + .getProperty("exo:data").getString()); } catch (Exception e) { @@ -2128,7 +2118,7 @@ backup.restoreExistingRepository(bchLog.getBackupId(), false); assertEquals(JobWorkspaceRestore.RESTORE_SUCCESSFUL, backup.getLastRepositoryRestore(repositoryNameToBackup) - .getStateRestore()); + .getStateRestore()); // check ManageableRepository restoredRepository = repositoryService.getRepository(repositoryNameToBackup); @@ -2138,10 +2128,10 @@ SessionImpl back1 = null; try { - back1 = (SessionImpl) restoredRepository.login(credentials, wsName); + 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()); + .getProperty("exo:data").getString()); } catch (Exception e) { @@ -2208,10 +2198,10 @@ SessionImpl back1 = null; try { - back1 = (SessionImpl) repositoryService.getRepository(repositoryNameToBackup).login(credentials, "ws1"); + back1 = (SessionImpl)repositoryService.getRepository(repositoryNameToBackup).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()); + .getProperty("exo:data").getString()); } catch (Exception e) { @@ -2271,7 +2261,7 @@ backup.restoreRepository(bchLog.getBackupId(), false); assertEquals(JobWorkspaceRestore.RESTORE_SUCCESSFUL, backup.getLastRepositoryRestore(repositoryNameToBackup) - .getStateRestore()); + .getStateRestore()); // check ManageableRepository restoredRepository = repositoryService.getRepository(repositoryNameToBackup); @@ -2281,10 +2271,10 @@ SessionImpl back1 = null; try { - back1 = (SessionImpl) restoredRepository.login(credentials, wsName); + 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()); + .getProperty("exo:data").getString()); } catch (Exception e) { @@ -2345,7 +2335,7 @@ backup.restore(bchLog, null, false); assertEquals(JobWorkspaceRestore.RESTORE_SUCCESSFUL, backup.getLastRepositoryRestore(repositoryNameToBackup) - .getStateRestore()); + .getStateRestore()); // check ManageableRepository restoredRepository = repositoryService.getRepository(repositoryNameToBackup); @@ -2355,10 +2345,10 @@ SessionImpl back1 = null; try { - back1 = (SessionImpl) restoredRepository.login(credentials, wsName); + 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()); + .getProperty("exo:data").getString()); } catch (Exception e) { @@ -2434,10 +2424,10 @@ SessionImpl back1 = null; try { - back1 = (SessionImpl) getReposityToBackup().login(credentials, workspaceNameToBackup); + back1 = (SessionImpl)getReposityToBackup().login(credentials, workspaceNameToBackup); Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") - .getProperty("exo:data").getString()); + .getProperty("exo:data").getString()); } catch (Exception e) { @@ -2500,10 +2490,10 @@ SessionImpl back1 = null; try { - back1 = (SessionImpl) getReposityToBackup().login(credentials, workspaceNameToBackup); + back1 = (SessionImpl)getReposityToBackup().login(credentials, workspaceNameToBackup); Node ws1backTestRoot = back1.getRootNode().getNode("backupTest"); assertEquals("Restored content should be same", "property-5", ws1backTestRoot.getNode("node_5") - .getProperty("exo:data").getString()); + .getProperty("exo:data").getString()); } catch (Exception e) { @@ -2561,7 +2551,7 @@ backup.restoreExistingRepository(bchLog.getBackupConfig().getBackupDir(), false); assertEquals(JobWorkspaceRestore.RESTORE_SUCCESSFUL, backup.getLastRepositoryRestore(repositoryNameToBackup) - .getStateRestore()); + .getStateRestore()); // check ManageableRepository restoredRepository = repositoryService.getRepository(repositoryNameToBackup); @@ -2571,10 +2561,10 @@ SessionImpl back1 = null; try { - back1 = (SessionImpl) restoredRepository.login(credentials, wsName); + 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()); + .getProperty("exo:data").getString()); } catch (Exception e) { @@ -2640,10 +2630,10 @@ SessionImpl back1 = null; try { - back1 = (SessionImpl) getReposityToBackup().login(credentials, "ws1"); + back1 = (SessionImpl)getReposityToBackup().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()); + .getProperty("exo:data").getString()); } catch (Exception e) { @@ -2703,7 +2693,7 @@ backup.restoreRepository(bchLog.getBackupConfig().getBackupDir(), false); assertEquals(JobWorkspaceRestore.RESTORE_SUCCESSFUL, backup.getLastRepositoryRestore(repositoryNameToBackup) - .getStateRestore()); + .getStateRestore()); // check ManageableRepository restoredRepository = repositoryService.getRepository(repositoryNameToBackup); @@ -2713,10 +2703,10 @@ SessionImpl back1 = null; try { - back1 = (SessionImpl) restoredRepository.login(credentials, wsName); + 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()); + .getProperty("exo:data").getString()); } catch (Exception e) { 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 2011-01-26 16:18:11 UTC (rev 3890) +++ jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/TestRdbmsFullBackupJob.java 2011-01-26 16:19:28 UTC (rev 3891) @@ -19,6 +19,7 @@ package org.exoplatform.services.jcr.ext.backup; import org.exoplatform.services.jcr.ext.backup.impl.rdbms.FullBackupJob; +import org.exoplatform.services.jcr.impl.core.query.SystemSearchManager; import java.io.File; import java.net.URL; @@ -48,17 +49,17 @@ URL url = job.getStorageURL(); assertNotNull(url); - File valuesDir = new File(url.getFile(), FullBackupJob.VALUE_STORAGE_DIR); + File valuesDir = new File(url.getFile(), "values"); assertTrue(valuesDir.exists()); String values[] = valuesDir.list(); assertEquals(values.length, 1); assertTrue(new File(valuesDir, values[0]).isDirectory()); - File indexesDir = new File(url.getFile(), FullBackupJob.INDEX_DIR); + File indexesDir = new File(url.getFile(), "index"); assertTrue(indexesDir.exists()); - indexesDir = new File(url.getFile(), FullBackupJob.SYSTEM_INDEX_DIR); + indexesDir = new File(url.getFile(), "index" + "_" + SystemSearchManager.INDEX_DIR_SUFFIX); assertTrue(indexesDir.exists()); assertTrue(new File(url.getFile(), "JCR_MITEM.dump").exists()); @@ -88,13 +89,13 @@ URL url = job.getStorageURL(); assertNotNull(url); - File valuesDir = new File(url.getFile(), FullBackupJob.VALUE_STORAGE_DIR); + File valuesDir = new File(url.getFile(), "values"); assertFalse(valuesDir.exists()); - File indexesDir = new File(url.getFile(), FullBackupJob.INDEX_DIR); + File indexesDir = new File(url.getFile(), "index"); assertTrue(indexesDir.exists()); - indexesDir = new File(url.getFile(), FullBackupJob.SYSTEM_INDEX_DIR); + indexesDir = new File(url.getFile(), "index" + "_" + SystemSearchManager.INDEX_DIR_SUFFIX); assertFalse(indexesDir.exists()); assertTrue(new File(url.getFile(), "JCR_MITEM.dump").exists()); 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 2011-01-26 16:18:11 UTC (rev 3890) +++ jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/TestRdbmsWorkspaceInitializer.java 2011-01-26 16:19:28 UTC (rev 3891) @@ -45,114 +45,6 @@ { TesterConfigurationHelper helper = TesterConfigurationHelper.getInstence(); - public void testRDBMSInitializerSystemWorkspace() throws Exception - { - FullBackupJob job = new FullBackupJob(); - BackupConfig config = new BackupConfig(); - config.setRepository("db1"); - config.setWorkspace("ws"); - config.setBackupDir(new File("target/backup/testJob/testRDBMSInitializerSystemWorkspace")); - - Calendar calendar = Calendar.getInstance(); - - job.init(repositoryService.getRepository("db1"), "ws", config, calendar); - job.run(); - - URL url = job.getStorageURL(); - - for (WorkspaceEntry workspaceEntry : repositoryService.getRepository("db1").getConfiguration() - .getWorkspaceEntries()) - { - if (workspaceEntry.getName().equals("ws")) - { - String newValueStoragePath = "target/temp/values/" + IdGenerator.generate(); - String newIndexPath = "target/temp/index/" + IdGenerator.generate(); - - // set the initializer - WorkspaceEntry newEntry = - helper.getNewWs("ws", true, null, newValueStoragePath, newIndexPath, workspaceEntry.getContainer(), - workspaceEntry.getContainer().getValueStorages()); - - WorkspaceInitializerEntry wiEntry = new WorkspaceInitializerEntry(); - wiEntry.setType(RdbmsWorkspaceInitializer.class.getCanonicalName()); - - List<SimpleParameterEntry> wieParams = new ArrayList<SimpleParameterEntry>(); - wieParams.add(new SimpleParameterEntry(SysViewWorkspaceInitializer.RESTORE_PATH_PARAMETER, new File(url - .getFile()).getParent())); - - wiEntry.setParameters(wieParams); - - newEntry.setInitializer(wiEntry); - - TesterRdbmsWorkspaceInitializer initializer = - new TesterRdbmsWorkspaceInitializer(newEntry, repositoryService.getRepository("db1").getConfiguration(), - cacheableDataManager, null, null, null, (ValueFactoryImpl)valueFactory, null, repositoryService, new FileCleanerHolder()); - - initializer.restoreValueFiles(); - assertTrue(new File(newValueStoragePath).list().length > 0); - - initializer.restoreIndexFiles(); - assertTrue(new File(newIndexPath).list().length > 0); - assertTrue(new File(newIndexPath + "_" + SystemSearchManager.INDEX_DIR_SUFFIX).exists()); - assertTrue(new File(newIndexPath + "_" + SystemSearchManager.INDEX_DIR_SUFFIX).list().length > 0); - } - } - } - - public void testRDBMSInitializer() throws Exception - { - FullBackupJob job = new FullBackupJob(); - BackupConfig config = new BackupConfig(); - config.setRepository("db1"); - config.setWorkspace("ws1"); - config.setBackupDir(new File("target/backup/testJob/testRDBMSInitializer")); - - Calendar calendar = Calendar.getInstance(); - - job.init(repositoryService.getRepository("db1"), "ws1", config, calendar); - job.run(); - - URL url = job.getStorageURL(); - - for (WorkspaceEntry workspaceEntry : repositoryService.getRepository("db1").getConfiguration() - .getWorkspaceEntries()) - { - if (workspaceEntry.getName().equals("ws1")) - { - String newValueStoragePath = "target/temp/values/" + IdGenerator.generate(); - String newIndexPath = "target/temp/index/" + IdGenerator.generate(); - - // set the initializer - WorkspaceEntry newEntry = - helper.getNewWs("ws1", true, null, newValueStoragePath, newIndexPath, workspaceEntry.getContainer(), - workspaceEntry.getContainer().getValueStorages()); - - WorkspaceInitializerEntry wiEntry = new WorkspaceInitializerEntry(); - wiEntry.setType(RdbmsWorkspaceInitializer.class.getCanonicalName()); - - List<SimpleParameterEntry> wieParams = new ArrayList<SimpleParameterEntry>(); - wieParams.add(new SimpleParameterEntry(SysViewWorkspaceInitializer.RESTORE_PATH_PARAMETER, new File(url - .getFile()).getParent())); - - wiEntry.setParameters(wieParams); - - newEntry.setInitializer(wiEntry); - - TesterRdbmsWorkspaceInitializer initializer = - new TesterRdbmsWorkspaceInitializer(newEntry, repositoryService.getRepository("db1").getConfiguration(), - cacheableDataManager, null, null, null, (ValueFactoryImpl)valueFactory, null, repositoryService, - new FileCleanerHolder()); - - initializer.restoreValueFiles(); - assertFalse(new File(newValueStoragePath).exists()); - - initializer.restoreIndexFiles(); - assertTrue(new File(newIndexPath).list().length > 0); - assertFalse(new File(newIndexPath + "_" + SystemSearchManager.INDEX_DIR_SUFFIX).exists()); - } - } - } - public void testRDBMSInitializerRestoreTablesMultiDB() throws Exception { FullBackupJob job = new FullBackupJob(); @@ -221,6 +113,10 @@ repositoryService.getRepository("db1").configWorkspace(newEntry); repositoryService.getRepository("db1").createWorkspace(newEntry.getName()); + + assertFalse(new File(newValueStoragePath).exists()); + assertTrue(new File(newIndexPath).list().length > 0); + assertFalse(new File(newIndexPath + "_" + SystemSearchManager.INDEX_DIR_SUFFIX).exists()); } break; @@ -299,6 +195,10 @@ repositoryService.getRepository("db1").configWorkspace(newEntry); repositoryService.getRepository("db1").createWorkspace(newEntry.getName()); + + assertFalse(new File(newValueStoragePath).exists()); + assertTrue(new File(newIndexPath).list().length > 0); + assertFalse(new File(newIndexPath + "_" + SystemSearchManager.INDEX_DIR_SUFFIX).exists()); } break; Modified: jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/load/TestLoadBackup.java =================================================================== --- jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/load/TestLoadBackup.java 2011-01-26 16:18:11 UTC (rev 3890) +++ jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/load/TestLoadBackup.java 2011-01-26 16:19:28 UTC (rev 3891) @@ -33,6 +33,9 @@ import org.exoplatform.services.jcr.ext.backup.BackupJob; 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.RepositoryBackupChainLog; +import org.exoplatform.services.jcr.ext.backup.RepositoryBackupConfig; import org.exoplatform.services.jcr.ext.backup.impl.BackupManagerImpl; import org.exoplatform.services.jcr.ext.backup.impl.JobWorkspaceRestore; import org.exoplatform.services.jcr.impl.Constants; @@ -43,8 +46,6 @@ import java.io.File; import java.io.FileInputStream; -import java.sql.Connection; -import java.sql.Statement; import java.util.ArrayList; import java.util.Iterator; import java.util.List; @@ -57,8 +58,6 @@ import javax.jcr.Value; import javax.jcr.version.VersionException; import javax.jcr.version.VersionHistory; -import javax.naming.InitialContext; -import javax.sql.DataSource; /** * Created by The eXo Platform SAS. @@ -70,11 +69,13 @@ */ public class TestLoadBackup extends BaseStandaloneTest { - protected final String REPOSITORY_NAME = "db7"; + protected final String REPOSITORY_NAME_SINGLE_DB = "db7"; + protected final String REPOSITORY_NAME_MULTI_DB = "db8"; + protected final String WORKSPACE_NAME = "ws1"; - protected final int WRITER_COUNT = 100; + protected final int WRITER_COUNT = 0; protected final String FULL_BACKUP_TYPE = "org.exoplatform.services.jcr.ext.backup.impl.rdbms.FullBackupJob"; @@ -120,7 +121,7 @@ * * @throws Exception */ - public void testBackupRestore() throws Exception + public void _testBackupRestore() throws Exception { BackupManagerImpl backupManagerImpl = (BackupManagerImpl)getBackupManager(); @@ -130,7 +131,8 @@ //writers for (int i = 0; i < WRITER_COUNT; i++) { - Session writerSession = repositoryService.getRepository(REPOSITORY_NAME).login(credentials, WORKSPACE_NAME); + Session writerSession = + repositoryService.getRepository(REPOSITORY_NAME_SINGLE_DB).login(credentials, WORKSPACE_NAME); TreeWriterThread writer = new TreeWriterThread(writerSession, "subnode" + i); writer.start(); threads.add(writer); @@ -149,14 +151,14 @@ backupManagerImpl.start(); BackupConfig config = new BackupConfig(); - config.setRepository(REPOSITORY_NAME); + config.setRepository(REPOSITORY_NAME_SINGLE_DB); config.setWorkspace(WORKSPACE_NAME); config.setBackupType(BACKUP_TYPE); config.setBackupDir(backDir); backupManagerImpl.startBackup(config); - bch = backupManagerImpl.findBackup(REPOSITORY_NAME, WORKSPACE_NAME); + bch = backupManagerImpl.findBackup(REPOSITORY_NAME_SINGLE_DB, WORKSPACE_NAME); // wait till full backup will be stopped while (bch.getFullBackupState() != BackupJob.FINISHED) @@ -191,7 +193,7 @@ { fail("Can't get fullBackup chain"); } - Thread.sleep(5 * 1000); + Thread.sleep(10 * 1000); System.out.println(" ============ BACKUP FINISHED ============"); @@ -208,9 +210,9 @@ assertNotNull(bchLog.getStartedTime()); assertNotNull(bchLog.getFinishedTime()); - backupManagerImpl.restore(bchLog, REPOSITORY_NAME, ws1back, false); + backupManagerImpl.restore(bchLog, REPOSITORY_NAME_SINGLE_DB, ws1back, false); - JobWorkspaceRestore restore = backupManagerImpl.getLastRestore(REPOSITORY_NAME, ws1back.getName()); + JobWorkspaceRestore restore = backupManagerImpl.getLastRestore(REPOSITORY_NAME_SINGLE_DB, ws1back.getName()); if (restore != null) { while (restore.getStateRestore() == JobWorkspaceRestore.RESTORE_FAIL @@ -233,10 +235,442 @@ System.out.println(" ============ CHECKING INTEGRITY ============"); - checkIntegrity((NodeImpl)repositoryService.getRepository(REPOSITORY_NAME).login(credentials, "ws1back") + checkIntegrity((NodeImpl)repositoryService.getRepository(REPOSITORY_NAME_SINGLE_DB).login(credentials, "ws1back") .getRootNode()); } + /** + * Test Backup/Restore. + * + * @throws Exception + */ + public void testBackupRestoreExistingWorkspaceSingleDB() throws Exception + { + WorkspaceEntry entry = null; + for (WorkspaceEntry en : repositoryService.getRepository(REPOSITORY_NAME_SINGLE_DB).getConfiguration() + .getWorkspaceEntries()) + { + if (en.getName().equals(WORKSPACE_NAME)) + { + entry = en; + break; + } + } + + BackupManagerImpl backupManagerImpl = (BackupManagerImpl)getBackupManager(); + + List<TreeWriterThread> threads = new ArrayList<TreeWriterThread>(); + List<Session> sessions = new ArrayList<Session>(); + + //writers + for (int i = 0; i < WRITER_COUNT; i++) + { + Session writerSession = + repositoryService.getRepository(REPOSITORY_NAME_SINGLE_DB).login(credentials, WORKSPACE_NAME); + TreeWriterThread writer = new TreeWriterThread(writerSession, "subnode" + i); + writer.start(); + threads.add(writer); + sessions.add(writerSession); + } + + // backup + File backDir = new File("target/backup/ws1"); + backDir.mkdirs(); + BackupChain bch = null; + + backupManagerImpl.start(); + + BackupConfig config = new BackupConfig(); + config.setRepository(REPOSITORY_NAME_SINGLE_DB); + config.setWorkspace(WORKSPACE_NAME); + config.setBackupType(BACKUP_TYPE); + config.setBackupDir(backDir); + + Thread.sleep(5 * 1000); + + System.out.println(" ============ BACKUP START ============"); + + backupManagerImpl.startBackup(config); + + bch = backupManagerImpl.findBackup(REPOSITORY_NAME_SINGLE_DB, WORKSPACE_NAME); + + // wait till full backup will be stopped + while (bch.getFullBackupState() != BackupJob.FINISHED) + { + Thread.yield(); + Thread.sleep(30); + } + + if (bch != null) + { + backupManagerImpl.stopBackup(bch); + } + else + { + fail("Can't get fullBackup chain"); + } + + System.out.println(" ============ BACKUP FINISHED ============"); + + // restore + File backLog = new File(bch.getLogFilePath()); + if (backLog.exists()) + { + BackupChainLog bchLog = new BackupChainLog(backLog); + + System.out.println(" ============ RESTORE START ============"); + + assertNotNull(bchLog.getStartedTime()); + assertNotNull(bchLog.getFinishedTime()); + + backupManagerImpl.restoreExistingWorkspace(bchLog, REPOSITORY_NAME_SINGLE_DB, entry, false); + + JobWorkspaceRestore restore = backupManagerImpl.getLastRestore(REPOSITORY_NAME_SINGLE_DB, WORKSPACE_NAME); + if (restore != null) + { + while (restore.getStateRestore() == JobWorkspaceRestore.RESTORE_FAIL + || restore.getStateRestore() == JobWorkspaceRestore.RESTORE_SUCCESSFUL) + { + Thread.sleep(1000); + } + + if (restore.getStateRestore() == JobWorkspaceRestore.RESTORE_FAIL) + { + restore.getRestoreException().printStackTrace(); + fail(restore.getRestoreException().getMessage()); + } + } + } + else + { + fail("There are no backup files in " + backDir.getAbsolutePath()); + } + + System.out.println(" ============ CHECKING INTEGRITY ============"); + + checkIntegrity((NodeImpl)repositoryService.getRepository(REPOSITORY_NAME_SINGLE_DB) + .login(credentials, WORKSPACE_NAME) + .getRootNode()); + } + + /** + * Test Backup/Restore. + * + * @throws Exception + */ + public void testBackupRestoreExistingRepositorySingleDB() throws Exception + { + + BackupManagerImpl backupManagerImpl = (BackupManagerImpl)getBackupManager(); + + List<TreeWriterThread> threads = new ArrayList<TreeWriterThread>(); + List<Session> sessions = new ArrayList<Session>(); + + //writers + for (int i = 0; i < WRITER_COUNT; i++) + { + Session writerSession = + repositoryService.getRepository(REPOSITORY_NAME_SINGLE_DB).login(credentials, WORKSPACE_NAME); + TreeWriterThread writer = new TreeWriterThread(writerSession, "subnode" + i); + writer.start(); + threads.add(writer); + sessions.add(writerSession); + } + + // backup + File backDir = new File("target/backup/db7"); + backDir.mkdirs(); + RepositoryBackupChain bch = null; + + backupManagerImpl.start(); + + RepositoryBackupConfig config = new RepositoryBackupConfig(); + config.setRepository(REPOSITORY_NAME_SINGLE_DB); + config.setBackupType(BACKUP_TYPE); + config.setBackupDir(backDir); + + Thread.sleep(5 * 1000); + + System.out.println(" ============ BACKUP START ============"); + + backupManagerImpl.startBackup(config); + + bch = backupManagerImpl.findRepositoryBackup(REPOSITORY_NAME_SINGLE_DB); + + // wait till full backup will be stopped + while (bch.getState() != BackupJob.FINISHED) + { + Thread.yield(); + Thread.sleep(30); + } + + if (bch != null) + { + backupManagerImpl.stopBackup(bch); + } + + System.out.println(" ============ BACKUP FINISHED ============"); + + // restore + File backLog = new File(bch.getLogFilePath()); + if (backLog.exists()) + { + RepositoryBackupChainLog bchLog = new RepositoryBackupChainLog(backLog); + + System.out.println(" ============ RESTORE START ============"); + + assertNotNull(bchLog.getStartedTime()); + assertNotNull(bchLog.getFinishedTime()); + + backupManagerImpl.restoreExistingRepository(bchLog, repositoryService.getRepository(REPOSITORY_NAME_SINGLE_DB) + .getConfiguration(), false); + + JobWorkspaceRestore restore = backupManagerImpl.getLastRestore(REPOSITORY_NAME_SINGLE_DB, WORKSPACE_NAME); + if (restore != null) + { + while (restore.getStateRestore() == JobWorkspaceRestore.RESTORE_FAIL + || restore.getStateRestore() == JobWorkspaceRestore.RESTORE_SUCCESSFUL) + { + Thread.sleep(1000); + } + + if (restore.getStateRestore() == JobWorkspaceRestore.RESTORE_FAIL) + { + restore.getRestoreException().printStackTrace(); + fail(restore.getRestoreException().getMessage()); + } + } + } + else + { + fail("There are no backup files in " + backDir.getAbsolutePath()); + } + + System.out.println(" ============ CHECKING INTEGRITY ============"); + + for (String wsName : repositoryService.getRepository(REPOSITORY_NAME_SINGLE_DB).getWorkspaceNames()) + { + checkIntegrity((NodeImpl)repositoryService.getRepository(REPOSITORY_NAME_SINGLE_DB).login(credentials, wsName) + .getRootNode()); + } + } + + /** + * Test Backup/Restore. + * + * @throws Exception + */ + public void testBackupRestoreExistingWorkspaceMultiDB() throws Exception + { + WorkspaceEntry entry = null; + for (WorkspaceEntry en : repositoryService.getRepository(REPOSITORY_NAME_MULTI_DB).getConfiguration() + .getWorkspaceEntries()) + { + if (en.getName().equals(WORKSPACE_NAME)) + { + entry = en; + break; + } + } + + BackupManagerImpl backupManagerImpl = (BackupManagerImpl)getBackupManager(); + + List<TreeWriterThread> threads = new ArrayList<TreeWriterThread>(); + List<Session> sessions = new ArrayList<Session>(); + + //writers + for (int i = 0; i < WRITER_COUNT; i++) + { + Session writerSession = + repositoryService.getRepository(REPOSITORY_NAME_MULTI_DB).login(credentials, WORKSPACE_NAME); + TreeWriterThread writer = new TreeWriterThread(writerSession, "subnode" + i); + writer.start(); + threads.add(writer); + sessions.add(writerSession); + } + + // backup + File backDir = new File("target/backup/ws1"); + backDir.mkdirs(); + BackupChain bch = null; + + backupManagerImpl.start(); + + BackupConfig config = new BackupConfig(); + config.setRepository(REPOSITORY_NAME_MULTI_DB); + config.setWorkspace(WORKSPACE_NAME); + config.setBackupType(BACKUP_TYPE); + config.setBackupDir(backDir); + + Thread.sleep(5 * 1000); + + System.out.println(" ============ BACKUP START ============"); + + backupManagerImpl.startBackup(config); + + bch = backupManagerImpl.findBackup(REPOSITORY_NAME_MULTI_DB, WORKSPACE_NAME); + + // wait till full backup will be stopped + while (bch.getFullBackupState() != BackupJob.FINISHED) + { + Thread.yield(); + Thread.sleep(30); + } + + if (bch != null) + { + backupManagerImpl.stopBackup(bch); + } + else + { + fail("Can't get fullBackup chain"); + } + + System.out.println(" ============ BACKUP FINISHED ============"); + + // restore + File backLog = new File(bch.getLogFilePath()); + if (backLog.exists()) + { + BackupChainLog bchLog = new BackupChainLog(backLog); + + System.out.println(" ============ RESTORE START ============"); + + assertNotNull(bchLog.getStartedTime()); + assertNotNull(bchLog.getFinishedTime()); + + backupManagerImpl.restoreExistingWorkspace(bchLog, REPOSITORY_NAME_MULTI_DB, entry, false); + + JobWorkspaceRestore restore = backupManagerImpl.getLastRestore(REPOSITORY_NAME_MULTI_DB, WORKSPACE_NAME); + if (restore != null) + { + while (restore.getStateRestore() == JobWorkspaceRestore.RESTORE_FAIL + || restore.getStateRestore() == JobWorkspaceRestore.RESTORE_SUCCESSFUL) + { + Thread.sleep(1000); + } + + if (restore.getStateRestore() == JobWorkspaceRestore.RESTORE_FAIL) + { + restore.getRestoreException().printStackTrace(); + fail(restore.getRestoreException().getMessage()); + } + } + } + else + { + fail("There are no backup files in " + backDir.getAbsolutePath()); + } + + System.out.println(" ============ CHECKING INTEGRITY ============"); + + checkIntegrity((NodeImpl)repositoryService.getRepository(REPOSITORY_NAME_MULTI_DB) + .login(credentials, WORKSPACE_NAME) + .getRootNode()); + } + + /** + * Test Backup/Restore. + * + * @throws Exception + */ + public void testBackupRestoreExistingRepositoryMultiDB() throws Exception + { + + BackupManagerImpl backupManagerImpl = (BackupManagerImpl)getBackupManager(); + + List<TreeWriterThread> threads = new ArrayList<TreeWriterThread>(); + List<Session> sessions = new ArrayList<Session>(); + + //writers + for (int i = 0; i < WRITER_COUNT; i++) + { + Session writerSession = + repositoryService.getRepository(REPOSITORY_NAME_MULTI_DB).login(credentials, WORKSPACE_NAME); + TreeWriterThread writer = new TreeWriterThread(writerSession, "subnode" + i); + writer.start(); + threads.add(writer); + sessions.add(writerSession); + } + + // backup + File backDir = new File("target/backup/db7"); + backDir.mkdirs(); + RepositoryBackupChain bch = null; + + backupManagerImpl.start(); + + RepositoryBackupConfig config = new RepositoryBackupConfig(); + config.setRepository(REPOSITORY_NAME_MULTI_DB); + config.setBackupType(BACKUP_TYPE); + config.setBackupDir(backDir); + + Thread.sleep(5 * 1000); + + System.out.println(" ============ BACKUP START ============"); + + backupManagerImpl.startBackup(config); + + bch = backupManagerImpl.findRepositoryBackup(REPOSITORY_NAME_MULTI_DB); + + // wait till full backup will be stopped + while (bch.getState() != BackupJob.FINISHED) + { + Thread.yield(); + Thread.sleep(30); + } + + if (bch != null) + { + backupManagerImpl.stopBackup(bch); + } + + System.out.println(" ============ BACKUP FINISHED ============"); + + // restore + File backLog = new File(bch.getLogFilePath()); + if (backLog.exists()) + { + RepositoryBackupChainLog bchLog = new RepositoryBackupChainLog(backLog); + + System.out.println(" ============ RESTORE START ============"); + + assertNotNull(bchLog.getStartedTime()); + assertNotNull(bchLog.getFinishedTime()); + + backupManagerImpl.restoreExistingRepository(bchLog, repositoryService.getRepository(REPOSITORY_NAME_MULTI_DB) + .getConfiguration(), false); + + JobWorkspaceRestore restore = backupManagerImpl.getLastRestore(REPOSITORY_NAME_MULTI_DB, WORKSPACE_NAME); + if (restore != null) + { + while (restore.getStateRestore() == JobWorkspaceRestore.RESTORE_FAIL + || restore.getStateRestore() == JobWorkspaceRestore.RESTORE_SUCCESSFUL) + { + Thread.sleep(1000); + } + + if (restore.getStateRestore() == JobWorkspaceRestore.RESTORE_FAIL) + { + restore.getRestoreException().printStackTrace(); + fail(restore.getRestoreException().getMessage()); + } + } + } + else + { + fail("There are no backup files in " + backDir.getAbsolutePath()); + } + + System.out.println(" ============ CHECKING INTEGRITY ============"); + + for (String wsName : repositoryService.getRepository(REPOSITORY_NAME_SINGLE_DB).getWorkspaceNames()) + { + checkIntegrity((NodeImpl)repositoryService.getRepository(REPOSITORY_NAME_MULTI_DB).login(credentials, wsName) + .getRootNode()); + } + } + protected void addChilds(Session session, Node root, int layer) throws Exception { if (layer == 4) @@ -330,39 +764,11 @@ } } - public void _testTableLock() throws Exception - { - Session writerSession = repositoryService.getRepository(REPOSITORY_NAME).login(credentials, WORKSPACE_NAME); - // TreeWriterThread writer = new TreeWriterThread(writerSession, "subnode"); - // writer.start(); - - DataSource ds = (DataSource)new InitialContext().lookup("jdbcjcr_to_repository_restore_singel_db"); - Connection conn = ds.getConnection(); - - Thread.sleep(2 * 1000); - - Statement st = conn.createStatement(); - st.executeQuery("SET PROPERTY \"readonly\" TRUE"); - System.out.println("LOCK TABLES JCR_SITEM WRITE"); - Thread.sleep(5 * 1000); - - // st.executeQuery("SET READONLY FALSE"); - // System.out.println("UNLOCK TABLES"); - // Thread.sleep(5 * 1000); - - st.close(); - conn.close(); - System.out.println("Con closed"); - Thread.sleep(5 * 1000); - - addChilds(writerSession, writerSession.getRootNode(), 0); - } - protected WorkspaceEntry makeWorkspaceEntry(String name, String sourceName) throws LoginException, NoSuchWorkspaceException, RepositoryException, RepositoryConfigurationException { SessionImpl session = - (SessionImpl)repositoryService.getRepository(REPOSITORY_NAME).login(credentials, WORKSPACE_NAME); + (SessionImpl)repositoryService.getRepository(REPOSITORY_NAME_SINGLE_DB).login(credentials, WORKSPACE_NAME); WorkspaceEntry ws1e = (WorkspaceEntry)session.getContainer().getComponentInstanceOfType(WorkspaceEntry.class); Modified: jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/server/HTTPBackupAgentTest.java =================================================================== --- jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/server/HTTPBackupAgentTest.java 2011-01-26 16:18:11 UTC (rev 3890) +++ jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/server/HTTPBackupAgentTest.java 2011-01-26 16:19:28 UTC (rev 3891) @@ -99,6 +99,7 @@ /** * {@inheritDoc} */ + @Override public void setUp() throws Exception { super.setUp(); @@ -1470,10 +1471,10 @@ MultivaluedMap<String, String> headers = new MultivaluedMapImpl(); headers.putSingle("Content-Type", "application/json; charset=UTF-8"); ContainerRequestUserRole creq = - new ContainerRequestUserRole("POST", new URI(HTTP_BACKUP_AGENT_PATH - + HTTPBackupAgent.Constants.OperationType.RESTORE_BACKUP_SET + "/" + "db6" + "/" - + backupSetPath + "/" + "true"), new URI(""), new ByteArrayInputStream(json.toString() - .getBytes("UTF-8")), new InputHeadersMap(headers)); + new ContainerRequestUserRole("POST", new URI(HTTP_BACKUP_AGENT_PATH + + HTTPBackupAgent.Constants.OperationType.RESTORE_BACKUP_SET + "/" + "db6" + "/" + backupSetPath + "/" + + "true"), new URI(""), new ByteArrayInputStream(json.toString().getBytes("UTF-8")), + new InputHeadersMap(headers)); ByteArrayContainerResponseWriter responseWriter = new ByteArrayContainerResponseWriter(); ContainerResponse cres = new ContainerResponse(responseWriter); @@ -3003,6 +3004,7 @@ return sessionRegistry.closeSessions(workspaceName); } + @Override protected WorkspaceEntry makeWorkspaceEntry(WorkspaceEntry defWEntry, String repoNmae, String wsName, String sourceName) { @@ -3086,6 +3088,7 @@ /** * {@inheritDoc} */ + @Override protected ExtendedBackupManager getBackupManager() { return (ExtendedBackupManager) container.getComponentInstanceOfType(BackupManager.class); Modified: jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/impl/core/TesterRdbmsWorkspaceInitializer.java =================================================================== --- jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/impl/core/TesterRdbmsWorkspaceInitializer.java 2011-01-26 16:18:11 UTC (rev 3890) +++ jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/impl/core/TesterRdbmsWorkspaceInitializer.java 2011-01-26 16:19:28 UTC (rev 3891) @@ -29,8 +29,6 @@ import org.exoplatform.services.jcr.impl.dataflow.persistent.CacheableWorkspaceDataManager; import org.exoplatform.services.jcr.impl.util.io.FileCleanerHolder; -import java.io.IOException; - import javax.jcr.PathNotFoundException; import javax.jcr.RepositoryException; @@ -58,16 +56,6 @@ accessManager, repositoryService, cleanerHolder); } - public void restoreValueFiles() throws RepositoryConfigurationException, IOException - { - super.restoreValueStorage(); - } - - public void restoreIndexFiles() throws RepositoryConfigurationException, IOException - { - super.restoreIndex(); - } - @Override public void fullRdbmsRestore() throws RepositoryException {