Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.jackrabbit.core; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.io.StringReader; import java.security.AccessControlContext; import java.security.AccessController; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Properties; import java.util.Set; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; import javax.jcr.AccessDeniedException; import javax.jcr.Credentials; import javax.jcr.LoginException; import javax.jcr.NoSuchWorkspaceException; import javax.jcr.PropertyType; import javax.jcr.Repository; import javax.jcr.RepositoryException; import javax.jcr.Session; import javax.jcr.SimpleCredentials; import javax.jcr.Value; import javax.jcr.ValueFactory; import javax.jcr.observation.Event; import javax.jcr.observation.ObservationManager; import javax.security.auth.Subject; import org.apache.commons.collections.map.ReferenceMap; import org.apache.commons.io.IOUtils; import org.apache.jackrabbit.api.JackrabbitRepository; import org.apache.jackrabbit.api.management.RepositoryManager; import org.apache.jackrabbit.api.security.authentication.token.TokenCredentials; import org.apache.jackrabbit.commons.AbstractRepository; import org.apache.jackrabbit.core.cache.CacheManager; import org.apache.jackrabbit.core.cluster.ClusterContext; import org.apache.jackrabbit.core.cluster.ClusterException; import org.apache.jackrabbit.core.cluster.ClusterNode; import org.apache.jackrabbit.core.cluster.LockEventChannel; import org.apache.jackrabbit.core.cluster.UpdateEventChannel; import org.apache.jackrabbit.core.cluster.UpdateEventListener; import org.apache.jackrabbit.core.cluster.WorkspaceEventChannel; import org.apache.jackrabbit.core.cluster.WorkspaceListener; import org.apache.jackrabbit.core.config.ClusterConfig; import org.apache.jackrabbit.core.config.PersistenceManagerConfig; import org.apache.jackrabbit.core.config.RepositoryConfig; import org.apache.jackrabbit.core.config.SecurityManagerConfig; import org.apache.jackrabbit.core.config.VersioningConfig; import org.apache.jackrabbit.core.config.WorkspaceConfig; import org.apache.jackrabbit.core.data.DataStore; import org.apache.jackrabbit.core.data.DataStoreException; import org.apache.jackrabbit.core.fs.FileSystem; import org.apache.jackrabbit.core.fs.FileSystemException; import org.apache.jackrabbit.core.fs.FileSystemResource; import org.apache.jackrabbit.core.gc.GarbageCollector; import org.apache.jackrabbit.core.id.NodeId; import org.apache.jackrabbit.core.id.NodeIdFactory; import org.apache.jackrabbit.core.lock.LockManager; import org.apache.jackrabbit.core.lock.LockManagerImpl; import org.apache.jackrabbit.core.nodetype.NodeTypeRegistry; import org.apache.jackrabbit.core.nodetype.virtual.VirtualNodeTypeStateManager; import org.apache.jackrabbit.core.observation.DelegatingObservationDispatcher; import org.apache.jackrabbit.core.observation.EventState; import org.apache.jackrabbit.core.observation.EventStateCollection; import org.apache.jackrabbit.core.observation.ObservationDispatcher; import org.apache.jackrabbit.core.persistence.IterablePersistenceManager; import org.apache.jackrabbit.core.persistence.PMContext; import org.apache.jackrabbit.core.persistence.PersistenceManager; import org.apache.jackrabbit.core.persistence.check.ConsistencyChecker; import org.apache.jackrabbit.core.retention.RetentionRegistry; import org.apache.jackrabbit.core.retention.RetentionRegistryImpl; import org.apache.jackrabbit.core.security.JackrabbitSecurityManager; import org.apache.jackrabbit.core.security.authentication.AuthContext; import org.apache.jackrabbit.core.security.authentication.token.TokenBasedAuthentication; import org.apache.jackrabbit.core.security.authorization.PrivilegeRegistry; import org.apache.jackrabbit.core.security.simple.SimpleSecurityManager; import org.apache.jackrabbit.core.state.ChangeLog; import org.apache.jackrabbit.core.state.ISMLocking; import org.apache.jackrabbit.core.state.ItemStateException; import org.apache.jackrabbit.core.state.ManagedMLRUItemStateCacheFactory; import org.apache.jackrabbit.core.state.SharedItemStateManager; import org.apache.jackrabbit.core.util.RepositoryLockMechanism; import org.apache.jackrabbit.core.version.InternalVersionManager; import org.apache.jackrabbit.core.version.InternalVersionManagerImpl; import org.apache.jackrabbit.core.xml.ClonedInputSource; import org.apache.jackrabbit.data.core.TransactionException; import org.apache.jackrabbit.spi.commons.name.NameConstants; import org.apache.jackrabbit.spi.commons.namespace.NamespaceResolver; import org.apache.jackrabbit.spi.commons.namespace.RegistryNamespaceResolver; import org.apache.jackrabbit.value.ValueFactoryImpl; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.xml.sax.InputSource; import EDU.oswego.cs.dl.util.concurrent.Mutex; import EDU.oswego.cs.dl.util.concurrent.ReadWriteLock; import EDU.oswego.cs.dl.util.concurrent.ReentrantWriterPreferenceReadWriteLock; import EDU.oswego.cs.dl.util.concurrent.WriterPreferenceReadWriteLock; /** * A <code>RepositoryImpl</code> ... */ public class RepositoryImpl extends AbstractRepository implements javax.jcr.Repository, JackrabbitRepository, SessionListener, WorkspaceListener { private static Logger log = LoggerFactory.getLogger(RepositoryImpl.class); /** * hardcoded id of the repository root node */ public static final NodeId ROOT_NODE_ID = NodeId.valueOf("cafebabe-cafe-babe-cafe-babecafebabe"); /** * hardcoded id of the "/jcr:system" node */ public static final NodeId SYSTEM_ROOT_NODE_ID = NodeId.valueOf("deadbeef-cafe-babe-cafe-babecafebabe"); /** * hardcoded id of the "/jcr:system/jcr:versionStorage" node */ public static final NodeId VERSION_STORAGE_NODE_ID = NodeId.valueOf("deadbeef-face-babe-cafe-babecafebabe"); /** * hardcoded id of the "/jcr:system/jcr:activities" node */ public static final NodeId ACTIVITIES_NODE_ID = NodeId.valueOf("deadbeef-face-babe-ac71-babecafebabe"); /** * hardcoded id of the "/jcr:system/jcr:configurations" node */ public static final NodeId CONFIGURATIONS_NODE_ID = NodeId.valueOf("deadbeef-face-babe-c04f-babecafebabe"); /** * hardcoded id of the "/jcr:system/jcr:nodeTypes" node */ public static final NodeId NODETYPES_NODE_ID = NodeId.valueOf("deadbeef-cafe-cafe-cafe-babecafebabe"); /** * the name of the resource containing customized descriptors of the repository. */ private static final String PROPERTIES_RESOURCE = "repository.properties"; /** * Key to a <code>string</code> descriptor. Returns the repository cluster id if * and only if clustering is enabled. */ public static final String JACKRABBIT_CLUSTER_ID = "jackrabbit.cluster.id"; /** * the repository descriptors, maps String keys to Value/Value[] objects */ private final Map<String, DescriptorValue> repDescriptors = new HashMap<String, DescriptorValue>(); protected final RepositoryContext context = new RepositoryContext(this); private final VirtualNodeTypeStateManager virtNTMgr; /** * Security manager */ private JackrabbitSecurityManager securityMgr; /** * Search manager for the jcr:system tree. May be <code>null</code> if * none is configured. */ private SearchManager systemSearchMgr; // configuration of the repository protected final RepositoryConfig repConfig; protected NodeIdFactory nodeIdFactory; /** * the delegating observation dispatcher for all workspaces */ private final DelegatingObservationDispatcher delegatingDispatcher = new DelegatingObservationDispatcher(); /** * map of workspace names and <code>WorkspaceInfo<code>s. */ private final HashMap<String, WorkspaceInfo> wspInfos = new HashMap<String, WorkspaceInfo>(); /** * active sessions (weak references) */ private final Map<Session, Session> activeSessions = new ReferenceMap(ReferenceMap.WEAK, ReferenceMap.WEAK); // flag indicating if repository has been shut down private boolean disposed; /** * The repository lock mechanism ensures that a repository is only instantiated once. */ private RepositoryLockMechanism repLock; /** * Shutdown lock for guaranteeing that no new sessions are started during * repository shutdown and that a repository shutdown is not initiated * during a login. Each session login acquires a read lock while the * repository shutdown requires a write lock. This guarantees that there * can be multiple concurrent logins when the repository is not shutting * down, but that only a single shutdown and no concurrent logins can * happen simultaneously. */ private final ReadWriteLock shutdownLock = new WriterPreferenceReadWriteLock(); /** * There is one cache manager per repository that manages the sizes of the caches used. */ private final CacheManager cacheMgr = new CacheManager(); /** * Chanel for posting create workspace messages. */ private WorkspaceEventChannel createWorkspaceEventChannel; /** * Protected constructor. * * @param repConfig the repository configuration. * @throws RepositoryException if there is already another repository * instance running on the given configuration * or another error occurs. */ protected RepositoryImpl(RepositoryConfig repConfig) throws RepositoryException { // Acquire a lock on the repository home repLock = repConfig.getRepositoryLockMechanism(); repLock.init(repConfig.getHomeDir()); repLock.acquire(); long t0 = System.currentTimeMillis(); log.info("Starting repository..."); boolean succeeded = false; try { this.repConfig = repConfig; context.setFileSystem(repConfig.getFileSystem()); // Load root node identifier context.setRootNodeId(loadRootNodeId()); // initialize repository descriptors initRepositoryDescriptors(); // create registries context.setNamespaceRegistry(createNamespaceRegistry()); context.setNodeTypeRegistry(createNodeTypeRegistry()); context.setPrivilegeRegistry( new PrivilegeRegistry(context.getNamespaceRegistry(), context.getFileSystem())); // Create item state cache manager context.setItemStateCacheFactory(new ManagedMLRUItemStateCacheFactory(cacheMgr)); DataStore dataStore = repConfig.getDataStore(); if (dataStore != null) { context.setDataStore(dataStore); } nodeIdFactory = new NodeIdFactory(repConfig.getHomeDir()); nodeIdFactory.open(); context.setNodeIdFactory(nodeIdFactory); context.setWorkspaceManager(new WorkspaceManager(this)); // init workspace configs for (WorkspaceConfig config : repConfig.getWorkspaceConfigs()) { WorkspaceInfo info = createWorkspaceInfo(config); wspInfos.put(config.getName(), info); } // initialize optional clustering before setting up any other // external event source that a cluster node will be interested in ClusterNode clusterNode = null; if (repConfig.getClusterConfig() != null) { clusterNode = createClusterNode(); context.setClusterNode(clusterNode); context.getNamespaceRegistry().setEventChannel(clusterNode); context.getNodeTypeRegistry().setEventChannel(clusterNode); context.getPrivilegeRegistry().setEventChannel(clusterNode); createWorkspaceEventChannel = clusterNode; clusterNode.setListener(this); } // init version manager InternalVersionManagerImpl vMgr = createVersionManager(repConfig.getVersioningConfig(), delegatingDispatcher); context.setInternalVersionManager(vMgr); if (clusterNode != null) { vMgr.setEventChannel(clusterNode.createUpdateChannel(null)); } // init virtual node type manager virtNTMgr = new VirtualNodeTypeStateManager(context.getNodeTypeRegistry(), delegatingDispatcher, NODETYPES_NODE_ID, SYSTEM_ROOT_NODE_ID); // initialize startup workspaces initStartupWorkspaces(); // initialize system search manager getSystemSearchManager(repConfig.getDefaultWorkspaceName()); // Initialise the security manager; initSecurityManager(); // after the workspace is initialized we pass a system session to // the virtual node type manager // todo FIXME the *global* virtual node type manager is using a session that is bound to a single specific workspace... virtNTMgr.setSession(getSystemSession(repConfig.getDefaultWorkspaceName())); // now start cluster node as last step if (clusterNode != null) { setDescriptor(JACKRABBIT_CLUSTER_ID, repConfig.getClusterConfig().getId()); try { clusterNode.start(); } catch (ClusterException e) { String msg = "Unable to start clustered node, forcing shutdown..."; log.error(msg, e); shutdown(); throw new RepositoryException(msg, e); } } // amount of time in seconds before an idle workspace is automatically // shut down int maxIdleTime = repConfig.getWorkspaceMaxIdleTime(); if (maxIdleTime != 0) { // start workspace janitor thread Thread wspJanitor = new Thread(new WorkspaceJanitor(maxIdleTime * 1000)); wspJanitor.setName("WorkspaceJanitor"); wspJanitor.setPriority(Thread.MIN_PRIORITY); wspJanitor.setDaemon(true); wspJanitor.start(); } succeeded = true; log.info("Repository started (" + (System.currentTimeMillis() - t0) + "ms)"); } catch (RepositoryException e) { log.error("failed to start Repository: " + e.getMessage(), e); throw e; } finally { if (!succeeded) { try { // repository startup failed, clean up... shutdown(); } catch (Throwable t) { // ensure this exception does not overlay the original // startup exception and only log it log.error("In addition to startup fail, another unexpected problem " + "occurred while shutting down the repository again.", t); // Clear the repository lock if it was left in place repLock.release(); } } } } /** * Protected factory method for creating the namespace registry. * Called by the constructor after the repository file system has * been initialised. * * @return namespace registry * @throws RepositoryException if the namespace registry can not be created */ protected NamespaceRegistryImpl createNamespaceRegistry() throws RepositoryException { return new NamespaceRegistryImpl(context.getFileSystem()); } /** * Protected factory method for creating the node type registry. * Called by the constructor after the repository file system and * namespace registry have been initialised. * * @return node type registry * @throws RepositoryException if the node type registry can not be created */ protected NodeTypeRegistry createNodeTypeRegistry() throws RepositoryException { return new NodeTypeRegistry(context.getNamespaceRegistry(), context.getFileSystem()); } /** * Returns the internal component context of this repository. * This package-private method should only be used when there is * no other reasonable way to access the repository context. * A better design would be to access the repository instance * through the repository context. * * @return repository context */ RepositoryContext getRepositoryContext() { // TODO: Get rid of this method return context; } /** * Get the cache manager of this repository, useful * for setting its memory parameters. * * @return the cache manager * @since 1.3 */ public CacheManager getCacheManager() { return cacheMgr; } /** * Creates the {@link org.apache.jackrabbit.core.security.JackrabbitSecurityManager SecurityManager} * of this <code>Repository</code> and adds it to the repository context. * * @throws RepositoryException if an error occurs. */ private synchronized void initSecurityManager() throws RepositoryException { SecurityManagerConfig smc = getConfig().getSecurityConfig().getSecurityManagerConfig(); if (smc == null) { log.debug( "No configuration entry for SecurityManager. Using org.apache.jackrabbit.core.security.simple.SimpleSecurityManager"); securityMgr = new SimpleSecurityManager(); } else { securityMgr = smc.newInstance(JackrabbitSecurityManager.class); } log.info("SecurityManager = " + securityMgr.getClass()); context.setSecurityManager(securityMgr); String workspaceName = getConfig().getDefaultWorkspaceName(); if (smc != null && smc.getWorkspaceName() != null) { workspaceName = smc.getWorkspaceName(); } // mark the workspace as 'active' for that it does not get disposed // by the workspace-janitor // TODO: There should be a cleaner way to do this markWorkspaceActive(workspaceName); // FIXME: Note that this call must be done *after* the security // manager has been added to the repository context, since the // initialisation code may invoke code that depends on the presence // of a security manager. It would be better if this was not the case. SystemSession systemSession = getSystemSession(workspaceName); securityMgr.init(this, systemSession); // initial security specific repository descriptors that are defined // by JackrabbitRepository ValueFactory vf = ValueFactoryImpl.getInstance(); boolean hasUserMgt; try { securityMgr.getUserManager(systemSession); hasUserMgt = true; } catch (RepositoryException e) { hasUserMgt = false; } setDescriptor(JackrabbitRepository.OPTION_USER_MANAGEMENT_SUPPORTED, vf.createValue(hasUserMgt)); boolean hasPrincipalMgt; try { securityMgr.getPrincipalManager(systemSession); hasPrincipalMgt = true; } catch (RepositoryException e) { hasPrincipalMgt = false; } setDescriptor(JackrabbitRepository.OPTION_PRINCIPAL_MANAGEMENT_SUPPORTED, vf.createValue(hasPrincipalMgt)); setDescriptor(JackrabbitRepository.OPTION_PRIVILEGE_MANAGEMENT_SUPPORTED, vf.createValue(true)); } /** * Creates the version manager. * * @param vConfig the versioning config * @return the newly created version manager * @throws RepositoryException if an error occurs */ protected InternalVersionManagerImpl createVersionManager(VersioningConfig vConfig, DelegatingObservationDispatcher delegatingDispatcher) throws RepositoryException { FileSystem fs = vConfig.getFileSystem(); PersistenceManager pm = createPersistenceManager(vConfig.getHomeDir(), fs, vConfig.getPersistenceManagerConfig()); ISMLocking ismLocking = vConfig.getISMLocking(); return new InternalVersionManagerImpl(pm, fs, context.getNodeTypeRegistry(), delegatingDispatcher, SYSTEM_ROOT_NODE_ID, VERSION_STORAGE_NODE_ID, ACTIVITIES_NODE_ID, context.getItemStateCacheFactory(), ismLocking, context.getNodeIdFactory()); } /** * Initialize startup workspaces. Base implementation will initialize the * default workspace. Derived classes may initialize their own startup * workspaces <b>after</b> having called the base implementation. * * @throws RepositoryException if an error occurs */ protected void initStartupWorkspaces() throws RepositoryException { String wspName = repConfig.getDefaultWorkspaceName(); String secWspName = null; SecurityManagerConfig smc = repConfig.getSecurityConfig().getSecurityManagerConfig(); if (smc != null) { secWspName = smc.getWorkspaceName(); } try { (wspInfos.get(wspName)).initialize(); if (secWspName != null && !wspInfos.containsKey(secWspName)) { createWorkspace(secWspName); log.info("created system workspace: {}", secWspName); } } catch (RepositoryException e) { // if default workspace failed to initialize, shutdown again log.error("Failed to initialize workspace '" + wspName + "'", e); log.error("Unable to start repository, forcing shutdown..."); shutdown(); throw e; } } /** * Returns the root node identifier. The identifier is loaded from * the <code>meta/rootUUID</code> file within the repository file system. * If such a file does not yet exist, the hardcoded default root node * identifier ({@link #ROOT_NODE_ID}) is used and written to that file. * <p> * This utility method should only be used by the constructor after the * repository file system has been initialised. * * @return root node identifier * @throws RepositoryException if the identifier can not be loaded or saved */ private NodeId loadRootNodeId() throws RepositoryException { try { FileSystemResource uuidFile = new FileSystemResource(context.getFileSystem(), "/meta/rootUUID"); if (uuidFile.exists()) { // Load uuid of the repository's root node. It is stored in // text format (36 characters) for better readability. InputStream in = uuidFile.getInputStream(); try { return NodeId.valueOf(IOUtils.toString(in, "US-ASCII")); } finally { IOUtils.closeQuietly(in); } } else { // Use hard-coded uuid for root node rather than generating // a different uuid per repository instance; using a // hard-coded uuid makes it easier to copy/move entire // workspaces from one repository instance to another. uuidFile.makeParentDirs(); OutputStream out = uuidFile.getOutputStream(); try { out.write(ROOT_NODE_ID.toString().getBytes("US-ASCII")); return ROOT_NODE_ID; } finally { IOUtils.closeQuietly(out); } } } catch (IOException e) { throw new RepositoryException("Failed to load or persist the root node identifier", e); } catch (FileSystemException fse) { throw new RepositoryException("Failed to access the root node identifier", fse); } } /** * Creates a new <code>RepositoryImpl</code> instance. * <p/> * * @param config the configuration of the repository * @return a new <code>RepositoryImpl</code> instance * @throws RepositoryException If an error occurs */ public static RepositoryImpl create(RepositoryConfig config) throws RepositoryException { return new RepositoryImpl(config); } /** * Performs a sanity check on this repository instance. * * @throws RepositoryException if this repository has been rendered * invalid for some reason (e.g. if it has been shut down) */ protected void sanityCheck() throws RepositoryException { // check repository status if (disposed) { throw new RepositoryException("This repository instance has been shut down."); } } /** * Returns the system search manager or <code>null</code> if none is * configured. */ protected SearchManager getSystemSearchManager(String wspName) throws RepositoryException { if (systemSearchMgr == null) { if (repConfig.isSearchEnabled()) { systemSearchMgr = new SearchManager(null, context, repConfig, getWorkspaceInfo(wspName).itemStateMgr, context.getInternalVersionManager().getPersistenceManager(), SYSTEM_ROOT_NODE_ID, null, null); SystemSession defSysSession = getSystemSession(wspName); ObservationManager obsMgr = defSysSession.getWorkspace().getObservationManager(); obsMgr.addEventListener(systemSearchMgr, Event.NODE_ADDED | Event.NODE_REMOVED | Event.PROPERTY_ADDED | Event.PROPERTY_CHANGED | Event.PROPERTY_REMOVED, "/" + defSysSession.getJCRName(NameConstants.JCR_SYSTEM), true, null, null, false); } } return systemSearchMgr; } /** * Creates the cluster node. * * @return clustered node */ protected ClusterNode createClusterNode() throws RepositoryException { try { ClusterNode clusterNode = new ClusterNode(); clusterNode.init(new ExternalEventListener()); return clusterNode; } catch (Exception e) { throw new RepositoryException(e); } } /** * Returns the names of <i>all</i> workspaces in this repository. * * @return the names of all workspaces in this repository. * @see javax.jcr.Workspace#getAccessibleWorkspaceNames() */ protected String[] getWorkspaceNames() { synchronized (wspInfos) { return wspInfos.keySet().toArray(new String[wspInfos.keySet().size()]); } } /** * Returns the {@link WorkspaceInfo} for the named workspace. * * @param workspaceName The name of the workspace whose {@link WorkspaceInfo} * is to be returned. This must not be <code>null</code>. * @return The {@link WorkspaceInfo} for the named workspace. This will * never be <code>null</code>. * @throws NoSuchWorkspaceException If the named workspace does not exist. * @throws RepositoryException If this repository has been shut down. */ protected WorkspaceInfo getWorkspaceInfo(String workspaceName) throws NoSuchWorkspaceException, RepositoryException { // check sanity of this instance sanityCheck(); WorkspaceInfo wspInfo; synchronized (wspInfos) { wspInfo = wspInfos.get(workspaceName); if (wspInfo == null) { throw new NoSuchWorkspaceException(workspaceName); } } try { wspInfo.initialize(); } catch (RepositoryException e) { log.error("Unable to initialize workspace '" + workspaceName + "'", e); throw new NoSuchWorkspaceException(workspaceName); } return wspInfo; } /** * Creates a workspace with the given name. * * @param workspaceName name of the new workspace * @throws RepositoryException if a workspace with the given name * already exists or if another error occurs * @see WorkspaceImpl#createWorkspace(String) */ protected void createWorkspace(String workspaceName) throws RepositoryException { synchronized (wspInfos) { if (wspInfos.containsKey(workspaceName)) { throw new RepositoryException("workspace '" + workspaceName + "' already exists."); } // needed to get newly created workspace config file content when // running in clustered environment StringBuffer workspaceConfigContent = null; if (context.getClusterNode() != null) { workspaceConfigContent = new StringBuffer(); } // create the workspace configuration WorkspaceConfig config = repConfig.createWorkspaceConfig(workspaceName, workspaceConfigContent); WorkspaceInfo info = createWorkspaceInfo(config); wspInfos.put(workspaceName, info); if (workspaceConfigContent != null && createWorkspaceEventChannel != null) { // notify other cluster node that workspace has been created InputSource s = new InputSource(new StringReader(workspaceConfigContent.toString())); createWorkspaceEventChannel.workspaceCreated(workspaceName, new ClonedInputSource(s)); } } } public void externalWorkspaceCreated(String workspaceName, InputSource configTemplate) throws RepositoryException { createWorkspaceInternal(workspaceName, configTemplate); } /** * Creates a workspace with the given name and given workspace configuration * template. * * The difference between this method and {@link #createWorkspace(String, InputSource)} * is that the later notifies the other cluster node that workspace has been created * whereas this method only creates the workspace. * * @param workspaceName name of the new workspace * @param configTemplate the workspace configuration template of the new * workspace * @throws RepositoryException if a workspace with the given name already * exists or if another error occurs * @see WorkspaceImpl#createWorkspace(String,InputSource) */ private void createWorkspaceInternal(String workspaceName, InputSource configTemplate) throws RepositoryException { synchronized (wspInfos) { if (wspInfos.containsKey(workspaceName)) { throw new RepositoryException("workspace '" + workspaceName + "' already exists."); } // create the workspace configuration WorkspaceConfig config = repConfig.createWorkspaceConfig(workspaceName, configTemplate); WorkspaceInfo info = createWorkspaceInfo(config); wspInfos.put(workspaceName, info); } } /** * Creates a workspace with the given name and given workspace configuration * template. * * @param workspaceName name of the new workspace * @param configTemplate the workspace configuration template of the new * workspace * @throws RepositoryException if a workspace with the given name already * exists or if another error occurs * @see WorkspaceImpl#createWorkspace(String,InputSource) */ protected void createWorkspace(String workspaceName, InputSource configTemplate) throws RepositoryException { if (createWorkspaceEventChannel == null) { createWorkspaceInternal(workspaceName, configTemplate); } else { ClonedInputSource template = new ClonedInputSource(configTemplate); createWorkspaceInternal(workspaceName, template.cloneInputSource()); createWorkspaceEventChannel.workspaceCreated(workspaceName, template); } } SharedItemStateManager getWorkspaceStateManager(String workspaceName) throws NoSuchWorkspaceException, RepositoryException { // check sanity of this instance sanityCheck(); return getWorkspaceInfo(workspaceName).getItemStateProvider(); } /** * Enables or disables referential integrity checking for given workspace. * Disabling referential integrity checks can result in a corrupted * workspace, and thus this feature is only available to customized * implementations that subclass RepositoryImpl. * * @see <a href="https://issues.apache.org/jira/browse/JCR-954">Issue JCR-954</a> * @param workspace name of the workspace * @param enabled <code>true</code> to enable integrity checking (default), * <code>false</code> to disable it * @throws RepositoryException if an error occurs */ protected void setReferentialIntegrityChecking(String workspace, boolean enabled) throws RepositoryException { SharedItemStateManager manager = getWorkspaceStateManager(workspace); manager.setCheckReferences(enabled); } ObservationDispatcher getObservationDispatcher(String workspaceName) throws NoSuchWorkspaceException, RepositoryException { // check sanity of this instance sanityCheck(); return getWorkspaceInfo(workspaceName).getObservationDispatcher(); } /** * Returns the {@link SearchManager} for the workspace with name * <code>workspaceName</code>. * * @param workspaceName the name of the workspace. * @return the <code>SearchManager</code> for the workspace, or * <code>null</code> if the workspace does not have a * <code>SearchManager</code> configured. * @throws NoSuchWorkspaceException if there is no workspace with name * <code>workspaceName</code>. * @throws RepositoryException if an error occurs while opening the * search index. */ SearchManager getSearchManager(String workspaceName) throws NoSuchWorkspaceException, RepositoryException { // check sanity of this instance sanityCheck(); return getWorkspaceInfo(workspaceName).getSearchManager(); } /** * Returns the {@link LockManager} for the workspace with name * <code>workspaceName</code> * * @param workspaceName workspace name * @return <code>LockManager</code> for the workspace * @throws NoSuchWorkspaceException if such a workspace does not exist * @throws RepositoryException if some other error occurs */ LockManagerImpl getLockManager(String workspaceName) throws NoSuchWorkspaceException, RepositoryException { // check sanity of this instance sanityCheck(); return getWorkspaceInfo(workspaceName).getLockManager(); } /** * Returns the {@link org.apache.jackrabbit.core.retention.RetentionRegistry} for the workspace with name * <code>workspaceName</code> * * @param workspaceName workspace name * @return <code>RetentionEvaluator</code> for the workspace * @throws NoSuchWorkspaceException if such a workspace does not exist * @throws RepositoryException if some other error occurs */ RetentionRegistry getRetentionRegistry(String workspaceName) throws NoSuchWorkspaceException, RepositoryException { // check sanity of this instance sanityCheck(); return getWorkspaceInfo(workspaceName).getRetentionRegistry(); } /** * Returns the {@link SystemSession} for the workspace with name * <code>workspaceName</code> * * @param workspaceName workspace name * @return system session of the specified workspace * @throws NoSuchWorkspaceException if such a workspace does not exist * @throws RepositoryException if some other error occurs */ SystemSession getSystemSession(String workspaceName) throws NoSuchWorkspaceException, RepositoryException { // check sanity of this instance sanityCheck(); return getWorkspaceInfo(workspaceName).getSystemSession(); } /** * Marks the specified workspace as "active", so that the workspace * janitor won't attempt to dispose it. This is used by features like * security managers and the data store garbage collector to prevent * workspaces from disappearing from below them. * <p> * FIXME: There should be a cleaner way to do this. * * @param workspaceName workspace name * @throws RepositoryException if the workspace can not be accessed */ void markWorkspaceActive(String workspaceName) throws RepositoryException { getWorkspaceInfo(workspaceName).setActive(true); } /** * Creates a new repository session on the specified workspace for the * <b><i>authenticated</i></b> subject of the given login context and * adds it to the <i>active</i> sessions. * <p/> * Calls {@link #createSessionInstance(AuthContext, WorkspaceConfig)} to * create the actual <code>SessionImpl</code> instance. * * @param loginContext login context with authenticated subject * @param workspaceName workspace name * @return a new session * @throws NoSuchWorkspaceException if the specified workspace does not exist * @throws AccessDeniedException if the subject of the given login context * is not granted access to the specified * workspace * @throws RepositoryException if another error occurs */ protected final SessionImpl createSession(AuthContext loginContext, String workspaceName) throws NoSuchWorkspaceException, AccessDeniedException, RepositoryException { WorkspaceInfo wspInfo = getWorkspaceInfo(workspaceName); SessionImpl ses = createSessionInstance(loginContext, wspInfo.getConfig()); onSessionCreated(ses); // reset idle timestamp wspInfo.setIdleTimestamp(0); return ses; } /** * Creates a new repository session on the specified workspace for the given * <b><i>authenticated</i></b> subject and adds it to the <i>active</i> * sessions. * <p/> * Calls {@link #createSessionInstance(Subject, WorkspaceConfig)} to * create the actual <code>SessionImpl</code> instance. * * @param subject authenticated subject * @param workspaceName workspace name * @return a new session * @throws NoSuchWorkspaceException if the specified workspace does not exist * @throws AccessDeniedException if the subject of the given login context * is not granted access to the specified * workspace * @throws RepositoryException if another error occurs */ protected final SessionImpl createSession(Subject subject, String workspaceName) throws NoSuchWorkspaceException, AccessDeniedException, RepositoryException { WorkspaceInfo wspInfo = getWorkspaceInfo(workspaceName); SessionImpl ses = createSessionInstance(subject, wspInfo.getConfig()); onSessionCreated(ses); // reset idle timestamp wspInfo.setIdleTimestamp(0); return ses; } /** * Adds the given session to the list of active sessions and registers this * repository as listener. * * @param session the session to register */ protected void onSessionCreated(SessionImpl session) { synchronized (activeSessions) { session.addListener(this); activeSessions.put(session, session); } } /** * Tries to add Principals to a given subject: * First Access the Subject from the current AccessControlContext, * If Subject is found the LoginContext is evoked for it, in order * to possibly allow for extension of preauthenticated Subject.<br> * In contrast to a login with Credentials, a Session is created, even if the * Authentication failed.<br> * If the {@link Subject} is marked to be unmodificable or if the * authentication of the the Subject failed Session is build for unchanged * Subject. * * @param workspaceName must not be null * @return if a Subject is exsting null else * @throws RepositoryException * @throws AccessDeniedException */ private Session extendAuthentication(String workspaceName) throws RepositoryException, AccessDeniedException { Subject subject = null; try { AccessControlContext acc = AccessController.getContext(); subject = Subject.getSubject(acc); } catch (SecurityException e) { log.warn("Can't check for preauthentication. Reason: {}", e.getMessage()); } if (subject == null) { log.debug("No preauthenticated subject found -> return null."); return null; } Session s; if (subject.isReadOnly()) { log.debug("Preauthenticated Subject is read-only -> create Session"); s = createSession(subject, workspaceName); } else { log.debug("Found preauthenticated Subject, try to extend authentication"); // login either using JAAS or custom LoginModule AuthContext authCtx = context.getSecurityManager().getAuthContext(null, subject, workspaceName); try { authCtx.login(); s = createSession(authCtx, workspaceName); } catch (javax.security.auth.login.LoginException e) { // subject could not be extended log.debug("Preauthentication could not be extended"); s = createSession(subject, workspaceName); } } return s; } //-------------------------------------------------< JackrabbitRepository > /** * Shuts down this repository. The shutdown is guarded by a shutdown lock * that prevents any new sessions from being started simultaneously. */ public void shutdown() { try { shutdownLock.writeLock().acquire(); } catch (InterruptedException e) { // TODO: Should this be a checked exception? throw new RuntimeException("Shutdown lock could not be acquired", e); } try { // check status of this instance if (!disposed) { doShutdown(); } } finally { shutdownLock.writeLock().release(); } } /** * Protected method that performs the actual shutdown after the shutdown * lock has been acquired by the {@link #shutdown()} method. */ protected synchronized void doShutdown() { log.info("Shutting down repository..."); // stop optional cluster node ClusterNode clusterNode = context.getClusterNode(); if (clusterNode != null) { clusterNode.stop(); } if (securityMgr != null) { securityMgr.close(); } // close active user sessions // (copy sessions to array to avoid ConcurrentModificationException; // manually copy entries rather than calling ReferenceMap#toArray() in // order to work around http://issues.apache.org/bugzilla/show_bug.cgi?id=25551) List<Session> sa; synchronized (activeSessions) { sa = new ArrayList<Session>(activeSessions.size()); for (Session session : activeSessions.values()) { sa.add(session); } } for (Session session : sa) { if (session != null) { session.logout(); } } // shutdown system search manager if there is one if (systemSearchMgr != null) { systemSearchMgr.close(); } // shut down workspaces synchronized (wspInfos) { for (WorkspaceInfo wspInfo : wspInfos.values()) { wspInfo.dispose(); } } try { InternalVersionManager m = context.getInternalVersionManager(); if (m != null) { m.close(); } } catch (Exception e) { log.error("Error while closing Version Manager.", e); } repDescriptors.clear(); DataStore dataStore = context.getDataStore(); if (dataStore != null) { try { // close the datastore dataStore.close(); } catch (DataStoreException e) { log.error("error while closing datastore", e); } } try { // close repository file system context.getFileSystem().close(); } catch (FileSystemException e) { log.error("error while closing repository file system", e); } try { nodeIdFactory.close(); } catch (RepositoryException e) { log.error("error while closing repository file system", e); } // make sure this instance is not used anymore disposed = true; // wake up threads waiting on this instance's monitor (e.g. workspace janitor) notifyAll(); // Shut down the executor service ScheduledExecutorService executor = context.getExecutor(); executor.shutdown(); try { // Wait for all remaining background threads to terminate if (!executor.awaitTermination(10, TimeUnit.SECONDS)) { log.warn("Attempting to forcibly shutdown runaway threads"); executor.shutdownNow(); } } catch (InterruptedException e) { log.warn("Interrupted while waiting for background threads", e); } repConfig.getConnectionFactory().close(); // finally release repository lock if (repLock != null) { try { repLock.release(); } catch (RepositoryException e) { log.error("failed to release the repository lock", e); } } log.info("Repository has been shutdown"); } /** * Returns the configuration of this repository. * @return repository configuration */ public RepositoryConfig getConfig() { return repConfig; } /** * Initializes the repository descriptors by executing the following steps: * <ul> * <li>Sets standard descriptors</li> * <li>{@link #getCustomRepositoryDescriptors()} is called * afterwards in order to add custom/overwrite standard repository descriptors.</li> * </ul> * * @throws RepositoryException */ protected void initRepositoryDescriptors() throws RepositoryException { ValueFactory valFactory = ValueFactoryImpl.getInstance(); Value valTrue = valFactory.createValue(true); Value valFalse = valFactory.createValue(false); setDescriptor(Repository.REP_NAME_DESC, "Jackrabbit"); setDescriptor(Repository.REP_VENDOR_DESC, "Apache Software Foundation"); setDescriptor(Repository.REP_VENDOR_URL_DESC, "http://jackrabbit.apache.org/"); setDescriptor(Repository.SPEC_NAME_DESC, "Content Repository API for Java(TM) Technology Specification"); setDescriptor(Repository.SPEC_VERSION_DESC, "2.0"); setDescriptor(Repository.IDENTIFIER_STABILITY, Repository.IDENTIFIER_STABILITY_INDEFINITE_DURATION); setDescriptor(Repository.LEVEL_1_SUPPORTED, valTrue); setDescriptor(Repository.LEVEL_2_SUPPORTED, valTrue); setDescriptor(Repository.WRITE_SUPPORTED, valTrue); setDescriptor(Repository.OPTION_NODE_TYPE_MANAGEMENT_SUPPORTED, valTrue); setDescriptor(Repository.NODE_TYPE_MANAGEMENT_AUTOCREATED_DEFINITIONS_SUPPORTED, valTrue); setDescriptor(Repository.NODE_TYPE_MANAGEMENT_INHERITANCE, Repository.NODE_TYPE_MANAGEMENT_INHERITANCE_MULTIPLE); setDescriptor(Repository.NODE_TYPE_MANAGEMENT_MULTIPLE_BINARY_PROPERTIES_SUPPORTED, valTrue); setDescriptor(Repository.NODE_TYPE_MANAGEMENT_MULTIVALUED_PROPERTIES_SUPPORTED, valTrue); setDescriptor(Repository.NODE_TYPE_MANAGEMENT_ORDERABLE_CHILD_NODES_SUPPORTED, valTrue); setDescriptor(Repository.NODE_TYPE_MANAGEMENT_OVERRIDES_SUPPORTED, valFalse); setDescriptor(Repository.NODE_TYPE_MANAGEMENT_PRIMARY_ITEM_NAME_SUPPORTED, valTrue); Value[] types = new Value[] { valFactory.createValue(PropertyType.BINARY), valFactory.createValue(PropertyType.BOOLEAN), valFactory.createValue(PropertyType.DATE), valFactory.createValue(PropertyType.DECIMAL), valFactory.createValue(PropertyType.DOUBLE), valFactory.createValue(PropertyType.LONG), valFactory.createValue(PropertyType.NAME), valFactory.createValue(PropertyType.PATH), valFactory.createValue(PropertyType.REFERENCE), valFactory.createValue(PropertyType.STRING), valFactory.createValue(PropertyType.URI), valFactory.createValue(PropertyType.WEAKREFERENCE), valFactory.createValue(PropertyType.UNDEFINED) }; setDescriptor(Repository.NODE_TYPE_MANAGEMENT_PROPERTY_TYPES, types); setDescriptor(Repository.NODE_TYPE_MANAGEMENT_RESIDUAL_DEFINITIONS_SUPPORTED, valTrue); setDescriptor(Repository.NODE_TYPE_MANAGEMENT_SAME_NAME_SIBLINGS_SUPPORTED, valTrue); setDescriptor(Repository.NODE_TYPE_MANAGEMENT_VALUE_CONSTRAINTS_SUPPORTED, valTrue); setDescriptor(Repository.NODE_TYPE_MANAGEMENT_UPDATE_IN_USE_SUPORTED, valFalse); setDescriptor(Repository.OPTION_ACCESS_CONTROL_SUPPORTED, valTrue); setDescriptor(Repository.OPTION_JOURNALED_OBSERVATION_SUPPORTED, valTrue); setDescriptor(Repository.OPTION_LIFECYCLE_SUPPORTED, valTrue); setDescriptor(Repository.OPTION_LOCKING_SUPPORTED, valTrue); setDescriptor(Repository.OPTION_OBSERVATION_SUPPORTED, valTrue); setDescriptor(Repository.OPTION_NODE_AND_PROPERTY_WITH_SAME_NAME_SUPPORTED, valTrue); setDescriptor(Repository.OPTION_QUERY_SQL_SUPPORTED, valTrue); setDescriptor(Repository.OPTION_RETENTION_SUPPORTED, valTrue); setDescriptor(Repository.OPTION_SHAREABLE_NODES_SUPPORTED, valTrue); setDescriptor(Repository.OPTION_SIMPLE_VERSIONING_SUPPORTED, valTrue); setDescriptor(Repository.OPTION_TRANSACTIONS_SUPPORTED, valTrue); setDescriptor(Repository.OPTION_UNFILED_CONTENT_SUPPORTED, valFalse); setDescriptor(Repository.OPTION_UPDATE_MIXIN_NODE_TYPES_SUPPORTED, valTrue); setDescriptor(Repository.OPTION_UPDATE_PRIMARY_NODE_TYPE_SUPPORTED, valTrue); setDescriptor(Repository.OPTION_VERSIONING_SUPPORTED, valTrue); setDescriptor(Repository.OPTION_WORKSPACE_MANAGEMENT_SUPPORTED, valTrue); setDescriptor(Repository.OPTION_XML_EXPORT_SUPPORTED, valTrue); setDescriptor(Repository.OPTION_XML_IMPORT_SUPPORTED, valTrue); setDescriptor(Repository.OPTION_ACTIVITIES_SUPPORTED, valTrue); setDescriptor(Repository.OPTION_BASELINES_SUPPORTED, valTrue); setDescriptor(Repository.QUERY_FULL_TEXT_SEARCH_SUPPORTED, valTrue); setDescriptor(Repository.QUERY_JOINS, Repository.QUERY_JOINS_INNER_OUTER); Value[] languages = new Value[] { valFactory.createValue("javax.jcr.query.JCR-JQOM"), valFactory.createValue("javax.jcr.query.JCR-SQL2") }; setDescriptor(Repository.QUERY_LANGUAGES, languages); setDescriptor(Repository.QUERY_STORED_QUERIES_SUPPORTED, valTrue); setDescriptor(Repository.QUERY_XPATH_POS_INDEX, valTrue); // Disabled since in default configuration document order is not supported. // See https://issues.apache.org/jira/browse/JCR-1237 for details setDescriptor(Repository.QUERY_XPATH_DOC_ORDER, valFalse); // now set customized repository descriptor values (if any exist) Properties props = getCustomRepositoryDescriptors(); if (props != null) { for (Object o : props.keySet()) { String key = (String) o; setDescriptor(key, props.getProperty(key)); } } } /** * Returns a <code>Properties</code> object containing custom repository * descriptors or <code>null</code> if none exist. * <p/> * Overridable to allow subclasses to add custom descriptors or to * override standard descriptor values. * <p/> * Note that the properties entries will be set as single-valued <code>STRING</code> * descriptor values. * <p/> * This method tries to load the <code>Properties</code> from the * <code>org/apache/jackrabbit/core/repository.properties</code> resource * found in the class path. * * @throws RepositoryException if the properties can not be loaded */ protected Properties getCustomRepositoryDescriptors() throws RepositoryException { InputStream in = RepositoryImpl.class.getResourceAsStream(PROPERTIES_RESOURCE); if (in != null) { try { Properties props = new Properties(); props.load(in); return props; } catch (IOException e) { String msg = "Failed to load customized repository properties: " + e.toString(); log.error(msg); throw new RepositoryException(msg, e); } finally { IOUtils.closeQuietly(in); } } else { return null; } } protected void setDescriptor(String desc, String value) { setDescriptor(desc, ValueFactoryImpl.getInstance().createValue(value)); } protected void setDescriptor(String desc, Value value) { repDescriptors.put(desc, new DescriptorValue(value)); } protected void setDescriptor(String desc, Value[] values) { repDescriptors.put(desc, new DescriptorValue(values)); } /** * Creates a workspace persistence manager based on the given * configuration. The persistence manager is instantiated using * information in the given persistence manager configuration and * initialized with a persistence manager context containing the other * arguments. * * @return the created workspace persistence manager * @throws RepositoryException if the persistence manager could * not be instantiated/initialized */ private PersistenceManager createPersistenceManager(File homeDir, FileSystem fs, PersistenceManagerConfig pmConfig) throws RepositoryException { try { PersistenceManager pm = pmConfig.newInstance(PersistenceManager.class); PMContext pmContext = new PMContext(homeDir, fs, context.getRootNodeId(), context.getNamespaceRegistry(), context.getNodeTypeRegistry(), context.getDataStore(), context.getRepositoryStatistics()); pm.init(pmContext); return pm; } catch (Exception e) { String msg = "Cannot instantiate persistence manager " + pmConfig.getClassName(); throw new RepositoryException(msg, e); } } /** * Creates a <code>SharedItemStateManager</code> or derivative. * * @param persistMgr persistence manager * @param usesReferences <code>true</code> if the item state manager should use * node references to verify integrity of its reference properties; * <code>false</code> otherwise * @return item state manager * @throws ItemStateException if an error occurs */ protected SharedItemStateManager createItemStateManager(PersistenceManager persistMgr, boolean usesReferences, ISMLocking locking) throws ItemStateException { return new SharedItemStateManager(persistMgr, context.getRootNodeId(), context.getNodeTypeRegistry(), true, context.getItemStateCacheFactory(), locking, context.getNodeIdFactory()); } /** * Creates a data store garbage collector for this repository. * <p> * Note that you should use the {@link RepositoryManager} interface * to access this functionality. This RepositoryImpl method may be * removed in future Jackrabbit versions. */ public GarbageCollector createDataStoreGarbageCollector() throws RepositoryException { ArrayList<PersistenceManager> pmList = new ArrayList<PersistenceManager>(); InternalVersionManagerImpl vm = context.getInternalVersionManager(); PersistenceManager pm = vm.getPersistenceManager(); pmList.add(pm); String[] wspNames = getWorkspaceNames(); SessionImpl[] sessions = new SessionImpl[wspNames.length]; for (int i = 0; i < wspNames.length; i++) { String wspName = wspNames[i]; WorkspaceInfo wspInfo = getWorkspaceInfo(wspName); // this will initialize the workspace if required SessionImpl systemSession = SystemSession.create(context, wspInfo.getConfig()); // mark the workspace as 'active' so it does not get disposed by // the workspace-janitor until the garbage collector is done wspInfo.setActive(true); // the workspace could be disposed, so re-initialize if required // afterwards it will not be disposed because it was marked active wspInfo.initialize(); sessions[i] = systemSession; pm = wspInfo.getPersistenceManager(); pmList.add(pm); } IterablePersistenceManager[] ipmList = new IterablePersistenceManager[pmList.size()]; for (int i = 0; i < pmList.size(); i++) { pm = pmList.get(i); if (!(pm instanceof IterablePersistenceManager)) { ipmList = null; break; } ipmList[i] = (IterablePersistenceManager) pm; } GarbageCollector gc = new GarbageCollector(context, context.getDataStore(), ipmList, sessions); synchronized (this) { if (context.isGcRunning()) { throw new RepositoryException("Cannot create GC. GC already running"); } context.setGcRunning(true); } return gc; } //-----------------------------------------------------------< Repository > /** * {@inheritDoc} */ public Session login(Credentials credentials, String workspaceName) throws LoginException, NoSuchWorkspaceException, RepositoryException { try { shutdownLock.readLock().acquire(); } catch (InterruptedException e) { throw new RepositoryException("Login lock could not be acquired", e); } try { // check sanity of this instance sanityCheck(); if (workspaceName == null) { workspaceName = repConfig.getDefaultWorkspaceName(); } // check if workspace exists (will throw NoSuchWorkspaceException if not) getWorkspaceInfo(workspaceName); if (credentials == null) { // try to obtain the identity of the already authenticated // subject from access control context Session session = extendAuthentication(workspaceName); if (session != null) { // successful extended authentication return session; } else { log.debug( "Attempt to login without Credentials and Subject -> try login with null credentials."); } } // not preauthenticated -> try login with credentials AuthContext authCtx = context.getSecurityManager().getAuthContext(credentials, new Subject(), workspaceName); authCtx.login(); // create session, and add SimpleCredentials attributes (JCR-1932) SessionImpl session = createSession(authCtx, workspaceName); if (credentials instanceof SimpleCredentials) { SimpleCredentials sc = (SimpleCredentials) credentials; for (String name : sc.getAttributeNames()) { if (!TokenBasedAuthentication.isMandatoryAttribute(name)) { session.setAttribute(name, sc.getAttribute(name)); } } } Set<TokenCredentials> tokenCreds = session.getSubject().getPublicCredentials(TokenCredentials.class); if (!tokenCreds.isEmpty()) { TokenCredentials tc = tokenCreds.iterator().next(); for (String name : tc.getAttributeNames()) { if (!TokenBasedAuthentication.isMandatoryAttribute(name)) { session.setAttribute(name, tc.getAttribute(name)); } } } log.debug("User {} logged in to workspace {}", session.getUserID(), workspaceName); return session; } catch (SecurityException se) { throw new LoginException("Unable to access authentication information", se); } catch (javax.security.auth.login.LoginException le) { throw new LoginException(le.getMessage(), le); } catch (AccessDeniedException ade) { // authenticated subject is not authorized for the specified workspace throw new LoginException("Workspace access denied", ade); } finally { shutdownLock.readLock().release(); } } /** * {@inheritDoc} */ public String getDescriptor(String key) { Value v = getDescriptorValue(key); try { return (v == null) ? null : v.getString(); } catch (RepositoryException e) { log.error("corrupt descriptor value: " + key, e); return null; } } /** * {@inheritDoc} */ public String[] getDescriptorKeys() { String[] keys = repDescriptors.keySet().toArray(new String[repDescriptors.keySet().size()]); Arrays.sort(keys); return keys; } /** * {@inheritDoc} */ public Value getDescriptorValue(String key) { DescriptorValue descVal = repDescriptors.get(key); return (descVal != null) ? descVal.getValue() : null; } /** * {@inheritDoc} */ public Value[] getDescriptorValues(String key) { DescriptorValue descVal = repDescriptors.get(key); return (descVal != null) ? descVal.getValues() : null; } /** * {@inheritDoc} */ public boolean isSingleValueDescriptor(String key) { DescriptorValue descVal = repDescriptors.get(key); return (descVal != null && descVal.getValue() != null); } //------------------------------------------------------< SessionListener > /** * {@inheritDoc} */ public void loggingOut(SessionImpl session) { } /** * {@inheritDoc} */ public void loggedOut(SessionImpl session) { synchronized (activeSessions) { // remove session from active sessions activeSessions.remove(session); } } //------------------------------------------< overridable factory methods > /** * Creates an instance of the {@link SessionImpl} class representing a * user authenticated by the <code>loginContext</code> instance attached * to the workspace configured by the <code>wspConfig</code>. * * @throws AccessDeniedException if the subject of the given login context * is not granted access to the specified * workspace * @throws RepositoryException If any other error occurs creating the * session. */ protected SessionImpl createSessionInstance(AuthContext loginContext, WorkspaceConfig wspConfig) throws AccessDeniedException, RepositoryException { return new XASessionImpl(context, loginContext, wspConfig); } /** * Creates an instance of the {@link SessionImpl} class representing a * user represented by the <code>subject</code> instance attached * to the workspace configured by the <code>wspConfig</code>. * * @throws AccessDeniedException if the subject of the given login context * is not granted access to the specified * workspace * @throws RepositoryException If any other error occurs creating the * session. */ protected SessionImpl createSessionInstance(Subject subject, WorkspaceConfig wspConfig) throws AccessDeniedException, RepositoryException { return new XASessionImpl(context, subject, wspConfig); } /** * Creates a new {@link RepositoryImpl.WorkspaceInfo} instance for * <code>wspConfig</code>. * * @param wspConfig the workspace configuration. * @return a new <code>WorkspaceInfo</code> instance. */ protected WorkspaceInfo createWorkspaceInfo(WorkspaceConfig wspConfig) { return new WorkspaceInfo(wspConfig); } //--------------------------------------------------------< inner classes > /** * <code>WorkspaceInfo</code> holds the objects that are shared * among multiple per-session <code>WorkspaceImpl</code> instances * representing the same named workspace, i.e. the same physical * storage. */ public class WorkspaceInfo implements UpdateEventListener { /** * workspace configuration (passed in constructor) */ private final WorkspaceConfig config; /** * file system (instantiated on init) */ private FileSystem fs; /** * persistence manager (instantiated on init) */ private PersistenceManager persistMgr; /** * item state provider (instantiated on init) */ private SharedItemStateManager itemStateMgr; /** * observation dispatcher (instantiated on init) */ private ObservationDispatcher dispatcher; /** * system session (lazily instantiated) */ private SystemSession systemSession; /** * search manager (lazily instantiated) */ private SearchManager searchMgr; /** * lock manager (lazily instantiated) */ private LockManagerImpl lockMgr; /** * internal manager for evaluation of effective retention policies * and holds */ private RetentionRegistryImpl retentionReg; /** * flag indicating whether this instance has been initialized. */ private boolean initialized; /** * Flag used to mark this as an "active" workspace that should not * get automatically disposed by the workspace janitor. */ private boolean active; /** * lock that guards the initialization of this instance */ private final ReadWriteLock initLock = new ReentrantWriterPreferenceReadWriteLock(); /** * timestamp when the workspace has been determined being idle */ private long idleTimestamp; /** * mutex for this workspace, used for locking transactions */ private final Mutex xaLock = new Mutex(); /** * Update event channel, used in clustered environment. */ private UpdateEventChannel updateChannel; /** * Lock event channel, used in clustered environment. */ private LockEventChannel lockChannel; /** * Creates a new <code>WorkspaceInfo</code> based on the given * <code>config</code>. * * @param config workspace configuration */ protected WorkspaceInfo(WorkspaceConfig config) { this.config = config; idleTimestamp = 0; initialized = false; } /** * Returns the workspace name. * * @return the workspace name */ protected String getName() { return config.getName(); } /** * Returns the workspace configuration. * * @return the workspace configuration */ public WorkspaceConfig getConfig() { return config; } /** * Returns the timestamp when the workspace has become idle or zero * if the workspace is currently not idle. * * @return the timestamp when the workspace has become idle or zero if * the workspace is not idle. */ final long getIdleTimestamp() { return idleTimestamp; } /** * Sets the timestamp when the workspace has become idle. if * <code>ts == 0</code> the workspace is marked as being currently * active. * * @param ts timestamp when workspace has become idle. */ final void setIdleTimestamp(long ts) { idleTimestamp = ts; } /** * Returns <code>true</code> if this workspace info is initialized, * otherwise returns <code>false</code>. * * @return <code>true</code> if this workspace info is initialized. */ protected final boolean isInitialized() { try { if (!initLock.readLock().attempt(0)) { return false; } } catch (InterruptedException e) { return false; } // can't use 'finally' pattern here boolean ret = initialized; initLock.readLock().release(); return ret; } public boolean isActive() { return active; } public void setActive(boolean active) { this.active = active; } /** * Returns the workspace file system. * * @return the workspace file system */ protected FileSystem getFileSystem() { if (!isInitialized()) { throw new IllegalStateException("workspace '" + getName() + "' not initialized"); } return fs; } /** * Returns the workspace persistence manager. * * @return the workspace persistence manager * @throws RepositoryException if the persistence manager could not be * instantiated/initialized */ public PersistenceManager getPersistenceManager() throws RepositoryException { if (!isInitialized()) { throw new IllegalStateException("workspace '" + getName() + "' not initialized"); } return persistMgr; } /** * Returns the workspace item state provider * * @return the workspace item state provider * @throws RepositoryException if the workspace item state provider * could not be created */ protected SharedItemStateManager getItemStateProvider() throws RepositoryException { if (!isInitialized()) { throw new IllegalStateException("workspace '" + getName() + "' not initialized"); } return itemStateMgr; } /** * Returns the observation dispatcher for this workspace * * @return the observation dispatcher for this workspace */ protected ObservationDispatcher getObservationDispatcher() { if (!isInitialized()) { throw new IllegalStateException("workspace '" + getName() + "' not initialized"); } return dispatcher; } /** * Returns the search manager for this workspace. * * @return the search manager for this workspace, or <code>null</code> * if no <code>SearchManager</code> * @throws RepositoryException if the search manager could not be created */ protected SearchManager getSearchManager() throws RepositoryException { if (!isInitialized()) { throw new IllegalStateException("workspace '" + getName() + "' not initialized"); } synchronized (this) { if (searchMgr == null && config.isSearchEnabled()) { // search manager is lazily instantiated in order to avoid // 'chicken & egg' bootstrap problems searchMgr = new SearchManager(getName(), context, config, itemStateMgr, persistMgr, context.getRootNodeId(), getSystemSearchManager(getName()), SYSTEM_ROOT_NODE_ID); } return searchMgr; } } /** * Returns the lock manager for this workspace. * * @return the lock manager for this workspace * @throws RepositoryException if the lock manager could not be created */ protected LockManagerImpl getLockManager() throws RepositoryException { if (!isInitialized()) { throw new IllegalStateException("workspace '" + getName() + "' not initialized"); } synchronized (this) { // lock manager is lazily instantiated in order to avoid // 'chicken & egg' bootstrap problems if (lockMgr == null) { lockMgr = createLockManager(); ClusterNode clusterNode = context.getClusterNode(); if (clusterNode != null && config.isClustered()) { lockChannel = clusterNode.createLockChannel(getName()); lockMgr.setEventChannel(lockChannel); } } return lockMgr; } } /** * Create a new lock manager. This method is only called once within * getLockManager(). * * @return the lock manager */ protected LockManagerImpl createLockManager() throws RepositoryException { return new LockManagerImpl(getSystemSession(), fs, context.getExecutor()); } /** * Return manager used for evaluating effect retention and holds. * * @return * @throws RepositoryException */ protected RetentionRegistry getRetentionRegistry() throws RepositoryException { if (!isInitialized()) { throw new IllegalStateException("workspace '" + getName() + "' not initialized"); } synchronized (this) { if (retentionReg == null) { retentionReg = new RetentionRegistryImpl(getSystemSession(), fs); } return retentionReg; } } /** * Returns the system session for this workspace. * * @return the system session for this workspace * @throws RepositoryException if the system session could not be created */ protected SystemSession getSystemSession() throws RepositoryException { if (!isInitialized()) { throw new IllegalStateException("workspace '" + getName() + "' not initialized"); } synchronized (this) { // system session is lazily instantiated in order to avoid // 'chicken & egg' bootstrap problems if (systemSession == null) { systemSession = SystemSession.create(context, config); } return systemSession; } } /** * Initializes this workspace info. The following components are * initialized immediately: * <ul> * <li>file system</li> * <li>persistence manager</li> * <li>shared item state manager</li> * <li>observation manager factory</li> * </ul> * The following components are initialized lazily (i.e. on demand) * in order to save resources and to avoid 'chicken & egg' bootstrap * problems: * <ul> * <li>system session</li> * <li>lock manager</li> * <li>search manager</li> * </ul> * @return <code>true</code> if this instance has been successfully * initialized, <code>false</code> if it is already initialized. * @throws RepositoryException if an error occurred during the initialization */ final boolean initialize() throws RepositoryException { // check initialize status try { initLock.readLock().acquire(); } catch (InterruptedException e) { throw new RepositoryException("Unable to aquire read lock.", e); } try { if (initialized) { // already initialized, we're done return false; } } finally { initLock.readLock().release(); } // workspace info was not initialized, now check again with write lock try { initLock.writeLock().acquire(); } catch (InterruptedException e) { throw new RepositoryException("Unable to aquire write lock.", e); } try { if (initialized) { // already initialized, some other thread was quicker, we're done return false; } log.info("initializing workspace '" + getName() + "'..."); doInitialize(); initialized = true; doPostInitialize(); log.info("workspace '" + getName() + "' initialized"); return true; } finally { initLock.writeLock().release(); } } /** * Does the actual initialization work. assumes holding write lock. * @throws RepositoryException if an error occurs. */ protected void doInitialize() throws RepositoryException { fs = config.getFileSystem(); persistMgr = createPersistenceManager(new File(config.getHomeDir()), fs, config.getPersistenceManagerConfig()); doVersionRecovery(); ISMLocking ismLocking = config.getISMLocking(); // create item state manager try { itemStateMgr = createItemStateManager(persistMgr, true, ismLocking); try { itemStateMgr.addVirtualItemStateProvider( context.getInternalVersionManager().getVirtualItemStateProvider()); itemStateMgr.addVirtualItemStateProvider(virtNTMgr.getVirtualItemStateProvider()); } catch (Exception e) { log.error("Unable to add vmgr: " + e.toString(), e); } ClusterNode clusterNode = context.getClusterNode(); if (clusterNode != null && config.isClustered()) { updateChannel = clusterNode.createUpdateChannel(getName()); itemStateMgr.setEventChannel(updateChannel); updateChannel.setListener(this); if (persistMgr instanceof ConsistencyChecker) { ((ConsistencyChecker) persistMgr).setEventChannel(updateChannel); } } } catch (ItemStateException ise) { String msg = "failed to instantiate shared item state manager"; log.debug(msg); throw new RepositoryException(msg, ise); } dispatcher = new ObservationDispatcher(); // register the observation factory of that workspace delegatingDispatcher.addDispatcher(dispatcher); } /** * If necessary, recover from a lost version history. */ protected void doVersionRecovery() throws RepositoryException { // JCR-2551: Recovery from a lost version history if (Boolean.getBoolean("org.apache.jackrabbit.version.recovery")) { RepositoryChecker checker = new RepositoryChecker(persistMgr, context.getInternalVersionManager()); checker.check(ROOT_NODE_ID, true, true); } } /** * Initializes the search manager of this workspace info. This method * is called while still holding the write lock on this workspace * info, but {@link #initialized} is already set to <code>true</code>. * * @throws RepositoryException if the search manager could not be created */ protected void doPostInitialize() throws RepositoryException { // get system Workspace instance WorkspaceImpl wsp = (WorkspaceImpl) getSystemSession().getWorkspace(); /** * todo implement 'System' workspace * FIXME * - there should be one 'System' workspace per repository * - the 'System' workspace should have the /jcr:system node * - versions, version history and node types should be reflected in * this system workspace as content under /jcr:system * - all other workspaces should be dynamic workspaces based on * this 'read-only' system workspace * * for now, the jcr:system node is created in * {@link org.apache.jackrabbit.core.state.SharedItemStateManager#createRootNodeState} */ log.debug("initializing SearchManager..."); long t0 = System.currentTimeMillis(); // register SearchManager as event listener SearchManager searchMgr = getSearchManager(); if (searchMgr != null) { wsp.getObservationManager() .addEventListener(searchMgr, Event.NODE_ADDED | Event.NODE_REMOVED | Event.PROPERTY_ADDED | Event.PROPERTY_REMOVED | Event.PROPERTY_CHANGED, "/", true, null, null, false); } log.debug("SearchManager initialized (" + (System.currentTimeMillis() - t0) + "ms)"); } /** * Disposes this <code>WorkspaceInfo</code> if it has been idle for more * than <code>maxIdleTime</code> milliseconds. * * @param maxIdleTime amount of time in mmilliseconds before an idle * workspace is automatically shutdown. */ final void disposeIfIdle(long maxIdleTime) { try { initLock.readLock().acquire(); } catch (InterruptedException e) { return; } try { if (!initialized || active) { return; } long currentTS = System.currentTimeMillis(); if (idleTimestamp == 0) { // set idle timestamp idleTimestamp = currentTS; } else { if ((currentTS - idleTimestamp) > maxIdleTime) { // temporarily shutdown workspace log.info("disposing workspace '" + getName() + "' which has been idle for " + (currentTS - idleTimestamp) + " ms"); dispose(); } } } finally { initLock.readLock().release(); } } /** * Disposes all objects this <code>WorkspaceInfo</code> is holding. */ final void dispose() { try { initLock.writeLock().acquire(); } catch (InterruptedException e) { throw new IllegalStateException("Unable to aquire write lock."); } try { if (!initialized) { // nothing to dispose of, we're already done return; } log.info("shutting down workspace '" + getName() + "'..."); doDispose(); // reset idle timestamp idleTimestamp = 0; active = false; initialized = false; log.info("workspace '" + getName() + "' has been shutdown"); } finally { initLock.writeLock().release(); } } /** * Does the actual disposal. assumes holding write lock. */ protected void doDispose() { // inform cluster node about disposal if (updateChannel != null) { updateChannel.setListener(null); } if (lockChannel != null) { lockChannel.setListener(null); } // deregister the observation factory of that workspace delegatingDispatcher.removeDispatcher(dispatcher); // dispose observation manager factory dispatcher.dispose(); dispatcher = null; // shutdown search managers if (searchMgr != null) { searchMgr.close(); searchMgr = null; } // deregister if (securityMgr != null) { securityMgr.dispose(getName()); } // close system session if (systemSession != null) { systemSession.removeListener(RepositoryImpl.this); systemSession.logout(); systemSession = null; } // dispose shared item state manager itemStateMgr.dispose(); itemStateMgr = null; // close persistence manager try { persistMgr.close(); } catch (Exception e) { log.error("error while closing persistence manager of workspace " + config.getName(), e); } persistMgr = null; // close lock manager if (lockMgr != null) { lockMgr.close(); lockMgr = null; } // close retention registry if (retentionReg != null) { retentionReg.close(); retentionReg = null; } // close workspace file system try { fs.close(); } catch (FileSystemException fse) { log.error("error while closing file system of workspace " + config.getName(), fse); } fs = null; } /** * Locks this workspace info. This is used (and only should be) by * the {@link XASessionImpl} in order to lock all internal resources * during a commit. * * @throws TransactionException */ void lockAcquire() throws TransactionException { try { xaLock.acquire(); } catch (InterruptedException e) { throw new TransactionException("Error while acquiering lock", e); } } /** * Unlocks this workspace info. This is used (and only should be) by * the {@link XASessionImpl} in order to lock all internal resources * during a commit. */ void lockRelease() { xaLock.release(); } //----------------------------------------------< UpdateEventListener > /** * {@inheritDoc} */ public void externalUpdate(ChangeLog external, List<EventState> events, long timestamp, String userData) throws RepositoryException { try { EventStateCollection esc = new EventStateCollection(getObservationDispatcher(), null, null); esc.setUserData(userData); esc.addAll(events); esc.setTimestamp(timestamp); getItemStateProvider().externalUpdate(external, esc); } catch (IllegalStateException e) { String msg = "Unable to deliver events: " + e.getMessage(); throw new RepositoryException(msg, e); } } } /** * The workspace janitor thread that will shutdown workspaces that have * been idle for a certain amount of time. */ private class WorkspaceJanitor implements Runnable { /** * amount of time in milliseconds before an idle workspace is * automatically shutdown. */ private long maxIdleTime; /** * interval in milliseconds between checks for idle workspaces. */ private long checkInterval; /** * Creates a new <code>WorkspaceJanitor</code> instance responsible for * shutting down idle workspaces. * * @param maxIdleTime amount of time in milliseconds before an idle * workspace is automatically shutdown. */ WorkspaceJanitor(long maxIdleTime) { this.maxIdleTime = maxIdleTime; // compute check interval as 10% of maxIdleTime checkInterval = (long) (0.1 * maxIdleTime); } /** * {@inheritDoc} * <p/> * Performs the following tasks in a <code>while (true)</code> loop: * <ol> * <li>wait for <code>checkInterval</code> milliseconds</li> * <li>build list of initialized but currently inactive workspaces * (excluding the default workspace)</li> * <li>shutdown those workspaces that have been idle for at least * <code>maxIdleTime</code> milliseconds</li> * </ol> */ public void run() { while (true) { synchronized (RepositoryImpl.this) { try { RepositoryImpl.this.wait(checkInterval); } catch (InterruptedException e) { // ignore } if (disposed) { return; } } // get names of workspaces Set<String> wspNames; synchronized (wspInfos) { wspNames = new HashSet<String>(wspInfos.keySet()); } // remove default workspace (will never be shutdown when idle) wspNames.remove(repConfig.getDefaultWorkspaceName()); synchronized (activeSessions) { // remove workspaces with active sessions for (Session ses : activeSessions.values()) { wspNames.remove(ses.getWorkspace().getName()); } } // remaining names denote workspaces which currently have not // active sessions for (String wspName : wspNames) { WorkspaceInfo wspInfo; synchronized (wspInfos) { wspInfo = wspInfos.get(wspName); } wspInfo.disposeIfIdle(maxIdleTime); } } } } /** * Cluster context passed to a <code>ClusterNode</code>. */ class ExternalEventListener implements ClusterContext { /** * {@inheritDoc} */ public ClusterConfig getClusterConfig() { return getConfig().getClusterConfig(); } /** * {@inheritDoc} */ public File getRepositoryHome() { return new File(getConfig().getHomeDir()); } /** * {@inheritDoc} */ public NamespaceResolver getNamespaceResolver() { return new RegistryNamespaceResolver(context.getNamespaceRegistry()); } /** * {@inheritDoc} */ public void updateEventsReady(String workspace) throws RepositoryException { // toggle the initialization of some workspace getWorkspaceInfo(workspace); } /** * {@inheritDoc} */ public void lockEventsReady(String workspace) throws RepositoryException { // toggle the initialization of some workspace's lock manager getWorkspaceInfo(workspace).getLockManager(); } } /** * Represents a Repository Descriptor Value (either Value or Value[]) */ protected static final class DescriptorValue { private Value val; private Value[] vals; protected DescriptorValue(Value val) { this.val = val; } protected DescriptorValue(Value[] vals) { this.vals = vals; } protected Value getValue() { return val; } protected Value[] getValues() { return vals != null ? vals : new Value[] { val }; } } }