Package org.exoplatform.services.jcr.core

Examples of org.exoplatform.services.jcr.core.ManageableRepository


   @Override
   protected void doRestore() throws Throwable
   {
      List<DataRestore> dataRestorers = new ArrayList<DataRestore>();

      ManageableRepository repository = null;
      try
      {
         repository = repositoryService.getRepository(repositoryEntry.getName());
      }
      catch (RepositoryConfigurationException e)
      {
         throw new RepositoryException(e);
      }

      List<Backupable> backupableComponents =
         repository.getWorkspaceContainer(workspaceName).getComponentInstancesOfType(Backupable.class);
     
      List<WorkspaceContainerFacade> workspacesWaits4Resume = new ArrayList<WorkspaceContainerFacade>();
     
      Throwable throwable = null;
      try
      {
         // set state SUSPENDED to other workspaces if singledb
         if (workspaceEntry.getContainer().getParameterBoolean("multi-db") == false)
         {
            for (WorkspaceEntry we : repositoryEntry.getWorkspaceEntries())
            {
               if (!we.getName().equals(workspaceEntry.getName()))
               {
                  WorkspaceContainerFacade wsContainer = repository.getWorkspaceContainer(we.getName());
                  wsContainer.setState(ManageableRepository.SUSPENDED);

                  workspacesWaits4Resume.add(wsContainer);
               }
            }
         }

         DataRestoreContext context = new DataRestoreContext(
                  new String[] {DataRestoreContext.STORAGE_DIR},
                  new Object[] {new File(restorePath)});

         // restore all components
         for (Backupable component : backupableComponents)
         {
            dataRestorers.add(component.getDataRestorer(context));
         }

         for (DataRestore restorer : dataRestorers)
         {
            restorer.clean();
         }

         for (DataRestore restorer : dataRestorers)
         {
            restorer.restore();
         }

         for (DataRestore restorer : dataRestorers)
         {
            restorer.commit();
         }
      }
      catch (Throwable e)
      {
         throwable = e;

         for (DataRestore restorer : dataRestorers)
         {
            try
            {
               restorer.rollback();
            }
            catch (BackupException e1)
            {
               log.error("Can't rollback restorer", e1);
            }
         }

         throw e;
      }
      finally
      {
         for (DataRestore restorer : dataRestorers)
         {
            try
            {
               restorer.close();
            }
            catch (BackupException e)
            {
               log.error("Can't close restorer", e);
            }
         }

         try
         {
            for (WorkspaceContainerFacade wsContainer : workspacesWaits4Resume)
            {
               wsContainer.setState(ManageableRepository.ONLINE);
            }
         }
         catch (RepositoryException e)
         {
            if (throwable == null)
            {
               log.error("Con not set ONLYNE state for repository " + repository.getConfiguration().getName(), e);
            }
            else
            {
               throw new RepositoryException("Con not set ONLINE state for repository "
                  + repository.getConfiguration().getName(), e);
            }
         }
      }
   }
