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);