/*
* 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.jcr2spi;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Semaphore;
import javax.jcr.AccessDeniedException;
import javax.jcr.InvalidItemStateException;
import javax.jcr.ItemExistsException;
import javax.jcr.ItemNotFoundException;
import javax.jcr.MergeException;
import javax.jcr.NamespaceException;
import javax.jcr.NamespaceRegistry;
import javax.jcr.NoSuchWorkspaceException;
import javax.jcr.PathNotFoundException;
import javax.jcr.ReferentialIntegrityException;
import javax.jcr.RepositoryException;
import javax.jcr.UnsupportedRepositoryOperationException;
import javax.jcr.lock.LockException;
import javax.jcr.nodetype.ConstraintViolationException;
import javax.jcr.nodetype.NoSuchNodeTypeException;
import javax.jcr.query.InvalidQueryException;
import javax.jcr.version.VersionException;
import org.apache.jackrabbit.jcr2spi.config.CacheBehaviour;
import org.apache.jackrabbit.jcr2spi.hierarchy.HierarchyEventListener;
import org.apache.jackrabbit.jcr2spi.hierarchy.HierarchyManager;
import org.apache.jackrabbit.jcr2spi.hierarchy.HierarchyManagerImpl;
import org.apache.jackrabbit.jcr2spi.nodetype.EffectiveNodeTypeProvider;
import org.apache.jackrabbit.jcr2spi.nodetype.ItemDefinitionProvider;
import org.apache.jackrabbit.jcr2spi.nodetype.ItemDefinitionProviderImpl;
import org.apache.jackrabbit.jcr2spi.nodetype.NodeTypeCache;
import org.apache.jackrabbit.jcr2spi.nodetype.NodeTypeRegistry;
import org.apache.jackrabbit.jcr2spi.nodetype.NodeTypeRegistryImpl;
import org.apache.jackrabbit.jcr2spi.observation.InternalEventListener;
import org.apache.jackrabbit.jcr2spi.operation.AddLabel;
import org.apache.jackrabbit.jcr2spi.operation.AddNode;
import org.apache.jackrabbit.jcr2spi.operation.AddProperty;
import org.apache.jackrabbit.jcr2spi.operation.Checkin;
import org.apache.jackrabbit.jcr2spi.operation.Checkout;
import org.apache.jackrabbit.jcr2spi.operation.Checkpoint;
import org.apache.jackrabbit.jcr2spi.operation.Clone;
import org.apache.jackrabbit.jcr2spi.operation.Copy;
import org.apache.jackrabbit.jcr2spi.operation.CreateActivity;
import org.apache.jackrabbit.jcr2spi.operation.CreateConfiguration;
import org.apache.jackrabbit.jcr2spi.operation.LockOperation;
import org.apache.jackrabbit.jcr2spi.operation.LockRefresh;
import org.apache.jackrabbit.jcr2spi.operation.LockRelease;
import org.apache.jackrabbit.jcr2spi.operation.Merge;
import org.apache.jackrabbit.jcr2spi.operation.Move;
import org.apache.jackrabbit.jcr2spi.operation.Operation;
import org.apache.jackrabbit.jcr2spi.operation.OperationVisitor;
import org.apache.jackrabbit.jcr2spi.operation.Remove;
import org.apache.jackrabbit.jcr2spi.operation.RemoveActivity;
import org.apache.jackrabbit.jcr2spi.operation.RemoveLabel;
import org.apache.jackrabbit.jcr2spi.operation.RemoveVersion;
import org.apache.jackrabbit.jcr2spi.operation.ReorderNodes;
import org.apache.jackrabbit.jcr2spi.operation.ResolveMergeConflict;
import org.apache.jackrabbit.jcr2spi.operation.Restore;
import org.apache.jackrabbit.jcr2spi.operation.SetMixin;
import org.apache.jackrabbit.jcr2spi.operation.SetPrimaryType;
import org.apache.jackrabbit.jcr2spi.operation.SetPropertyValue;
import org.apache.jackrabbit.jcr2spi.operation.Update;
import org.apache.jackrabbit.jcr2spi.operation.WorkspaceImport;
import org.apache.jackrabbit.jcr2spi.security.AccessManager;
import org.apache.jackrabbit.jcr2spi.state.ChangeLog;
import org.apache.jackrabbit.jcr2spi.state.ItemState;
import org.apache.jackrabbit.jcr2spi.state.ItemStateFactory;
import org.apache.jackrabbit.jcr2spi.state.NodeState;
import org.apache.jackrabbit.jcr2spi.state.Status;
import org.apache.jackrabbit.jcr2spi.state.TransientISFactory;
import org.apache.jackrabbit.jcr2spi.state.TransientItemStateFactory;
import org.apache.jackrabbit.jcr2spi.state.UpdatableItemStateManager;
import org.apache.jackrabbit.jcr2spi.state.WorkspaceItemStateFactory;
import org.apache.jackrabbit.spi.Batch;
import org.apache.jackrabbit.spi.Event;
import org.apache.jackrabbit.spi.EventBundle;
import org.apache.jackrabbit.spi.EventFilter;
import org.apache.jackrabbit.spi.IdFactory;
import org.apache.jackrabbit.spi.ItemId;
import org.apache.jackrabbit.spi.ItemInfoCache;
import org.apache.jackrabbit.spi.LockInfo;
import org.apache.jackrabbit.spi.Name;
import org.apache.jackrabbit.spi.NameFactory;
import org.apache.jackrabbit.spi.NodeId;
import org.apache.jackrabbit.spi.Path;
import org.apache.jackrabbit.spi.PathFactory;
import org.apache.jackrabbit.spi.PropertyId;
import org.apache.jackrabbit.spi.QNodeTypeDefinition;
import org.apache.jackrabbit.spi.QValue;
import org.apache.jackrabbit.spi.QueryInfo;
import org.apache.jackrabbit.spi.RepositoryService;
import org.apache.jackrabbit.spi.SessionInfo;
import org.apache.jackrabbit.spi.Subscription;
import org.apache.jackrabbit.spi.commons.nodetype.NodeTypeStorage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* <code>WorkspaceManager</code>...
*/
public class WorkspaceManager
implements UpdatableItemStateManager, NamespaceStorage, AccessManager {
private static Logger log = LoggerFactory.getLogger(WorkspaceManager.class);
private final RepositoryService service;
private final SessionInfo sessionInfo;
private final NameFactory nameFactory;
private final PathFactory pathFactory;
private final ItemStateFactory isf;
private final HierarchyManager hierarchyManager;
private final CacheBehaviour cacheBehaviour;
private final IdFactory idFactory;
private final NamespaceRegistryImpl nsRegistry;
private final NodeTypeRegistryImpl ntRegistry;
private final ItemDefinitionProvider definitionProvider;
/**
* Semaphore to synchronize the feed thread with client
* threads that call {@link #execute(Operation)} or {@link
* #execute(ChangeLog)}.
*/
private final Semaphore updateSync = new Semaphore(1);
/**
* This is the event polling for changes. If <code>null</code>
* then the underlying repository service does not support observation.
*/
private final Thread changeFeed;
/**
* Flag that indicates that the changeFeed thread should be disposed.
*/
private volatile boolean disposeChangeFeed = false;
/**
* List of event listener that are set on this WorkspaceManager to get
* notifications about local and external changes.
*/
private final List<InternalEventListener> listeners = new LinkedList<InternalEventListener>();
/**
* The current subscription for change events if there are listeners.
*/
private Subscription subscription;
/**
* A cache for item infos as supplied by {@link RepositoryService#getItemInfoCache(SessionInfo)}
*/
private ItemInfoCache cache;
public WorkspaceManager(RepositoryService service, SessionInfo sessionInfo,
CacheBehaviour cacheBehaviour, int pollTimeout,
boolean enableObservation)
throws RepositoryException {
this.service = service;
this.sessionInfo = sessionInfo;
this.cacheBehaviour = cacheBehaviour;
this.nameFactory = service.getNameFactory();
this.pathFactory = service.getPathFactory();
idFactory = service.getIdFactory();
nsRegistry = new NamespaceRegistryImpl(this);
ntRegistry = createNodeTypeRegistry(nsRegistry);
changeFeed = createChangeFeed(pollTimeout, enableObservation);
definitionProvider = createDefinitionProvider(getEffectiveNodeTypeProvider());
TransientItemStateFactory stateFactory = createItemStateFactory();
this.isf = stateFactory;
this.hierarchyManager = createHierarchyManager(stateFactory, idFactory);
// If cache behavior is observation register a hierarchy listener which is
// notified about all changes. Otherwise just add a hierarchy listener which
// is only notified on changes for which client event listeners have been
// installed. Note: this listener has to be the first one called in order
// for the hierarchy to be consistent with the event (See JCR-2293).
InternalEventListener listener = createHierarchyListener(hierarchyManager);
if (cacheBehaviour == CacheBehaviour.OBSERVATION) {
addEventListener(listener);
} else {
listeners.add(listener);
}
}
public NamespaceRegistryImpl getNamespaceRegistryImpl() {
return nsRegistry;
}
public NodeTypeRegistry getNodeTypeRegistry() {
return ntRegistry;
}
public ItemDefinitionProvider getItemDefinitionProvider() {
return definitionProvider;
}
public EffectiveNodeTypeProvider getEffectiveNodeTypeProvider() {
return ntRegistry;
}
public HierarchyManager getHierarchyManager() {
return hierarchyManager;
}
public String[] getWorkspaceNames() throws RepositoryException {
return service.getWorkspaceNames(sessionInfo);
}
public IdFactory getIdFactory() {
return idFactory;
}
public NameFactory getNameFactory() {
return nameFactory;
}
public PathFactory getPathFactory() {
return pathFactory;
}
public ItemStateFactory getItemStateFactory() {
return isf;
}
public LockInfo getLockInfo(NodeId nodeId) throws RepositoryException {
return service.getLockInfo(sessionInfo, nodeId);
}
/**
* Returns the lock tokens present with the <code>SessionInfo</code>.
*
* @return lock tokens present with the <code>SessionInfo</code>.
* @throws UnsupportedRepositoryOperationException
* @throws RepositoryException
* @see org.apache.jackrabbit.spi.SessionInfo#getLockTokens()
*/
public String[] getLockTokens() throws UnsupportedRepositoryOperationException, RepositoryException {
return sessionInfo.getLockTokens();
}
/**
* This method succeeds if the lock tokens could be added to the
* <code>SessionInfo</code>.
*
* @param lt
* @throws UnsupportedRepositoryOperationException
* @throws LockException
* @throws RepositoryException
* @see SessionInfo#addLockToken(String)
*/
public void addLockToken(String lt) throws UnsupportedRepositoryOperationException, LockException, RepositoryException {
sessionInfo.addLockToken(lt);
}
/**
* Tries to remove the given token from the <code>SessionInfo</code>.
*
* @param lt
* @throws UnsupportedRepositoryOperationException
* @throws LockException
* @throws RepositoryException
* @see SessionInfo#removeLockToken(String)
*/
public void removeLockToken(String lt) throws UnsupportedRepositoryOperationException, LockException, RepositoryException {
for (String token : sessionInfo.getLockTokens()) {
if (token.equals(lt)) {
sessionInfo.removeLockToken(lt);
return;
}
}
// sessionInfo doesn't contain the given lock token and is therefore
// not the lock holder
throw new LockException("Unable to remove locktoken '" + lt + "' from Session.");
}
/**
*
* @return
* @throws RepositoryException
*/
public String[] getSupportedQueryLanguages() throws RepositoryException {
return service.getSupportedQueryLanguages(sessionInfo);
}
/**
* Checks if the query statement is valid.
*
* @param statement the query statement.
* @param language the query language.
* @param namespaces the locally remapped namespaces which might be used in
* the query statement.
* @return the bind variable names.
* @throws InvalidQueryException if the query statement is invalid.
* @throws RepositoryException if an error occurs while checking the query
* statement.
*/
public String[] checkQueryStatement(String statement,
String language,
Map<String, String> namespaces)
throws InvalidQueryException, RepositoryException {
return service.checkQueryStatement(sessionInfo, statement, language, namespaces);
}
/**
* @param statement the query statement.
* @param language the query language.
* @param namespaces the locally remapped namespaces which might be used in
* the query statement.
* @param limit
* @param offset
* @param boundValues
* @return
* @throws RepositoryException
*/
public QueryInfo executeQuery(String statement, String language, Map<String, String> namespaces,
long limit, long offset, Map<String, QValue> boundValues) throws RepositoryException {
return service.executeQuery(sessionInfo, statement, language, namespaces, limit, offset, boundValues);
}
/**
* Sets the <code>InternalEventListener</code> that gets notifications about
* local and external changes.
*
* @param listener the new listener.
* @throws RepositoryException if the listener cannot be registered.
*/
public void addEventListener(InternalEventListener listener)
throws RepositoryException {
synchronized (listeners) {
listeners.add(listener);
EventFilter[] filters = getEventFilters(listeners);
if (subscription == null) {
subscription = service.createSubscription(sessionInfo, filters);
} else {
service.updateEventFilters(subscription, filters);
}
listeners.notifyAll();
}
}
/**
* Updates the event filters on the subscription. The filters are retrieved
* from the current list of internal event listeners.
*
* @throws RepositoryException
*/
public void updateEventFilters() throws RepositoryException {
synchronized (listeners) {
service.updateEventFilters(subscription, getEventFilters(listeners));
}
}
/**
*
* @param listener
*/
public void removeEventListener(InternalEventListener listener)
throws RepositoryException {
synchronized (listeners) {
listeners.remove(listener);
if (listeners.isEmpty()) {
service.dispose(subscription);
subscription = null;
} else {
service.updateEventFilters(subscription, getEventFilters(listeners));
}
}
}
/**
* Creates an event filter based on the parameters available in {@link
* javax.jcr.observation.ObservationManager#addEventListener}.
*
* @param eventTypes A combination of one or more event type constants
* encoded as a bitmask.
* @param path an absolute path.
* @param isDeep a <code>boolean</code>.
* @param uuids array of UUIDs.
* @param nodeTypes array of node type names.
* @param noLocal a <code>boolean</code>.
* @return the event filter instance with the given parameters.
* @throws UnsupportedRepositoryOperationException
* if this implementation does not support observation.
*/
public EventFilter createEventFilter(int eventTypes, Path path, boolean isDeep,
String[] uuids, Name[] nodeTypes,
boolean noLocal)
throws UnsupportedRepositoryOperationException, RepositoryException {
return service.createEventFilter(sessionInfo, eventTypes, path, isDeep, uuids, nodeTypes, noLocal);
}
/**
* Returns the events from the journal that occurred after a given date.
*
* @param filter the event filter to apply.
* @param after a date in milliseconds.
* @return the events as a bundle.
* @throws RepositoryException if an error occurs.
* @throws UnsupportedRepositoryOperationException
* if the implementation does not support
* journaled observation.
*/
public EventBundle getEvents(EventFilter filter, long after)
throws RepositoryException, UnsupportedRepositoryOperationException {
return service.getEvents(sessionInfo, filter, after);
}
/**
*
* @param userData
* @throws RepositoryException
*/
public void setUserData(String userData) throws RepositoryException {
sessionInfo.setUserData(userData);
}
//--------------------------------------------------------------------------
/**
* Gets the event filters from the passed listener list.
*
* @param listeners the internal event listeners.
*/
private static EventFilter[] getEventFilters(Collection<InternalEventListener> listeners) {
List<EventFilter> filters = new ArrayList<EventFilter>();
for (InternalEventListener listener : listeners) {
filters.addAll(listener.getEventFilters());
}
return filters.toArray(new EventFilter[filters.size()]);
}
/**
* @return a new instance of <code>TransientItemStateFactory</code>.
*/
private TransientItemStateFactory createItemStateFactory() throws RepositoryException {
cache = service.getItemInfoCache(sessionInfo);
WorkspaceItemStateFactory isf = new WorkspaceItemStateFactory(service, sessionInfo,
getItemDefinitionProvider(), cache);
TransientItemStateFactory tisf = new TransientISFactory(isf, getItemDefinitionProvider());
return tisf;
}
/**
* @return a new instance of <code>HierarchyManager</code>.
*/
private HierarchyManager createHierarchyManager(TransientItemStateFactory tisf, IdFactory idFactory) throws RepositoryException {
return new HierarchyManagerImpl(tisf, idFactory, getPathFactory());
}
/**
* @return a new InternalEventListener
*/
private InternalEventListener createHierarchyListener(HierarchyManager hierarchyMgr) {
InternalEventListener listener = new HierarchyEventListener(this, hierarchyMgr, cacheBehaviour);
return listener;
}
/**
* @param nsRegistry
* @return an instance of <code>NodeTypeRegistryImpl</code>.
*/
private NodeTypeRegistryImpl createNodeTypeRegistry(NamespaceRegistry nsRegistry) {
NodeTypeStorage ntst = new NodeTypeStorage() {
public Iterator<QNodeTypeDefinition> getAllDefinitions() throws RepositoryException {
return service.getQNodeTypeDefinitions(sessionInfo);
}
public Iterator<QNodeTypeDefinition> getDefinitions(Name[] nodeTypeNames) throws NoSuchNodeTypeException, RepositoryException {
return service.getQNodeTypeDefinitions(sessionInfo, nodeTypeNames);
}
public void registerNodeTypes(QNodeTypeDefinition[] nodeTypeDefs, boolean allowUpdate) throws RepositoryException {
service.registerNodeTypes(sessionInfo, nodeTypeDefs, allowUpdate);
}
public void unregisterNodeTypes(Name[] nodeTypeNames) throws NoSuchNodeTypeException, RepositoryException {
service.unregisterNodeTypes(sessionInfo, nodeTypeNames);
}
};
NodeTypeCache ntCache = NodeTypeCache.getInstance(service, sessionInfo.getUserID());
ntst = ntCache.wrap(ntst);
return NodeTypeRegistryImpl.create(ntst, nsRegistry);
}
/**
* @param entProvider
* @return a new instance of <code>ItemDefinitionProvider</code>.
*/
private ItemDefinitionProvider createDefinitionProvider(EffectiveNodeTypeProvider entProvider) {
return new ItemDefinitionProviderImpl(entProvider, service, sessionInfo);
}
/**
* Creates a background thread which polls for external changes on the
* RepositoryService.
*
* @param pollTimeout the polling timeout in milliseconds.
* @param enableObservation if observation should be enabled.
* @return the background polling thread or <code>null</code> if the underlying
* <code>RepositoryService</code> does not support observation.
*/
private Thread createChangeFeed(int pollTimeout, boolean enableObservation) {
Thread t = null;
if (enableObservation) {
t = new Thread(new ChangePolling(pollTimeout));
t.setName("Change Polling");
t.setDaemon(true);
t.start();
}
return t;
}
//-----------------------------------------------------< wsp management >---
/**
* Create a new workspace with the specified <code>name</code>. If
* <code>srcWorkspaceName</code> isn't <code>null</code> the content of
* that workspace is used as inital content, otherwise an empty workspace
* will be created.
*
* @param name The name of the workspace to be created.
* @param srcWorkspaceName The name of the workspace from which the initial
* content of the new workspace will be 'cloned'.
* @throws RepositoryException If an exception occurs.
*/
void createWorkspace(String name, String srcWorkspaceName) throws RepositoryException {
service.createWorkspace(sessionInfo, name, srcWorkspaceName);
}
/**
* Deletes the workspace with the specified <code>name</code>.
*
* @param name
* @throws RepositoryException
*/
void deleteWorkspace(String name) throws RepositoryException {
service.deleteWorkspace(sessionInfo, name);
}
//------------------------------------------< UpdatableItemStateManager >---
/**
* Creates a new batch from the single workspace operation and executes it.
*
* @see UpdatableItemStateManager#execute(Operation)
*/
public void execute(Operation operation) throws RepositoryException {
// block event delivery while changes are executed
try {
updateSync.acquire();
} catch (InterruptedException e) {
throw new RepositoryException(e);
}
try {
/*
Execute operation and delegate invalidation of affected item
states to the operation.
NOTE, that the invalidation is independent of the cache behaviour
due to the fact, that local event bundles are not processed by
the HierarchyEventListener.
*/
new OperationVisitorImpl(sessionInfo).execute(operation);
operation.persisted();
} finally {
updateSync.release();
}
}
/**
* Creates a new batch from the given <code>ChangeLog</code> and executes it.
*
* @param changes
* @throws RepositoryException
*/
public void execute(ChangeLog changes) throws RepositoryException {
// block event delivery while changes are executed
try {
updateSync.acquire();
} catch (InterruptedException e) {
throw new RepositoryException(e);
}
try {
new OperationVisitorImpl(sessionInfo).execute(changes);
changes.persisted();
} finally {
updateSync.release();
}
}
/**
* Dispose this <code>WorkspaceManager</code>
*/
public synchronized void dispose() {
try {
updateSync.acquire();
} catch (InterruptedException e) {
log.warn("Exception while disposing WorkspaceManager: " + e);
return;
}
try {
if (changeFeed != null) {
disposeChangeFeed = true;
changeFeed.interrupt();
changeFeed.join();
}
hierarchyManager.dispose();
if (subscription != null) {
service.dispose(subscription);
}
service.dispose(sessionInfo);
cache.dispose();
} catch (Exception e) {
log.warn("Exception while disposing WorkspaceManager: " + e);
} finally {
updateSync.release();
}
ntRegistry.dispose();
}
//------------------------------------------------------< AccessManager >---
/**
* @see AccessManager#isGranted(NodeState, Path, String[])
*/
public boolean isGranted(NodeState parentState, Path relPath, String[] actions)
throws ItemNotFoundException, RepositoryException {
if (parentState.getStatus() == Status.NEW) {
return true;
}
// TODO: check again.
// build itemId from the given state and the relative path without
// making an attempt to retrieve the proper id of the item possibly
// identified by the resulting id.
// the server must be able to deal with paths and with proper ids anyway.
// TODO: 'createNodeId' is basically wrong since isGranted is unspecific for any item.
ItemId id = idFactory.createNodeId((NodeId) parentState.getWorkspaceId(), relPath);
return service.isGranted(sessionInfo, id, actions);
}
/**
* @see AccessManager#isGranted(ItemState, String[])
*/
public boolean isGranted(ItemState itemState, String[] actions) throws ItemNotFoundException, RepositoryException {
// a 'new' state can always be read, written and removed
if (itemState.getStatus() == Status.NEW) {
return true;
}
return service.isGranted(sessionInfo, itemState.getWorkspaceId(), actions);
}
/**
* @see AccessManager#canRead(ItemState)
*/
public boolean canRead(ItemState itemState) throws ItemNotFoundException, RepositoryException {
// a 'new' state can always be read
if (itemState.getStatus() == Status.NEW) {
return true;
}
return service.isGranted(sessionInfo, itemState.getWorkspaceId(), AccessManager.READ);
}
/**
* @see AccessManager#canRemove(ItemState)
*/
public boolean canRemove(ItemState itemState) throws ItemNotFoundException, RepositoryException {
// a 'new' state can always be removed again
if (itemState.getStatus() == Status.NEW) {
return true;
}
return service.isGranted(sessionInfo, itemState.getWorkspaceId(), AccessManager.REMOVE);
}
/**
* @see AccessManager#canAccess(String)
*/
public boolean canAccess(String workspaceName) throws NoSuchWorkspaceException, RepositoryException {
for (String wspName : getWorkspaceNames()) {
if (wspName.equals(workspaceName)) {
return true;
}
}
return false;
}
//---------------------------------------------------< NamespaceStorage >---
public Map<String, String> getRegisteredNamespaces() throws RepositoryException {
return service.getRegisteredNamespaces(sessionInfo);
}
public String getPrefix(String uri) throws NamespaceException, RepositoryException {
return service.getNamespacePrefix(sessionInfo, uri);
}
public String getURI(String prefix) throws NamespaceException, RepositoryException {
return service.getNamespaceURI(sessionInfo, prefix);
}
public void registerNamespace(String prefix, String uri) throws NamespaceException, UnsupportedRepositoryOperationException, AccessDeniedException, RepositoryException {
service.registerNamespace(sessionInfo, prefix, uri);
}
public void unregisterNamespace(String uri) throws NamespaceException, UnsupportedRepositoryOperationException, AccessDeniedException, RepositoryException {
service.unregisterNamespace(sessionInfo, uri);
}
//--------------------------------------------------------------------------
/**
* Called when local or external events occured. This method is called after
* changes have been applied to the repository.
*
* @param eventBundles the event bundles generated by the repository service
* as the effect of an local or external change.
* @throws InterruptedException if this thread is interrupted while waiting
* for the {@link #updateSync}.
*/
private void onEventReceived(EventBundle[] eventBundles,
InternalEventListener[] lstnrs)
throws InterruptedException {
if (log.isDebugEnabled()) {
log.debug("received {} event bundles.", eventBundles.length);
for (EventBundle eventBundle : eventBundles) {
log.debug("IsLocal: {}", eventBundle.isLocal());
for (Iterator<Event> it = eventBundle.getEvents(); it.hasNext();) {
Event e = it.next();
String type;
switch (e.getType()) {
case Event.NODE_ADDED:
type = "NodeAdded";
break;
case Event.NODE_REMOVED:
type = "NodeRemoved";
break;
case Event.PROPERTY_ADDED:
type = "PropertyAdded";
break;
case Event.PROPERTY_CHANGED:
type = "PropertyChanged";
break;
case Event.PROPERTY_REMOVED:
type = "PropertyRemoved";
break;
case Event.NODE_MOVED:
type = "NodeMoved";
break;
case Event.PERSIST:
type = "Persist";
break;
default:
type = "Unknown";
}
log.debug(" {}; {}", e.getPath(), type);
}
}
}
// do not deliver events while an operation executes
updateSync.acquire();
try {
// notify listener
for (EventBundle eventBundle : eventBundles) {
for (InternalEventListener lstnr : lstnrs) {
lstnr.onEvent(eventBundle);
}
}
} finally {
updateSync.release();
}
}
/**
* Executes a sequence of operations on the repository service within
* a given <code>SessionInfo</code>.
*/
private final class OperationVisitorImpl implements OperationVisitor {
/**
* The session info for all operations in this batch.
*/
private final SessionInfo sessionInfo;
private Batch batch;
private OperationVisitorImpl(SessionInfo sessionInfo) {
this.sessionInfo = sessionInfo;
}
/**
* Executes the operations on the repository service.
*/
private void execute(ChangeLog changeLog) throws RepositoryException, ConstraintViolationException, AccessDeniedException, ItemExistsException, NoSuchNodeTypeException, UnsupportedRepositoryOperationException, VersionException {
RepositoryException ex = null;
try {
ItemState target = changeLog.getTarget();
batch = service.createBatch(sessionInfo, target.getId());
for (Operation op : changeLog.getOperations()) {
log.debug("executing " + op.getName());
op.accept(this);
}
} catch (RepositoryException e) {
ex = e;
} finally {
if (batch != null) {
try {
// submit must be called even in case there is an
// exception to give the service a chance to clean
// up the batch
service.submit(batch);
} catch (RepositoryException e) {
if (ex == null) {
ex = e;
} else {
log.warn("Exception submitting batch", e);
}
}
// reset batch field
batch = null;
}
}
if (ex != null) {
throw ex;
}
}
/**
* Executes the operations on the repository service.
*/
private void execute(Operation workspaceOperation) throws RepositoryException, ConstraintViolationException, AccessDeniedException, ItemExistsException, NoSuchNodeTypeException, UnsupportedRepositoryOperationException, VersionException {
log.debug("executing " + workspaceOperation.getName());
workspaceOperation.accept(this);
}
//-----------------------------------------------< OperationVisitor >---
/**
* @see OperationVisitor#visit(AddNode)
*/
public void visit(AddNode operation) throws RepositoryException {
NodeId parentId = operation.getParentId();
batch.addNode(parentId, operation.getNodeName(), operation.getNodeTypeName(), operation.getUuid());
}
/**
* @see OperationVisitor#visit(AddProperty)
*/
public void visit(AddProperty operation) throws RepositoryException {
NodeId parentId = operation.getParentId();
Name propertyName = operation.getPropertyName();
if (operation.isMultiValued()) {
batch.addProperty(parentId, propertyName, operation.getValues());
} else {
QValue value = operation.getValues()[0];
batch.addProperty(parentId, propertyName, value);
}
}
/**
* @see OperationVisitor#visit(Clone)
*/
public void visit(Clone operation) throws NoSuchWorkspaceException, LockException, ConstraintViolationException, AccessDeniedException, ItemExistsException, UnsupportedRepositoryOperationException, VersionException, RepositoryException {
NodeId nId = operation.getNodeId();
NodeId destParentId = operation.getDestinationParentId();
service.clone(sessionInfo, operation.getWorkspaceName(), nId, destParentId, operation.getDestinationName(), operation.isRemoveExisting());
}
/**
* @see OperationVisitor#visit(Copy)
*/
public void visit(Copy operation) throws NoSuchWorkspaceException, LockException, ConstraintViolationException, AccessDeniedException, ItemExistsException, UnsupportedRepositoryOperationException, VersionException, RepositoryException {
NodeId nId = operation.getNodeId();
NodeId destParentId = operation.getDestinationParentId();
service.copy(sessionInfo, operation.getWorkspaceName(), nId, destParentId, operation.getDestinationName());
}
/**
* @see OperationVisitor#visit(Move)
*/
public void visit(Move operation) throws LockException, ConstraintViolationException, AccessDeniedException, ItemExistsException, UnsupportedRepositoryOperationException, VersionException, RepositoryException {
NodeId moveId = operation.getSourceId();
NodeId destParentId = operation.getDestinationParentId();
if (batch == null) {
service.move(sessionInfo, moveId, destParentId, operation.getDestinationName());
} else {
batch.move(moveId, destParentId, operation.getDestinationName());
}
}
/**
* @see OperationVisitor#visit(Update)
*/
public void visit(Update operation) throws NoSuchWorkspaceException, AccessDeniedException, LockException, InvalidItemStateException, RepositoryException {
NodeId nId = operation.getNodeId();
service.update(sessionInfo, nId, operation.getSourceWorkspaceName());
}
/**
* @see OperationVisitor#visit(Remove)
*/
public void visit(Remove operation) throws RepositoryException {
batch.remove(operation.getRemoveId());
}
/**
* @see OperationVisitor#visit(SetMixin)
*/
public void visit(SetMixin operation) throws RepositoryException {
batch.setMixins(operation.getNodeId(), operation.getMixinNames());
}
/**
* @see OperationVisitor#visit(SetPrimaryType)
*/
public void visit(SetPrimaryType operation) throws RepositoryException {
batch.setPrimaryType(operation.getNodeId(), operation.getPrimaryTypeName());
}
/**
* @see OperationVisitor#visit(SetPropertyValue)
*/
public void visit(SetPropertyValue operation) throws RepositoryException {
PropertyId id = operation.getPropertyId();
if (operation.isMultiValued()) {
batch.setValue(id, operation.getValues());
} else {
batch.setValue(id, operation.getValues()[0]);
}
}
/**
* @see OperationVisitor#visit(ReorderNodes)
*/
public void visit(ReorderNodes operation) throws RepositoryException {
NodeId parentId = operation.getParentId();
NodeId insertId = operation.getInsertId();
NodeId beforeId = operation.getBeforeId();
batch.reorderNodes(parentId, insertId, beforeId);
}
/**
* @see OperationVisitor#visit(Checkout)
*/
public void visit(Checkout operation) throws UnsupportedRepositoryOperationException, LockException, RepositoryException {
if (operation.supportsActivity()) {
service.checkout(sessionInfo, operation.getNodeId(), operation.getActivityId());
} else {
service.checkout(sessionInfo, operation.getNodeId());
}
}
/**
* @see OperationVisitor#visit(Checkin)
*/
public void visit(Checkin operation) throws UnsupportedRepositoryOperationException, LockException, InvalidItemStateException, RepositoryException {
NodeId newId = service.checkin(sessionInfo, operation.getNodeId());
operation.setNewVersionId(newId);
}
/**
* @see OperationVisitor#visit(Checkpoint)
*/
public void visit(Checkpoint operation) throws UnsupportedRepositoryOperationException, LockException, InvalidItemStateException, RepositoryException {
NodeId newId;
if (operation.supportsActivity()) {
newId = service.checkpoint(sessionInfo, operation.getNodeId(), operation.getActivityId());
} else {
newId = service.checkpoint(sessionInfo, operation.getNodeId());
}
operation.setNewVersionId(newId);
}
/**
* @see OperationVisitor#visit(Restore)
*/
public void visit(Restore operation) throws VersionException, PathNotFoundException, ItemExistsException, UnsupportedRepositoryOperationException, LockException, InvalidItemStateException, RepositoryException {
NodeId nId = operation.getNodeId();
if (nId == null) {
service.restore(sessionInfo, operation.getVersionIds(), operation.removeExisting());
} else {
NodeId targetId;
Path relPath = operation.getRelativePath();
if (relPath != null) {
targetId = idFactory.createNodeId(nId, relPath);
} else {
targetId = nId;
}
NodeId versionId = operation.getVersionIds()[0];
service.restore(sessionInfo, targetId, versionId, operation.removeExisting());
}
}
/**
* @see OperationVisitor#visit(Merge)
*/
public void visit(Merge operation) throws NoSuchWorkspaceException, AccessDeniedException, MergeException, LockException, InvalidItemStateException, RepositoryException {
NodeId nId = operation.getNodeId();
Iterator<NodeId> failed;
if (operation.isActivityMerge()) {
failed = service.mergeActivity(sessionInfo, nId);
} else {
failed = service.merge(sessionInfo, nId, operation.getSourceWorkspaceName(), operation.bestEffort(), operation.isShallow());
}
operation.setFailedIds(failed);
}
/**
* @see OperationVisitor#visit(ResolveMergeConflict)
*/
public void visit(ResolveMergeConflict operation) throws VersionException, InvalidItemStateException, UnsupportedRepositoryOperationException, RepositoryException {
NodeId nId = operation.getNodeId();
NodeId[] mergedFailedIds = operation.getMergeFailedIds();
NodeId[] predecessorIds = operation.getPredecessorIds();
service.resolveMergeConflict(sessionInfo, nId, mergedFailedIds, predecessorIds);
}
/**
* @see OperationVisitor#visit(LockOperation)
*/
public void visit(LockOperation operation) throws AccessDeniedException, InvalidItemStateException, UnsupportedRepositoryOperationException, LockException, RepositoryException {
LockInfo lInfo = service.lock(sessionInfo, operation.getNodeId(), operation.isDeep(), operation.isSessionScoped(), operation.getTimeoutHint(), operation.getOwnerHint());
operation.setLockInfo(lInfo);
}
/**
* @see OperationVisitor#visit(LockRefresh)
*/
public void visit(LockRefresh operation) throws AccessDeniedException, InvalidItemStateException, UnsupportedRepositoryOperationException, LockException, RepositoryException {
service.refreshLock(sessionInfo, operation.getNodeId());
}
/**
* @see OperationVisitor#visit(LockRelease)
*/
public void visit(LockRelease operation) throws AccessDeniedException, InvalidItemStateException, UnsupportedRepositoryOperationException, LockException, RepositoryException {
service.unlock(sessionInfo, operation.getNodeId());
}
/**
* @see OperationVisitor#visit(AddLabel)
*/
public void visit(AddLabel operation) throws VersionException, RepositoryException {
NodeId vhId = operation.getVersionHistoryId();
NodeId vId = operation.getVersionId();
service.addVersionLabel(sessionInfo, vhId, vId, operation.getLabel(), operation.moveLabel());
}
/**
* @see OperationVisitor#visit(RemoveLabel)
*/
public void visit(RemoveLabel operation) throws VersionException, RepositoryException {
NodeId vhId = operation.getVersionHistoryId();
NodeId vId = operation.getVersionId();
service.removeVersionLabel(sessionInfo, vhId, vId, operation.getLabel());
}
/**
* @see OperationVisitor#visit(RemoveVersion)
*/
public void visit(RemoveVersion operation) throws VersionException, AccessDeniedException, ReferentialIntegrityException, RepositoryException {
NodeId versionId = (NodeId) operation.getRemoveId();
NodeState vhState = operation.getParentState();
service.removeVersion(sessionInfo, (NodeId) vhState.getWorkspaceId(), versionId);
}
/**
* @see OperationVisitor#visit(WorkspaceImport)
*/
public void visit(WorkspaceImport operation) throws RepositoryException {
service.importXml(sessionInfo, operation.getNodeId(), operation.getXmlStream(), operation.getUuidBehaviour());
}
/**
* @see OperationVisitor#visit(CreateActivity)
*/
public void visit(CreateActivity operation) throws RepositoryException {
NodeId activityId = service.createActivity(sessionInfo, operation.getTitle());
operation.setNewActivityId(activityId);
}
/**
* @see OperationVisitor#visit(RemoveActivity)
*/
public void visit(RemoveActivity operation) throws RepositoryException {
service.removeActivity(sessionInfo, (NodeId) operation.getRemoveId());
}
/**
* @see OperationVisitor#visit(CreateConfiguration)
*/
public void visit(CreateConfiguration operation) throws RepositoryException {
NodeId configId = service.createConfiguration(sessionInfo, operation.getNodeId());
operation.setNewConfigurationId(configId);
}
}
//------------------------------------------------------< ChangePolling >---
/**
* Implements the polling for changes on the repository service.
*/
private final class ChangePolling implements Runnable {
/**
* The polling timeout in milliseconds.
*/
private final int pollTimeout;
/**
* Creates a new change polling with a given polling timeout.
*
* @param pollTimeout the timeout in milliseconds.
*/
private ChangePolling(int pollTimeout) {
this.pollTimeout = pollTimeout;
}
public void run() {
while (!Thread.interrupted() && !disposeChangeFeed) {
try {
InternalEventListener[] iel;
Subscription subscr;
synchronized (listeners) {
while (subscription == null) {
listeners.wait();
}
iel = listeners.toArray(new InternalEventListener[0]);
subscr = subscription;
}
log.debug("calling getEvents() (Workspace={})",
sessionInfo.getWorkspaceName());
EventBundle[] bundles = service.getEvents(subscr, pollTimeout);
log.debug("returned from getEvents() (Workspace={})",
sessionInfo.getWorkspaceName());
// check if thread had been interrupted while
// getting events
if (Thread.interrupted() || disposeChangeFeed) {
log.debug("Thread interrupted, terminating...");
break;
}
if (bundles.length > 0) {
onEventReceived(bundles, iel);
}
} catch (UnsupportedRepositoryOperationException e) {
log.error("SPI implementation does not support observation: " + e);
// terminate
break;
} catch (RepositoryException e) {
log.info("Workspace=" + sessionInfo.getWorkspaceName() +
": Exception while retrieving event bundles: " + e);
log.debug("Dump:", e);
} catch (InterruptedException e) {
// terminate
break;
} catch (Exception e) {
log.warn("Exception in event polling thread: " + e);
log.debug("Dump:", e);
}
}
}
}
}