Package org.exoplatform.services.jcr.core

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


            jdbcConn.setAutoCommit(false);

            dbCleaner = DBCleanService.getRepositoryDBCleaner(jdbcConn, repositoryEntry);
         }

         ManageableRepository repository = repositoryService.getRepository(this.repositoryEntry.getName());
         for (String wsName : repository.getWorkspaceNames())
         {
            WorkspaceContainerFacade wsContainer = repository.getWorkspaceContainer(wsName);
            wsContainer.setState(ManageableRepository.SUSPENDED);

            workspacesWaits4Resume.add(wsContainer);
         }
View Full Code Here


    * @throws Exception {@link Exception}
    */
   protected Session session(String repoName, String wsName, List<String> lockTokens) throws Exception,
      NoSuchWorkspaceException
   {
      ManageableRepository repo = this.repositoryService.getRepository(repoName);
      SessionProvider sp = sessionProviderService.getSessionProvider(null);
      if (sp == null)
         throw new RepositoryException("SessionProvider is not properly set. Make the application calls"
            + "SessionProviderService.setSessionProvider(..) somewhere before ("
            + "for instance in Servlet Filter for WEB application)");
View Full Code Here

            // Deploy auto-load scripts and start Observation Listeners.
            final String repositoryName = getWorkingRepositoryName();

            List<String> workspaceNames = observationListenerConfiguration.getWorkspaces();

            final ManageableRepository repository = repositoryService.getRepository(repositoryName);

            // JCR it offers an asynchronous workspace reindexing (since 1.14.0-CR2). But while it
            // is performed in background queries can't be executed. In this case autoload scripts could only
            // be loaded after reindexing finished.
            final Set<String> delayedWorkspacePublishing = new HashSet<String>();

            for (String workspaceName : workspaceNames)
            {
               Session session = repository.getSystemSession(workspaceName);
               try
               {
                  autoLoadScripts(session);
               }
               catch (IndexOfflineRepositoryException e)
               {
                  delayedWorkspacePublishing.add(workspaceName);
               }
               finally
               {
                  session.logout();
               }

               session
                  .getWorkspace()
                  .getObservationManager()
                  .addEventListener(new GroovyScript2RestUpdateListener(repository, workspaceName, this),
                     Event.PROPERTY_ADDED | Event.PROPERTY_CHANGED | Event.PROPERTY_REMOVED, "/", true, null,
                     new String[]{getNodeType()}, false);
            }
            if (!delayedWorkspacePublishing.isEmpty())
            {
               LOG.warn("The following workspaces are being reindexed now: " + delayedWorkspacePublishing
                  + ". Groove scripts from those workspaces marked as AutoLoad will be loaded later.");
               // lauch delayed autoLoad
               new Thread(new Runnable()
               {
                  public void run()
                  {
                     while (true)
                     {
                        if (delayedWorkspacePublishing.isEmpty())
                        {
                           // finish thread
                           return;
                        }
                        for (Iterator iterator = delayedWorkspacePublishing.iterator(); iterator.hasNext();)
                        {
                           String workspaceName = (String)iterator.next();
                           try
                           {
                              Session session = repository.getSystemSession(workspaceName);
                              try
                              {
                                 autoLoadScripts(session);
                              }
                              finally
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

   protected void removeRepositoryLocally(String repositoryName, boolean forceRemove) throws RepositoryCreationException
   {
      try
      {
         // extract list of all datasources
         ManageableRepository repositorty = repositoryService.getRepository(repositoryName);
         Set<String> datasources = extractDataSourceNames(repositorty.getConfiguration(), false);

         // close all opened sessions
         for (String workspaceName : repositorty.getWorkspaceNames())
         {
            WorkspaceContainerFacade wc = repositorty.getWorkspaceContainer(workspaceName);
            SessionRegistry sessionRegistry = (SessionRegistry)wc.getComponent(SessionRegistry.class);

            sessionRegistry.closeSessions(workspaceName);
         }
        
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

               new BackupChainLog(logDirectory, config, fullBackupType, incrementalBackupType, backupId,
                        repositoryService.getConfig(), rootDir);

      this.backupId = backupId;
     
      ManageableRepository repository = null;
      try
      {
         repository = repositoryService.getRepository(config.getRepository());
      }
      catch (RepositoryConfigurationException e)
View Full Code Here

   @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

    */
   protected void removeRepository(RepositoryService repositoryService, String repositoryName)
      throws RepositoryException,
      RepositoryConfigurationException
   {
      ManageableRepository mr = null;

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

   public void initStorage(boolean replace) throws RepositoryConfigurationException, RepositoryException
   {
      for (RepositoryEntry repConfiguration : repConfigurations())
      {
         String repName = repConfiguration.getName();
         ManageableRepository rep = repositoryService.getRepository(repName);
         final Session sysSession = rep.getSystemSession(regWorkspaces.get(repName));

         try
         {
            if (sysSession.getRootNode().hasNode(EXO_REGISTRY) && replace)
            {
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.