| /* |
| * 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.lenya.cms.repository; |
| |
| import java.util.ArrayList; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.apache.avalon.framework.container.ContainerUtil; |
| import org.apache.avalon.framework.logger.AbstractLogEnabled; |
| import org.apache.avalon.framework.logger.Logger; |
| import org.apache.avalon.framework.service.ServiceException; |
| import org.apache.avalon.framework.service.ServiceManager; |
| import org.apache.lenya.ac.Identity; |
| import org.apache.lenya.cms.observation.ObservationRegistry; |
| import org.apache.lenya.cms.observation.RepositoryEvent; |
| import org.apache.lenya.cms.observation.RepositoryListener; |
| import org.apache.lenya.transaction.ConcurrentModificationException; |
| import org.apache.lenya.transaction.IdentityMap; |
| import org.apache.lenya.transaction.IdentityMapImpl; |
| import org.apache.lenya.transaction.Lock; |
| import org.apache.lenya.transaction.Lockable; |
| import org.apache.lenya.transaction.TransactionException; |
| import org.apache.lenya.transaction.TransactionLock; |
| import org.apache.lenya.transaction.Transactionable; |
| import org.apache.lenya.transaction.UnitOfWork; |
| import org.apache.lenya.transaction.UnitOfWorkImpl; |
| import org.apache.lenya.util.Assert; |
| |
| /** |
| * Repository session. |
| */ |
| public class SessionImpl extends AbstractLogEnabled implements Session { |
| |
| protected static final String UNMODIFIABLE_SESSION_ID = "unmodifiable"; |
| private ServiceManager manager; |
| private Identity identity; |
| |
| /** |
| * Ctor. |
| * @param identity The identity. |
| * @param modifiable Determines if the repository items in this session can be modified. |
| * @param manager The service manager. |
| * @param logger The logger. |
| */ |
| public SessionImpl(Identity identity, boolean modifiable, ServiceManager manager, Logger logger) { |
| |
| ContainerUtil.enableLogging(this, logger); |
| |
| Assert.notNull("service manager", manager); |
| this.manager = manager; |
| |
| this.identityMap = new IdentityMapImpl(logger); |
| this.identity = identity; |
| this.id = modifiable ? createUuid() : UNMODIFIABLE_SESSION_ID; |
| |
| ObservationRegistry registry = null; |
| try { |
| registry = (ObservationRegistry) this.manager.lookup(ObservationRegistry.ROLE); |
| addListener(registry); |
| } catch (Exception e) { |
| throw new RuntimeException(e); |
| } finally { |
| if (registry != null) { |
| this.manager.release(registry); |
| } |
| } |
| |
| if (modifiable) { |
| this.unitOfWork = new UnitOfWorkImpl(this.identityMap, this.identity, getLogger()); |
| } |
| } |
| |
| protected String createUuid() { |
| String id; |
| UUIDGenerator generator = null; |
| try { |
| |
| generator = (UUIDGenerator) this.manager.lookup(UUIDGenerator.ROLE); |
| id = generator.nextUUID(); |
| } catch (Exception e) { |
| throw new RuntimeException(e); |
| } finally { |
| if (generator == null) { |
| this.manager.release(generator); |
| } |
| } |
| return id; |
| } |
| |
| public Identity getIdentity() { |
| return this.identity; |
| } |
| |
| private UnitOfWork unitOfWork; |
| private SharedItemStore sharedItemStore; |
| |
| /** |
| * @return The unit of work. |
| */ |
| protected UnitOfWork getUnitOfWork() { |
| if (this.unitOfWork == null) { |
| throw new RuntimeException("This session [" + getId() + "] is not modifiable!"); |
| } |
| return this.unitOfWork; |
| } |
| |
| private boolean committing = false; |
| |
| /** |
| * Commits the transaction. |
| * @throws RepositoryException if an error occurs. |
| * @throws ConcurrentModificationException if a transactionable has been modified by another |
| * session. |
| */ |
| public synchronized void commit() throws RepositoryException, ConcurrentModificationException { |
| |
| savePersistables(); |
| |
| this.committing = true; |
| |
| try { |
| synchronized (TransactionLock.LOCK) { |
| |
| getUnitOfWork().commit(); |
| getSharedItemStore().clear(); |
| } |
| } catch (ConcurrentModificationException e) { |
| throw e; |
| } catch (TransactionException e) { |
| throw new RepositoryException(e); |
| } |
| |
| for (Iterator i = this.events.iterator(); i.hasNext();) { |
| RepositoryEvent event = (RepositoryEvent) i.next(); |
| for (Iterator l = this.listeners.iterator(); l.hasNext();) { |
| RepositoryListener listener = (RepositoryListener) l.next(); |
| listener.eventFired(event); |
| } |
| } |
| this.events.clear(); |
| this.committing = false; |
| } |
| |
| /** |
| * Save all persistable objects to their nodes. |
| * @throws RepositoryException if an error occurs. |
| */ |
| protected void savePersistables() throws RepositoryException { |
| Object[] objects = getIdentityMap().getObjects(); |
| for (int i = 0; i < objects.length; i++) { |
| if (objects[i] instanceof Node) { |
| Node node = (Node) objects[i]; |
| Persistable persistable = node.getPersistable(); |
| if (persistable != null && persistable.isModified()) { |
| persistable.save(); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Rolls the transaction back. |
| * @throws RepositoryException if an error occurs. |
| */ |
| public void rollback() throws RepositoryException { |
| try { |
| synchronized (TransactionLock.LOCK) { |
| getUnitOfWork().rollback(); |
| } |
| } catch (TransactionException e) { |
| throw new RepositoryException(e); |
| } |
| this.events.clear(); |
| } |
| |
| protected SharedItemStore getSharedItemStore() { |
| if (this.sharedItemStore == null) { |
| try { |
| this.sharedItemStore = (SharedItemStore) this.manager.lookup(SharedItemStore.ROLE); |
| } catch (ServiceException e) { |
| throw new RuntimeException(e); |
| } |
| } |
| return this.sharedItemStore; |
| } |
| |
| /** |
| * @see org.apache.lenya.cms.repository.Session#getRepositoryItem(org.apache.lenya.cms.repository.RepositoryItemFactory, |
| * java.lang.String) |
| */ |
| public RepositoryItem getRepositoryItem(RepositoryItemFactory factory, String key) |
| throws RepositoryException { |
| RepositoryItemFactoryWrapper wrapper = new RepositoryItemFactoryWrapper(factory, this); |
| return (RepositoryItem) getIdentityMap().get(wrapper, key); |
| } |
| |
| public void registerNew(Transactionable object) throws TransactionException { |
| getUnitOfWork().registerNew(object); |
| } |
| |
| public void registerDirty(Transactionable object) throws TransactionException { |
| getUnitOfWork().registerDirty(object); |
| } |
| |
| public void registerRemoved(Transactionable object) throws TransactionException { |
| getUnitOfWork().registerRemoved(object); |
| } |
| |
| /** |
| * @param identity The identity. |
| */ |
| public void setIdentity(Identity identity) { |
| this.identity = identity; |
| } |
| |
| public boolean isDirty(Transactionable transactionable) { |
| return getUnitOfWork().isDirty(transactionable); |
| } |
| |
| public Lock createLock(Lockable lockable, int version) throws TransactionException { |
| return getUnitOfWork().createLock(lockable, version); |
| } |
| |
| public void removeLock(Lockable lockable) throws TransactionException { |
| getUnitOfWork().removeLock(lockable); |
| } |
| |
| private Set listeners = new HashSet(); |
| |
| public void addListener(RepositoryListener listener) throws RepositoryException { |
| if (this.listeners.contains(listener)) { |
| throw new RepositoryException("The listener [" + listener |
| + "] is already registered for node [" + this + "]!"); |
| } |
| this.listeners.add(listener); |
| } |
| |
| public boolean isListenerRegistered(RepositoryListener listener) { |
| return this.listeners.contains(listener); |
| } |
| |
| private List events = new ArrayList(); |
| private IdentityMap identityMap; |
| |
| public synchronized void enqueueEvent(RepositoryEvent event) { |
| if (!isModifiable()) { |
| throw new RuntimeException("Can't enqueue event in unmodifiable session!"); |
| } |
| if (committing) { |
| throw new RuntimeException( |
| "No events can be queued while the session is being committed. Event: [" |
| + event.getDescriptor() + "]"); |
| } |
| Assert.isTrue("event belongs to session", event.getSession() == this); |
| this.events.add(event); |
| } |
| |
| protected IdentityMap getIdentityMap() { |
| return this.identityMap; |
| } |
| |
| public boolean isModifiable() { |
| return this.unitOfWork != null; |
| } |
| |
| private String id; |
| |
| public String getId() { |
| return this.id; |
| } |
| |
| } |