[exo-jcr-commits] exo-jcr SVN: r5175 - jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/usecase.
do-not-reply at jboss.org
do-not-reply at jboss.org
Wed Nov 9 09:14:52 EST 2011
Author: areshetnyak
Date: 2011-11-09 09:14:52 -0500 (Wed, 09 Nov 2011)
New Revision: 5175
Modified:
jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/usecase/TestBackupRestore.java
Log:
EXOJCR-1611 : Use cases for testing all restore jobs was added.
Modified: jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/usecase/TestBackupRestore.java
===================================================================
--- jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/usecase/TestBackupRestore.java 2011-11-09 14:14:49 UTC (rev 5174)
+++ jcr/trunk/exo.jcr.component.ext/src/test/java/org/exoplatform/services/jcr/ext/backup/usecase/TestBackupRestore.java 2011-11-09 14:14:52 UTC (rev 5175)
@@ -16,10 +16,13 @@
*/
package org.exoplatform.services.jcr.ext.backup.usecase;
+import org.apache.commons.collections.map.HashedMap;
import org.exoplatform.container.xml.InitParams;
import org.exoplatform.container.xml.PropertiesParam;
+import org.exoplatform.services.jcr.config.RepositoryConfigurationException;
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.ext.backup.BackupChain;
import org.exoplatform.services.jcr.ext.backup.BackupChainLog;
import org.exoplatform.services.jcr.ext.backup.BackupConfig;
@@ -30,13 +33,23 @@
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.JobExistingRepositoryRestore;
+import org.exoplatform.services.jcr.ext.backup.impl.JobExistingRepositorySameConfigRestore;
+import org.exoplatform.services.jcr.ext.backup.impl.JobExistingWorkspaceRestore;
+import org.exoplatform.services.jcr.ext.backup.impl.JobExistingWorkspaceSameConfigRestore;
import org.exoplatform.services.jcr.ext.backup.impl.JobRepositoryRestore;
import org.exoplatform.services.jcr.ext.backup.impl.JobWorkspaceRestore;
+import org.exoplatform.services.jcr.impl.backup.Backupable;
import org.exoplatform.services.jcr.impl.core.SessionImpl;
+import org.exoplatform.services.jcr.impl.core.SessionRegistry;
import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
import javax.jcr.Node;
+import javax.jcr.RepositoryException;
/**
* Created by The eXo Platform SAS.
@@ -48,6 +61,7 @@
*/
public class TestBackupRestore extends BaseStandaloneBackupRestoreTest
{
+
public void testBackupRestoreExistingRepositorySingleDB() throws Exception
{
repositoryBackupRestore("db1", 1);
@@ -72,6 +86,310 @@
workspaceBackupRestore("db2", 8);
}
+ public void testJobExistingRepositorySameConfigRestoreSingleDB() throws Exception
+ {
+ repositoryBackupRestoreDirectlyOverJobExistingRepositorySameConfigRestore("db1", 9);
+ repositoryBackupRestoreDirectlyOverJobExistingRepositorySameConfigRestore("db1", 10);
+ }
+
+ public void testJobExistingRepositorySameConfigRestoreMultiDB() throws Exception
+ {
+ repositoryBackupRestoreDirectlyOverJobExistingRepositorySameConfigRestore("db2", 10);
+ repositoryBackupRestoreDirectlyOverJobExistingRepositorySameConfigRestore("db2", 11);
+ }
+
+ public void testJobExistingRepositoryRestoreSingleDB() throws Exception
+ {
+ repositoryBackupRestoreDirectlyOverJobExistingRepositoryRestore("db1", 12);
+ repositoryBackupRestoreDirectlyOverJobExistingRepositoryRestore("db1", 13);
+ }
+
+ public void testJobExistingRepositoryRestoreMultiDB() throws Exception
+ {
+ repositoryBackupRestoreDirectlyOverJobExistingRepositoryRestore("db2", 14);
+ repositoryBackupRestoreDirectlyOverJobExistingRepositoryRestore("db2", 15);
+ }
+
+ public void testJobRepositoryRestoreSingleDB() throws Exception
+ {
+ repositoryBackupRestoreDirectlyOverJobRepositoryRestore("db1", 17);
+ repositoryBackupRestoreDirectlyOverJobRepositoryRestore("db1", 18);
+ }
+
+ public void testJobRepositoryRestoreMultiDB() throws Exception
+ {
+ repositoryBackupRestoreDirectlyOverJobRepositoryRestore("db2", 19);
+ repositoryBackupRestoreDirectlyOverJobRepositoryRestore("db2", 20);
+ }
+
+ public void testJobExistingWorkspaceSameConfigRestoreSingleDB() throws Exception
+ {
+ workspaceBackupRestoreDirectlyOverJobExistingWorkspaceSameConfigRestore("db1", 21);
+ workspaceBackupRestoreDirectlyOverJobExistingWorkspaceSameConfigRestore("db1", 22);
+ }
+
+ public void testJobExistingWorkspaceSameConfigRestoreMultiDB() throws Exception
+ {
+ workspaceBackupRestoreDirectlyOverJobExistingWorkspaceSameConfigRestore("db2", 23);
+ workspaceBackupRestoreDirectlyOverJobExistingWorkspaceSameConfigRestore("db2", 24);
+ }
+
+ public void testJobExistingWorkspaceRestoreSingleDB() throws Exception
+ {
+ workspaceBackupRestoreDirectlyOverJobExistingWorkspaceRestore("db1", 25);
+ workspaceBackupRestoreDirectlyOverJobExistingWorkspaceRestore("db1", 26);
+ }
+
+ public void testJobExistingWorkspaceRestoreMultiDB() throws Exception
+ {
+ workspaceBackupRestoreDirectlyOverJobExistingWorkspaceRestore("db2", 27);
+ workspaceBackupRestoreDirectlyOverJobExistingWorkspaceRestore("db2", 28);
+ }
+
+ public void testJobWorkspaceRestoreSingleDB() throws Exception
+ {
+ workspaceBackupRestoreDirectlyOverJobWorkspaceRestore("db1", 29);
+ workspaceBackupRestoreDirectlyOverJobWorkspaceRestore("db1", 30);
+ }
+
+ public void testJobWorkspaceRestoreMultiDB() throws Exception
+ {
+ workspaceBackupRestoreDirectlyOverJobWorkspaceRestore("db2", 31);
+ workspaceBackupRestoreDirectlyOverJobWorkspaceRestore("db2", 32);
+ }
+
+ protected void repositoryBackupRestoreDirectlyOverJobExistingRepositorySameConfigRestore(String repositoryName,
+ int number) throws Exception
+ {
+ addConent(repositoryName, number);
+
+ BackupManagerImpl backupManagerImpl = (BackupManagerImpl)getBackupManager();
+ backupManagerImpl.start();
+
+ File backDir = new File("target/backup/" + repositoryName);
+ backDir.mkdirs();
+
+ RepositoryBackupConfig config = new RepositoryBackupConfig();
+ config.setRepository(repositoryName);
+ config.setBackupType(BackupManager.FULL_BACKUP_ONLY);
+ config.setBackupDir(backDir);
+
+ RepositoryBackupChain bch = backupManagerImpl.startBackup(config);
+
+ // wait till full backup will stop
+ while (bch.getState() != BackupJob.FINISHED)
+ {
+ Thread.yield();
+ Thread.sleep(30);
+ }
+
+ if (bch != null)
+ {
+ backupManagerImpl.stopBackup(bch);
+ }
+
+ // restore
+ RepositoryBackupChainLog rblog = new RepositoryBackupChainLog(new File(bch.getLogFilePath()));
+
+ Map<String, BackupChainLog> workspacesMapping = new HashedMap();
+ Map<String, BackupChainLog> backups = new HashedMap();
+
+ for (String path : rblog.getWorkspaceBackupsInfo())
+ {
+ BackupChainLog bLog = new BackupChainLog(new File(path));
+ backups.put(bLog.getBackupConfig().getWorkspace(), bLog);
+ }
+
+ for (WorkspaceEntry wsEntry : rblog.getOriginalRepositoryEntry().getWorkspaceEntries())
+ {
+ workspacesMapping.put(wsEntry.getName(), backups.get(wsEntry.getName()));
+ }
+
+ JobExistingRepositorySameConfigRestore job =
+ new JobExistingRepositorySameConfigRestore(repositoryService, backupManagerImpl, rblog
+ .getOriginalRepositoryEntry(), workspacesMapping, rblog);
+
+ job.run();
+ assertEquals(JobRepositoryRestore.REPOSITORY_RESTORE_SUCCESSFUL, job.getStateRestore());
+
+ checkConent(repositoryName, number);
+ }
+
+ protected void repositoryBackupRestoreDirectlyOverJobExistingRepositoryRestore(String repositoryName, int number)
+ throws Exception
+ {
+ addConent(repositoryName, number);
+
+ BackupManagerImpl backupManagerImpl = (BackupManagerImpl)getBackupManager();
+ backupManagerImpl.start();
+
+ File backDir = new File("target/backup/" + repositoryName);
+ backDir.mkdirs();
+
+ RepositoryBackupConfig config = new RepositoryBackupConfig();
+ config.setRepository(repositoryName);
+ config.setBackupType(BackupManager.FULL_BACKUP_ONLY);
+ config.setBackupDir(backDir);
+
+ RepositoryBackupChain bch = backupManagerImpl.startBackup(config);
+
+ // wait till full backup will stop
+ while (bch.getState() != BackupJob.FINISHED)
+ {
+ Thread.yield();
+ Thread.sleep(30);
+ }
+
+ if (bch != null)
+ {
+ backupManagerImpl.stopBackup(bch);
+ }
+
+ // restore
+ RepositoryBackupChainLog rblog = new RepositoryBackupChainLog(new File(bch.getLogFilePath()));
+
+ Map<String, BackupChainLog> workspacesMapping = new HashedMap();
+ Map<String, BackupChainLog> backups = new HashedMap();
+
+ for (String path : rblog.getWorkspaceBackupsInfo())
+ {
+ BackupChainLog bLog = new BackupChainLog(new File(path));
+ backups.put(bLog.getBackupConfig().getWorkspace(), bLog);
+ }
+
+ for (WorkspaceEntry wsEntry : rblog.getOriginalRepositoryEntry().getWorkspaceEntries())
+ {
+ workspacesMapping.put(wsEntry.getName(), backups.get(wsEntry.getName()));
+ }
+
+ //TODO
+ /*List<WorkspaceContainerFacade> workspacesWaits4Resume = new ArrayList<WorkspaceContainerFacade>();
+ ManageableRepository repository = repositoryService.getRepository(repositoryName);
+ for (String wsName : repository.getWorkspaceNames())
+ {
+ WorkspaceContainerFacade wsContainer = repository.getWorkspaceContainer(wsName);
+ wsContainer.setState(ManageableRepository.SUSPENDED);
+
+ workspacesWaits4Resume.add(wsContainer);
+ }*/
+ //
+
+ JobExistingRepositoryRestore job =
+ new JobExistingRepositoryRestore(repositoryService, backupManagerImpl, rblog.getOriginalRepositoryEntry(),
+ workspacesMapping, rblog);
+
+ job.run();
+
+ //TODO resume components
+ /*for (WorkspaceContainerFacade wsContainer : workspacesWaits4Resume)
+ {
+ wsContainer.setState(ManageableRepository.ONLINE);
+ }
+ //
+ */
+ assertEquals(JobRepositoryRestore.REPOSITORY_RESTORE_SUCCESSFUL, job.getStateRestore());
+
+ checkConent(repositoryName, number);
+ }
+
+ 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);
+ }
+
+ protected void repositoryBackupRestoreDirectlyOverJobRepositoryRestore(String repositoryName, int number)
+ throws Exception
+ {
+ addConent(repositoryName, number);
+
+ BackupManagerImpl backupManagerImpl = (BackupManagerImpl)getBackupManager();
+ backupManagerImpl.start();
+
+ File backDir = new File("target/backup/" + repositoryName);
+ backDir.mkdirs();
+
+ RepositoryBackupConfig config = new RepositoryBackupConfig();
+ config.setRepository(repositoryName);
+ config.setBackupType(BackupManager.FULL_BACKUP_ONLY);
+ config.setBackupDir(backDir);
+
+ RepositoryBackupChain bch = backupManagerImpl.startBackup(config);
+
+ // wait till full backup will stop
+ while (bch.getState() != BackupJob.FINISHED)
+ {
+ Thread.yield();
+ Thread.sleep(30);
+ }
+
+ if (bch != null)
+ {
+ backupManagerImpl.stopBackup(bch);
+ }
+
+ // restore
+ RepositoryBackupChainLog rblog = new RepositoryBackupChainLog(new File(bch.getLogFilePath()));
+
+ // clean existing repository
+ // list of components to clean
+ List<Backupable> backupable = new ArrayList<Backupable>();
+
+ //Create local copy of WorkspaceEntry for all workspaces
+ ArrayList<WorkspaceEntry> workspaceList = new ArrayList<WorkspaceEntry>();
+ workspaceList.addAll(rblog.getOriginalRepositoryEntry().getWorkspaceEntries());
+
+ // get all backupable components
+ for (WorkspaceEntry wEntry : workspaceList)
+ {
+ backupable.addAll(repositoryService.getRepository(rblog.getOriginalRepositoryEntry().getName())
+ .getWorkspaceContainer(wEntry.getName()).getComponentInstancesOfType(Backupable.class));
+ }
+
+ //close all session
+ for (WorkspaceEntry wEntry : workspaceList)
+ {
+ forceCloseSession(rblog.getOriginalRepositoryEntry().getName(), wEntry.getName());
+ }
+
+ //remove repository
+ repositoryService.removeRepository(rblog.getOriginalRepositoryEntry().getName());
+
+ // clean
+ for (Backupable component : backupable)
+ {
+ component.clean();
+ }
+
+ Map<String, BackupChainLog> workspacesMapping = new HashedMap();
+ Map<String, BackupChainLog> backups = new HashedMap();
+
+ for (String path : rblog.getWorkspaceBackupsInfo())
+ {
+ BackupChainLog bLog = new BackupChainLog(new File(path));
+ backups.put(bLog.getBackupConfig().getWorkspace(), bLog);
+ }
+
+ for (WorkspaceEntry wsEntry : rblog.getOriginalRepositoryEntry().getWorkspaceEntries())
+ {
+ workspacesMapping.put(wsEntry.getName(), backups.get(wsEntry.getName()));
+ }
+
+ JobRepositoryRestore job =
+ new JobRepositoryRestore(repositoryService, backupManagerImpl, rblog.getOriginalRepositoryEntry(),
+ workspacesMapping, rblog);
+
+ job.run();
+ assertEquals(JobRepositoryRestore.REPOSITORY_RESTORE_SUCCESSFUL, job.getStateRestore());
+
+ checkConent(repositoryName, number);
+ }
+
protected void workspaceBackupRestore(String repositoryName, int number) throws Exception
{
addConent(repositoryName, number);
@@ -144,6 +462,202 @@
checkConent(repositoryName, number);
}
+ protected void workspaceBackupRestoreDirectlyOverJobExistingWorkspaceSameConfigRestore(String repositoryName,
+ int number) throws Exception
+ {
+ addConent(repositoryName, number);
+ String workspaceName =
+ repositoryService.getRepository(repositoryName).getConfiguration().getSystemWorkspaceName();
+
+ WorkspaceEntry wsEntry = null;
+ for (WorkspaceEntry entry : repositoryService.getRepository(repositoryName).getConfiguration()
+ .getWorkspaceEntries())
+ {
+ if (entry.getName().equals(workspaceName))
+ {
+ wsEntry = entry;
+ break;
+ }
+ }
+
+ BackupManagerImpl backupManagerImpl = (BackupManagerImpl)getBackupManager();
+ backupManagerImpl.start();
+
+ File backDir = new File("target/backup/" + repositoryName);
+ backDir.mkdirs();
+
+ BackupConfig config = new BackupConfig();
+ config.setRepository(repositoryName);
+ config.setWorkspace(workspaceName);
+ config.setBackupType(BackupManager.FULL_BACKUP_ONLY);
+ config.setBackupDir(backDir);
+
+ BackupChain bch = backupManagerImpl.startBackup(config);
+
+ // wait till full backup will stop
+ while (bch.getFullBackupState() != BackupChain.FINISHED)
+ {
+ Thread.yield();
+ Thread.sleep(30);
+ }
+
+ if (bch != null)
+ {
+ backupManagerImpl.stopBackup(bch);
+ }
+
+ // restore
+ BackupChainLog bclog = new BackupChainLog(new File(bch.getLogFilePath()));
+
+ JobExistingWorkspaceSameConfigRestore job =
+ new JobExistingWorkspaceSameConfigRestore(repositoryService, backupManagerImpl, repositoryName, bclog, bclog
+ .getOriginalWorkspaceEntry());
+
+ job.run();
+ assertEquals(JobWorkspaceRestore.RESTORE_SUCCESSFUL, job.getStateRestore());
+
+ checkConent(repositoryName, number);
+ }
+
+ /**
+ * JobExistingWorkspaseRrestore is not support restore system workspace,
+ * because repository is not allowed removing system workspace.
+ */
+ protected void workspaceBackupRestoreDirectlyOverJobExistingWorkspaceRestore(String repositoryName,
+ int number) throws Exception
+ {
+ addConent(repositoryName, number);
+
+ WorkspaceEntry wsEntry = null;
+ for (WorkspaceEntry entry : repositoryService.getRepository(repositoryName).getConfiguration()
+ .getWorkspaceEntries())
+ {
+ if (!entry.getName().equals(
+ repositoryService.getRepository(repositoryName).getConfiguration().getSystemWorkspaceName()))
+ {
+ wsEntry = entry;
+ break;
+ }
+ }
+
+ BackupManagerImpl backupManagerImpl = (BackupManagerImpl)getBackupManager();
+ backupManagerImpl.start();
+
+ File backDir = new File("target/backup/" + repositoryName);
+ backDir.mkdirs();
+
+ BackupConfig config = new BackupConfig();
+ config.setRepository(repositoryName);
+ config.setWorkspace(wsEntry.getName());
+ config.setBackupType(BackupManager.FULL_BACKUP_ONLY);
+ config.setBackupDir(backDir);
+
+ BackupChain bch = backupManagerImpl.startBackup(config);
+
+ // wait till full backup will stop
+ while (bch.getFullBackupState() != BackupChain.FINISHED)
+ {
+ Thread.yield();
+ Thread.sleep(30);
+ }
+
+ if (bch != null)
+ {
+ backupManagerImpl.stopBackup(bch);
+ }
+
+ // restore
+ BackupChainLog bclog = new BackupChainLog(new File(bch.getLogFilePath()));
+
+ JobExistingWorkspaceRestore job =
+ new JobExistingWorkspaceRestore(repositoryService, backupManagerImpl, repositoryName, bclog, bclog
+ .getOriginalWorkspaceEntry());
+
+ job.run();
+ assertEquals(JobWorkspaceRestore.RESTORE_SUCCESSFUL, job.getStateRestore());
+
+ checkConent(repositoryName, number);
+ }
+
+ /**
+ * JobWorkspaseRrestore is not support restore system workspace,
+ * because repository is not allowed removing system workspace.
+ */
+ protected void workspaceBackupRestoreDirectlyOverJobWorkspaceRestore(String repositoryName, int number)
+ throws Exception
+ {
+ addConent(repositoryName, number);
+
+ WorkspaceEntry wsEntry = null;
+ for (WorkspaceEntry entry : repositoryService.getRepository(repositoryName).getConfiguration()
+ .getWorkspaceEntries())
+ {
+ if (!entry.getName().equals(
+ repositoryService.getRepository(repositoryName).getConfiguration().getSystemWorkspaceName()))
+ {
+ wsEntry = entry;
+ break;
+ }
+ }
+
+ String workspaceName = wsEntry.getName();
+
+ BackupManagerImpl backupManagerImpl = (BackupManagerImpl)getBackupManager();
+ backupManagerImpl.start();
+
+ File backDir = new File("target/backup/" + repositoryName);
+ backDir.mkdirs();
+
+ BackupConfig config = new BackupConfig();
+ config.setRepository(repositoryName);
+ config.setWorkspace(workspaceName);
+ config.setBackupType(BackupManager.FULL_BACKUP_ONLY);
+ config.setBackupDir(backDir);
+
+ BackupChain bch = backupManagerImpl.startBackup(config);
+
+ // wait till full backup will stop
+ while (bch.getFullBackupState() != BackupChain.FINISHED)
+ {
+ Thread.yield();
+ Thread.sleep(30);
+ }
+
+ if (bch != null)
+ {
+ backupManagerImpl.stopBackup(bch);
+ }
+
+ // clean existed workspace
+ // get all backupable components
+ List<Backupable> backupable =
+ repositoryService.getRepository(repositoryName).getWorkspaceContainer(wsEntry.getName())
+ .getComponentInstancesOfType(Backupable.class);
+
+ // close all session
+ forceCloseSession(repositoryName, wsEntry.getName());
+
+ repositoryService.getRepository(repositoryName).removeWorkspace(wsEntry.getName());
+
+ // clean
+ for (Backupable component : backupable)
+ {
+ component.clean();
+ }
+
+ // restore
+ BackupChainLog bclog = new BackupChainLog(new File(bch.getLogFilePath()));
+
+ JobWorkspaceRestore job =
+ new JobWorkspaceRestore(repositoryService, backupManagerImpl, repositoryName, bclog, bclog
+ .getOriginalWorkspaceEntry());
+
+ job.run();
+ assertEquals(JobWorkspaceRestore.RESTORE_SUCCESSFUL, job.getStateRestore());
+
+ checkConent(repositoryName, number);
+ }
+
protected void repositoryBackupRestore(String repositoryName, int number) throws Exception
{
addConent(repositoryName, number);
More information about the exo-jcr-commits
mailing list