View Full Code Here


         {
            // Deploy auto-load scripts and start Observation Listeners.
            String repositoryName = observationListenerConfiguration.getRepository();
            List<String> workspaceNames = observationListenerConfiguration.getWorkspaces();

            ManageableRepository repository = repositoryService.getRepository(repositoryName);

            for (String workspaceName : workspaceNames)
            {
               Session session = repository.getSystemSession(workspaceName);

               String xpath = "//element(*, " + getNodeType() + ")[@exo:autoload='true']";
               Query query = session.getWorkspace().getQueryManager().createQuery(xpath, Query.XPATH);

               QueryResult result = query.execute();
View Full Code Here

         }

         Session session = null;
         try
         {
            ManageableRepository repository = repositoryService.getRepository(loadPlugin.getRepository());
            String workspace = loadPlugin.getWorkspace();
            session = repository.getSystemSession(workspace);
            String nodeName = loadPlugin.getNode();
            Node node = null;
            try
            {
               node = (Node)session.getItem(nodeName);
View Full Code Here

   public RepositoryBackupChain startBackup(RepositoryBackupConfig config) throws BackupOperationException,
      BackupConfigurationException, RepositoryException, RepositoryConfigurationException
   {
      validateBackupConfig(config);

      ManageableRepository repository = repoService.getRepository(config.getRepository());

      File dir =
         new File(config.getBackupDir() + File.separator + "repository_" + config.getRepository() + "_backup_"
            + System.currentTimeMillis());
      dir.mkdir();
View Full Code Here

      {
         if (!restored)
         {
            try
            {
               ManageableRepository mr = null;

               try
               {
                  mr = repositoryService.getRepository(repositoryEntry.getName());
               }
View Full Code Here

         (SessionProviderService)container.getComponentInstanceOfType(SessionProviderService.class);

      RepositoryService repositoryService =
         (RepositoryService)container.getComponentInstanceOfType(RepositoryService.class);

      ManageableRepository repo = repositoryService.getCurrentRepository();
      Session session =
         sessionProviderService.getSessionProvider(null).getSession(repo.getConfiguration().getDefaultWorkspaceName(),
            repo);
      try
      {
         this.file = (Node)session.getItem(filePath);
      }
View Full Code Here

    *           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);
   }
View Full Code Here

      session = (SessionImpl)repository.login(credentials, WS_NAME);
      workspace = session.getWorkspace();
      root = session.getRootNode();
      valueFactory = session.getValueFactory();

      ManageableRepository repository = repositoryService.getDefaultRepository();
      WorkspaceContainerFacade wsc = repository.getWorkspaceContainer(WS_NAME);

      WorkspaceEntry wconf = (WorkspaceEntry)wsc.getComponent(WorkspaceEntry.class);

      maxBufferSize =
         wconf.getContainer().getParameterInteger(WorkspaceDataContainer.MAXBUFFERSIZE_PROP,
            WorkspaceDataContainer.DEF_MAXBUFFERSIZE);

      FileCleanerHolder wfcleaner =
         (FileCleanerHolder)wsc.getComponent(FileCleanerHolder.class);
      fileCleaner = wfcleaner.getFileCleaner();
      holder = new ReaderSpoolFileHolder();

      wsc = repository.getWorkspaceContainer("ws4");
      dataManager = (PersistentDataManager)wsc.getComponent(PersistentDataManager.class);
      cacheableDataManager = (CacheableWorkspaceDataManager)wsc.getComponent(PersistentDataManager.class);
   }
View Full Code Here

      }
   }

   public void testRemoveRepository() throws Exception
   {
      ManageableRepository repository = helper.createRepository(container, true, null);

      String wsName = repository.getConfiguration().getSystemWorkspaceName();
      String repoName = repository.getConfiguration().getName();

      Session session =
         repositoryService.getRepository(repoName).login(new CredentialsImpl("root", "exo".toCharArray()), wsName);
      assertNotNull(session);
      assertNotNull(session.getRootNode());
View Full Code Here

{

   public void testCreateRepositoryMultiDB() throws Exception
   {
      // prepare
      ManageableRepository repository = helper.createRepository(container, true, null);
      WorkspaceEntry wsEntry = helper.createWorkspaceEntry(true, null);
      helper.addWorkspace(repository, wsEntry);
      addConent(repository, wsEntry.getName());

      // backup
      File backDir = new File("target/backup");
      backDir.mkdirs();

      RepositoryBackupConfig config = new RepositoryBackupConfig();
      config.setRepository(repository.getConfiguration().getName());
      config.setBackupType(BackupManager.FULL_BACKUP_ONLY);
      config.setBackupDir(backDir);

      RepositoryBackupChain bch = backup.startBackup(config);
      waitEndOfBackup(bch);
      backup.stopBackup(bch);

      // restore with RepositoryCreatorService
      RepositoryCreationService creatorService =
         (RepositoryCreationService)container.getComponentInstanceOfType(RepositoryCreationService.class);
      assertNotNull(creatorService);

      String tenantName = "new_repository_mutli-db";
      String repoToken = creatorService.reserveRepositoryName(tenantName);

      // restore            
      RepositoryEntry newRE =
         helper.createRepositoryEntry(true, repository.getConfiguration().getSystemWorkspaceName(),
            IdGenerator.generate());
      newRE.setName(tenantName);

      WorkspaceEntry newWSEntry = helper.createWorkspaceEntry(true, IdGenerator.generate());
      newWSEntry.setName(wsEntry.getName());
      newRE.addWorkspace(newWSEntry);

      creatorService.createRepository(bch.getBackupId(), newRE, repoToken);

      // check
      ManageableRepository restoredRepository = repositoryService.getRepository(tenantName);
      assertNotNull(restoredRepository);
     
      checkConent(restoredRepository, wsEntry.getName());

      //check repositoryConfiguration
View Full Code Here

TOP

Related Classes of org.exoplatform.services.jcr.core.ManageableRepository

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.