org.eclipse.skalli.core/src/main/java/org/eclipse/skalli/core/persistence/XStreamPersistenceComponent.java - skalli/org.eclipse.skalli - Git at Google

 /*******************************************************************************
  * Copyright (c) 2010-2014 SAP AG and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     SAP AG - initial API and implementation
  *******************************************************************************/
 package org.eclipse.skalli.core.persistence;

 import java.io.IOException;
 import java.text.MessageFormat;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import java.util.UUID;

 import org.apache.commons.lang.StringUtils;
 import org.eclipse.skalli.commons.ComparatorUtils;
 import org.eclipse.skalli.core.storage.FileStorageComponent;
 import org.eclipse.skalli.model.EntityBase;
 import org.eclipse.skalli.model.EntityFilter;
 import org.eclipse.skalli.services.BundleProperties;
 import org.eclipse.skalli.services.entity.EntityService;
 import org.eclipse.skalli.services.entity.EntityServices;
 import org.eclipse.skalli.services.extension.MigrationException;
 import org.eclipse.skalli.services.persistence.PersistenceService;
 import org.eclipse.skalli.services.persistence.StorageService;
 import org.osgi.service.component.ComponentConstants;
 import org.osgi.service.component.ComponentContext;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 /**
  * Implementation of {@link PersistenceService} based on XStream.
  */
 public class XStreamPersistenceComponent extends PersistenceServiceBase implements PersistenceService {

     private static final Logger LOG = LoggerFactory.getLogger(XStreamPersistenceComponent.class);
     private static final Logger AUDIT_LOG = LoggerFactory.getLogger("audit"); //$NON-NLS-1$

     private final EntityCache cache = new EntityCache();
     private final EntityCache deleted = new EntityCache();

     private XStreamPersistence xstreamPersistence;
     private String storageServiceClassName;

     protected void activate(ComponentContext context) {
         LOG.info(MessageFormat.format("[PersistenceService][xstream] {0} : activated",
                 (String) context.getProperties().get(ComponentConstants.COMPONENT_NAME)));
     }

     protected void deactivate(ComponentContext context) {
         xstreamPersistence = null;
         cache.clearAll();
         deleted.clearAll();
         LOG.info(MessageFormat.format("[PersistenceService][xstream] {0} : deactivated",
                 (String) context.getProperties().get(ComponentConstants.COMPONENT_NAME)));
     }

     protected void bindStorageService(StorageService storageService) {
         if (storageServiceClassName.equals(storageService.getClass().getName())) {
             xstreamPersistence = new XStreamPersistence(storageService);
             cache.clearAll();
             deleted.clearAll();
             LOG.info(MessageFormat.format("bindStorageService({0})", storageService)); //$NON-NLS-1$
         }
     }

     protected void unbindStorageService(StorageService storageService) {
         if (storageServiceClassName.equals(storageService.getClass().getName())) {
             LOG.info(MessageFormat.format("unbindStorageService({0})", storageService)); //$NON-NLS-1$
             xstreamPersistence = null;
             cache.clearAll();
             deleted.clearAll();
         }
     }

     /**
      * Creates a <code>XStreamPersistenceComponent</code> for the storage service specified
      * with the {@link BundleProperties#PROPERTY_STORAGE_SERVICE} bundle property.
      */
     public XStreamPersistenceComponent() {
         storageServiceClassName = BundleProperties.getProperty(BundleProperties.PROPERTY_STORAGE_SERVICE,
                 FileStorageComponent.class.getName());
     }

     /**
      * Creates a <code>XStreamPersistenceComponent</code> for a dedicated storage service.
      * <p>
      * This constructor is package protected for testing purposes.
      */
     XStreamPersistenceComponent(StorageService storageService) {
         xstreamPersistence = new XStreamPersistence(storageService);
     }

     @Override
     public synchronized <T extends EntityBase> void persist(Class<T> entityClass, EntityBase entity, String userId) {
         if (entity == null) {
             throw new IllegalArgumentException("argument 'entity' must not be null");
         }
         if (StringUtils.isBlank(userId)) {
             throw new IllegalArgumentException("argument 'userId' must not be null or an empty string");
         }

         if (xstreamPersistence == null) {
             LOG.warn(MessageFormat.format("Cannot persist entity {0}: StorageService not available", entity));
             return;
         }

         // load all project models
         loadModel(entityClass);

         // generate unique id
         UUID entityId = entity.getUuid();
         if (entityId == null) {
             entity.setUuid(UUID.randomUUID());
         }

         // verify parent is known
         // TODO should be in EntitySeriviceImpl#validate
         if (entity.getParentEntityId() != null) {
             UUID parentUUID = entity.getParentEntityId();
             EntityBase parent = getParentEntity(entityClass, entity);
             if (parent == null) {
                 throw new RuntimeException(MessageFormat.format("Parent entity {0} does not exist", parentUUID));
             }
         }

         EntityService<?> entityService = EntityServices.getByEntityClass(entityClass);
         if (entityService == null) {
             LOG.warn(MessageFormat.format(
                     "Cannot persist entity {0}:  No entity service registered for entities of type {1}",
                     entity.getUuid(), entityClass.getName()));
             return;
         }

         EntityBase oldEntity = getCachedEntity(entityClass, entityId);
         try {
             xstreamPersistence.saveEntity(entityService, entity, userId,
                     getAliases(entityClass), getConverters(entityClass));
         } catch (IOException e) {
             throw new RuntimeException(e);
         } catch (MigrationException e) {
             throw new RuntimeException(e);
         }

         // reload the entity to proof that is has been persisted successfully;
         // if so, adjust the parent/child relations of entity and put it into the cache.
         if (loadEntity(entityClass, entityId) != null) {
             adjustEntityRelations(entityClass, oldEntity, entity);
             updateCache(entity);
             if (entity.isDeleted()) {
                 AUDIT_LOG.info(MessageFormat.format("Entity {0} of type ''{1}'' has been deleted by user ''{2}''",
                         entityId, entityClass.getSimpleName(), userId));
             } else {
                 AUDIT_LOG.info(MessageFormat.format("Entity {0} of type ''{1}'' has been changed by user ''{2}''",
                         entityId, entityClass.getSimpleName(), userId));
             }
         } else {
             throw new RuntimeException(MessageFormat.format("Failed to save entity {0} of type {1}",
                     entity, entityClass.getName()));
         }
     }

     @Override
     public <T extends EntityBase> T loadEntity(Class<T> entityClass, UUID uuid) {
         if (xstreamPersistence == null) {
             LOG.warn(MessageFormat.format("Cannot load entity {0}/{1}: StorageService not available", entityClass, uuid));
             return null;
         }
         EntityService<T> entityService = EntityServices.getByEntityClass(entityClass);
         if (entityService == null) {
             LOG.warn(MessageFormat.format("No entity service registered for entities of type {0}", entityClass.getName()));
             return null;
         }
         T entity = null;
         try {
             entity = xstreamPersistence.loadEntity(entityService, uuid.toString(), getClassLoaders(entityClass),
                     getMigrations(entityClass), getAliases(entityClass), getConverters(entityClass));
         } catch (IOException e) {
             LOG.warn(MessageFormat.format("Cannot load entity {0}/{1} of type {2}):",
                     entityClass, uuid, entityClass.getName()), e);
         }

         // resolve the parent chain; if necessary, load missing entities from storage
         if (entity != null) {
             T parentEntity = getParentChain(entityClass, entity);
             if (parentEntity != null) {
                 entity.setParentEntity(parentEntity);
             }
         }
         return entity;
     }

     @Override
     public <T extends EntityBase> T getEntity(Class<T> entityClass, UUID uuid) {
         loadModel(entityClass);
         return cache.getEntity(entityClass, uuid);
     }

     @Override
     public <T extends EntityBase> List<T> getEntities(Class<T> entityClass) {
         loadModel(entityClass);
         return cache.getEntities(entityClass);
     }

     @Override
     public <T extends EntityBase> List<T> getEntities(Class<T> entityClass, EntityFilter<T> filter) {
         loadModel(entityClass);
         return cache.getEntities(entityClass, filter);
     }

     @Override
     public <T extends EntityBase> int size(Class<T> entityClass) {
         loadModel(entityClass);
         return cache.size(entityClass);
     }

     @Override
     public <T extends EntityBase> Set<UUID> keySet(Class<T> entityClass) {
         loadModel(entityClass);
         return cache.keySet(entityClass);
     }

     @Override
     public <T extends EntityBase> T getEntity(Class<T> entityClass, EntityFilter<T> filter) {
         loadModel(entityClass);
         return cache.getEntity(entityClass, filter);
     }

     @Override
     public <T extends EntityBase> T getDeletedEntity(Class<T> entityClass, UUID uuid) {
         loadModel(entityClass);
         return deleted.getEntity(entityClass, uuid);
     }

     @Override
     public <T extends EntityBase> List<T> getDeletedEntities(Class<T> entityClass) {
         loadModel(entityClass);
         return deleted.getEntities(entityClass);
     }

     @Override
     public <T extends EntityBase> Set<UUID> deletedSet(Class<T> entityClass) {
         loadModel(entityClass);
         return deleted.keySet(entityClass);
     }

     @Override
     public <T extends EntityBase> void refresh(Class<T> entityClass) {
         cache.clearAll(entityClass);
         deleted.clearAll(entityClass);
         loadModel(entityClass);
     }

     @Override
     public void refreshAll() {
         Set<Class<? extends EntityBase>> entityClasses = new HashSet<Class<? extends EntityBase>>();
         entityClasses.addAll(cache.getEntityTypes());
         entityClasses.addAll(deleted.getEntityTypes());
         cache.clearAll();
         deleted.clearAll();
         for (Class<? extends EntityBase> entityClass : entityClasses) {
             loadModel(entityClass);
         }
     }

     /**
      * Loads all entities of a given class from storage.
      *
      * Resolves the parent/child hierarchy of the loaded entities and stores the
      * result in the model caches (deleted entities in {@link #deleted},
      * all others in {@link #cache}).
      * <p>
      * This method is package protected for testing purposes.
      *
      * @param entityClass   the class of the entities to load.
      */
     synchronized <T extends EntityBase> void loadModel(Class<T> entityClass) {
         if (cache.size(entityClass) > 0) {
             //nothing to do, all entities are already loaded in the cache :-)
             return;
         }
         if (xstreamPersistence == null) {
             LOG.warn(MessageFormat.format("Cannot load entities of type {0}: StorageService not available", entityClass));
             return;
         }
         EntityService<T> entityService = EntityServices.getByEntityClass(entityClass);
         if (entityService == null) {
             LOG.warn(MessageFormat.format("No entity service registered for entities of type {0}", entityClass.getName()));
             return;
         }
         registerEntityClass(entityClass);

         List<T> loadedEntities;
         try {
             loadedEntities = xstreamPersistence.loadEntities(entityService,
                     getClassLoaders(entityClass), getMigrations(entityClass),
                     getAliases(entityClass), getConverters(entityClass));
         } catch (IOException e) {
             throw new RuntimeException(e);
         }
         for (EntityBase loadedEntity : loadedEntities) {
             updateCache(loadedEntity);
         }
         resolveEntityRelations(entityClass);
     }

     <T extends EntityBase> T getCachedEntity(Class<T> entityClass, UUID uuid) {
         T entity = cache.getEntity(entityClass, uuid);
         if (entity == null) {
             entity = deleted.getEntity(entityClass, uuid);
         }
         return entity;
     }

     /**
      * Registers the given entity class with the caches. An entity class must be
      * registered prior to adding an instance of the entity class to the caches.
      * <p>
      * This method is package protected for testing purposes.
      *
      * @param entityClass  the entity class to register.
      */
     <T extends EntityBase> void registerEntityClass(Class<T> entityClass) {
         if (!cache.isRegistered(entityClass)) {
             cache.registerEntityClass(entityClass);
         }
         if (!deleted.isRegistered(entityClass)) {
             deleted.registerEntityClass(entityClass);
         }
     }

     /**
      * Adds the given entity to the cache (deleted entities in {@link #deleted},
      * all other in {@link #cache}).
      * <p>
      * This method is package protected for testing purposes.
      *
      * @param entity  the entity to add.
      */
     void updateCache(EntityBase entity) {
         if (entity.isDeleted()) {
             cache.removeEntity(entity);
             deleted.putEntity(entity);
         } else {
             deleted.removeEntity(entity);
             cache.putEntity(entity);
         }
     }

     /**
      * Resolves all parent/child relations between entities of the
      * given class (separately for deleted and non-deleted entities!).
      * This method assumes that the caches have already been filled from
      * storage so that all referenced parents/children/siblings of any
      * entity in the cache can be resolved without loading additional
      * data from storage.
      * <p>
      * This method is package protected for testing purposes.
      *
      * @param entityClass  the class of entities to resolve relations for.
      */
     <T extends EntityBase> void resolveEntityRelations(Class<T> entityClass) {
         resolveEntityRelations(entityClass, cache.getEntities(entityClass));
         resolveEntityRelations(entityClass, deleted.getEntities(entityClass));
     }

     /**
      * Resolves all parent/child relations between entities in a
      * given collection. This method assumes that the collection of entities
      * is "self contained", i.e. all referenced parents/children/siblings
      * are also contained in the given list.
      * <p>
      * This method is package protected for testing purposes.
      *
      * @param entityClass  the class of entities to resolve relations for.
      * @param entities the entities to resolve relations for.
      */
     <T extends EntityBase> void resolveEntityRelations(Class<T> entityClass, Collection<T> entities) {
         for (T entity : entities) {
             resolveEntityRelations(entityClass, entity);
         }
     }

     /**
      * Determines the parent of the given entity and inserts the entity as
      * child of that parent. This method assumes that the parent is already in the cache.
      * <p>
      * This method is package protected for testing purposes.
      *
      * @param entityClass  the class of the entity.
      * @param entity  the entity to resolve.
      */
     <T extends EntityBase> void resolveEntityRelations(Class<T> entityClass, EntityBase entity) {
         T parentEntity = getParentEntity(entityClass, entity);
         entity.setParentEntity(parentEntity);
         if (parentEntity != null) {
             insertChildEntity(parentEntity, entity);
         }
     }

     /**
      * Adjusts the parent/child relations of an entity after it has been changed
      * or created. If the parent changed or the deleted flag has been switched,
      * the entity is removed from the old parent (if any) and assigned to
      * the new parent (if any). Furthermore, the children of the old entity
      * are assigned to the new entity.
      *
      * @param entityClass  the class of the entity.
      * @param oldEntity  the old entity instance, or <code>null</code> if the entity
      * did not exist before.
      * @param newEntity  the new entity instance, never <code>null</code>.
      */
     <T extends EntityBase> void adjustEntityRelations(Class<T> entityClass,
             EntityBase oldEntity, EntityBase newEntity) {
         T newParent = getParentEntity(entityClass, newEntity);
         if (oldEntity != null) {
             reassignChildren(oldEntity, newEntity);
             T oldParent = getParentEntity(entityClass, oldEntity);
             if (!ComparatorUtils.equals(oldParent, newParent)
                     || oldEntity.isDeleted() != newEntity.isDeleted()) {
                 removeChildEntity(oldParent, oldEntity);
             }
         }
         insertChildEntity(newParent, newEntity);
     }

     /**
      * Re-assigns the children of the oldEntity to the newEntity, i.e.
      * iterates through the children of oldEntity and sets the parent
      * pointer to newEntity. Furthermore, the firstChild pointer of
      * newEntity is assigned from oldEntity.
      *
      * @param oldEntity  the old entity.
      * @param newEntity  the new entity.
      */
     void reassignChildren(EntityBase oldEntity, EntityBase newEntity) {
         EntityBase next = oldEntity.getFirstChild();
         newEntity.setFirstChild(next);
         while (next != null) {
             next.setParentEntity(newEntity);
             next = next.getNextSibling();
         }
     }

     /**
      * Assigns a child entity to a given parent entity.
      * <p>
      * If there was no child yet, insert the entity as first child.
      * If an entity with the same uuid was already in the list of children,
      * replace the entity with the new value. Otherwise append the entity
      * to the end of the siblings chain. If the parent entity is <code>null</code>,
      * or parent and child have different deleted flags, the method does nothing.
      * <p>
      * This method is package protected for testing purposes.
      *
      * @param parentEntity  the parent entity, or <code>null</code>.
      * @param entity the entity to replace or append.
      */
     void insertChildEntity(EntityBase parentEntity, EntityBase entity) {
         if (parentEntity == null) {
             return;
         }
         entity.setParentEntity(parentEntity);
         if (parentEntity.isDeleted() != entity.isDeleted()) {
             return;
         }
         EntityBase next = parentEntity.getFirstChild();
         if (next == null) {
             parentEntity.setFirstChild(entity);
             return;
         }
         EntityBase prev = null;
         while (next != null) {
             if (next.equals(entity)) {
                 if (prev != null) {
                     prev.setNextSibling(entity);
                 } else {
                     parentEntity.setFirstChild(entity);
                 }
                 entity.setNextSibling(next.getNextSibling());
                 return;
             }
             prev = next;
             next = next.getNextSibling();
         }
         prev.setNextSibling(entity);
     }

     /**
      * Removes a child entity from a given parent entity.
      * <p>
      * If the parent entity has no children, or there is no entity
      * with the same uuid among the children, this method does nothing.
      * Otherwise the child entity matching the uuid is removed and the
      * siblings chain is adjusted. If the parent entity is <code>null</code>,
      * the method does nothing.
      * <p>
      * This method is package protected for testing purposes.
      *
      * @param parentEntity  the parent entity, or <code>null</code>.
      * @param entity  the entity to remove.
      */
     void removeChildEntity(EntityBase parentEntity, EntityBase entity) {
         if (parentEntity == null) {
             return;
         }
         EntityBase next = parentEntity.getFirstChild();
         if (next == null) {
             return;
         }
         EntityBase prev = null;
         while (next != null) {
             if (next.equals(entity)) {
                 if (prev != null) {
                     prev.setNextSibling(next.getNextSibling());
                 } else {
                     parentEntity.setFirstChild(next.getNextSibling());
                 }
                 next.setNextSibling(null);
                 return;
             }
             prev = next;
             next = next.getNextSibling();
         }
     }

     /**
      * Loads the whole chain of parent entities from storage (if neccessary),
      * and returns the parent entity of the given entity.
      * <p>
      * This method is package protected for testing purposes.
      *
      * @param entityClass  the class of the entity.
      * @param entity  the entity for which to lookup the parent.
      *
      * @return  the parent entity, or <code>null</code> if the entity has no parent, the parent
      * is deleted but the entity is not, or the parent entity could not be read from storage.
      */
     <T extends EntityBase> T getParentChain(Class<T> entityClass, EntityBase entity) {
         T parentEntity = null;
         UUID parentId = entity.getParentEntityId();
         if (parentId != null) {
             parentEntity = getParentEntity(entityClass, entity);
             if (parentEntity == null) {
                 parentEntity = loadEntity(entityClass, parentId);
                 if (parentEntity == null) {
                     LOG.warn(MessageFormat.format(
                             "Entity {0} references entity {1} as parent entity but there is no such entity",
                             entity.getUuid(), parentId));
                     return null;
                 }
             }
             if (parentEntity.isDeleted() && !entity.isDeleted()) {
                 LOG.warn(MessageFormat.format(
                         "Entity {0} cannot reference deleted entity {1} as parent entity",
                         entity.getUuid(), parentId));
                 return null;
             }
         }
         return parentEntity;
     }

     /**
      * Returns the parent entity of the given entity from the cache: If the given entity is
      * {@link EntityBase#isDeleted() deleted} the lookup is performed in the cache of
      * deleted entities. For all other entities the lookup is performed first in
      * the cache of non-deleted entities. If there is no match, the lookup is repeated
      * in the cache of deleted entities.
      * <p>
      * This method is package protected for testing purposes.
      *
      * @param entityClass  the class of the entity.
      * @param entity  the entity for which to lookup the parent.
      *
      * @return  the parent entity, or <code>null</code> if the parent entity is not in the caches
      * or the entity has no parent.
      */
     <T extends EntityBase> T getParentEntity(Class<T> entityClass, EntityBase entity) {
         T parentEntity = null;
         UUID parentId = entity.getParentEntityId();
         if (parentId != null) {
             if (!entity.isDeleted()) {
                 // undeleted entities can only reference undeleted entities
                 parentEntity = cache.getEntity(entityClass, parentId);
             }
             else {
                 // deleted entities can reference deleted & undeleted entities
                 parentEntity = cache.getEntity(entityClass, parentId);
                 if (parentEntity == null) {
                     parentEntity = deleted.getEntity(entityClass, parentId);
                 }
             }
         }
         return parentEntity;
     }
 }
	/*******************************************************************************
	* Copyright (c) 2010-2014 SAP AG and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* SAP AG - initial API and implementation
	*******************************************************************************/
	package org.eclipse.skalli.core.persistence;

	import java.io.IOException;
	import java.text.MessageFormat;
	import java.util.Collection;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Set;
	import java.util.UUID;

	import org.apache.commons.lang.StringUtils;
	import org.eclipse.skalli.commons.ComparatorUtils;
	import org.eclipse.skalli.core.storage.FileStorageComponent;
	import org.eclipse.skalli.model.EntityBase;
	import org.eclipse.skalli.model.EntityFilter;
	import org.eclipse.skalli.services.BundleProperties;
	import org.eclipse.skalli.services.entity.EntityService;
	import org.eclipse.skalli.services.entity.EntityServices;
	import org.eclipse.skalli.services.extension.MigrationException;
	import org.eclipse.skalli.services.persistence.PersistenceService;
	import org.eclipse.skalli.services.persistence.StorageService;
	import org.osgi.service.component.ComponentConstants;
	import org.osgi.service.component.ComponentContext;
	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	/**
	* Implementation of {@link PersistenceService} based on XStream.
	*/
	public class XStreamPersistenceComponent extends PersistenceServiceBase implements PersistenceService {

	private static final Logger LOG = LoggerFactory.getLogger(XStreamPersistenceComponent.class);
	private static final Logger AUDIT_LOG = LoggerFactory.getLogger("audit"); //$NON-NLS-1$

	private final EntityCache cache = new EntityCache();
	private final EntityCache deleted = new EntityCache();

	private XStreamPersistence xstreamPersistence;
	private String storageServiceClassName;

	protected void activate(ComponentContext context) {
	LOG.info(MessageFormat.format("[PersistenceService][xstream] {0} : activated",
	(String) context.getProperties().get(ComponentConstants.COMPONENT_NAME)));
	}

	protected void deactivate(ComponentContext context) {
	xstreamPersistence = null;
	cache.clearAll();
	deleted.clearAll();
	LOG.info(MessageFormat.format("[PersistenceService][xstream] {0} : deactivated",
	(String) context.getProperties().get(ComponentConstants.COMPONENT_NAME)));
	}

	protected void bindStorageService(StorageService storageService) {
	if (storageServiceClassName.equals(storageService.getClass().getName())) {
	xstreamPersistence = new XStreamPersistence(storageService);
	cache.clearAll();
	deleted.clearAll();
	LOG.info(MessageFormat.format("bindStorageService({0})", storageService)); //$NON-NLS-1$
	}
	}

	protected void unbindStorageService(StorageService storageService) {
	if (storageServiceClassName.equals(storageService.getClass().getName())) {
	LOG.info(MessageFormat.format("unbindStorageService({0})", storageService)); //$NON-NLS-1$
	xstreamPersistence = null;
	cache.clearAll();
	deleted.clearAll();
	}
	}

	/**
	* Creates a <code>XStreamPersistenceComponent</code> for the storage service specified
	* with the {@link BundleProperties#PROPERTY_STORAGE_SERVICE} bundle property.
	*/
	public XStreamPersistenceComponent() {
	storageServiceClassName = BundleProperties.getProperty(BundleProperties.PROPERTY_STORAGE_SERVICE,
	FileStorageComponent.class.getName());
	}

	/**
	* Creates a <code>XStreamPersistenceComponent</code> for a dedicated storage service.
	* <p>
	* This constructor is package protected for testing purposes.
	*/
	XStreamPersistenceComponent(StorageService storageService) {
	xstreamPersistence = new XStreamPersistence(storageService);
	}

	@Override
	public synchronized <T extends EntityBase> void persist(Class<T> entityClass, EntityBase entity, String userId) {
	if (entity == null) {
	throw new IllegalArgumentException("argument 'entity' must not be null");
	}
	if (StringUtils.isBlank(userId)) {
	throw new IllegalArgumentException("argument 'userId' must not be null or an empty string");
	}

	if (xstreamPersistence == null) {
	LOG.warn(MessageFormat.format("Cannot persist entity {0}: StorageService not available", entity));
	return;
	}

	// load all project models
	loadModel(entityClass);

	// generate unique id
	UUID entityId = entity.getUuid();
	if (entityId == null) {
	entity.setUuid(UUID.randomUUID());
	}

	// verify parent is known
	// TODO should be in EntitySeriviceImpl#validate
	if (entity.getParentEntityId() != null) {
	UUID parentUUID = entity.getParentEntityId();
	EntityBase parent = getParentEntity(entityClass, entity);
	if (parent == null) {
	throw new RuntimeException(MessageFormat.format("Parent entity {0} does not exist", parentUUID));
	}
	}

	EntityService<?> entityService = EntityServices.getByEntityClass(entityClass);
	if (entityService == null) {
	LOG.warn(MessageFormat.format(
	"Cannot persist entity {0}: No entity service registered for entities of type {1}",
	entity.getUuid(), entityClass.getName()));
	return;
	}

	EntityBase oldEntity = getCachedEntity(entityClass, entityId);
	try {
	xstreamPersistence.saveEntity(entityService, entity, userId,
	getAliases(entityClass), getConverters(entityClass));
	} catch (IOException e) {
	throw new RuntimeException(e);
	} catch (MigrationException e) {
	throw new RuntimeException(e);
	}

	// reload the entity to proof that is has been persisted successfully;
	// if so, adjust the parent/child relations of entity and put it into the cache.
	if (loadEntity(entityClass, entityId) != null) {
	adjustEntityRelations(entityClass, oldEntity, entity);
	updateCache(entity);
	if (entity.isDeleted()) {
	AUDIT_LOG.info(MessageFormat.format("Entity {0} of type ''{1}'' has been deleted by user ''{2}''",
	entityId, entityClass.getSimpleName(), userId));
	} else {
	AUDIT_LOG.info(MessageFormat.format("Entity {0} of type ''{1}'' has been changed by user ''{2}''",
	entityId, entityClass.getSimpleName(), userId));
	}
	} else {
	throw new RuntimeException(MessageFormat.format("Failed to save entity {0} of type {1}",
	entity, entityClass.getName()));
	}
	}

	@Override
	public <T extends EntityBase> T loadEntity(Class<T> entityClass, UUID uuid) {
	if (xstreamPersistence == null) {
	LOG.warn(MessageFormat.format("Cannot load entity {0}/{1}: StorageService not available", entityClass, uuid));
	return null;
	}
	EntityService<T> entityService = EntityServices.getByEntityClass(entityClass);
	if (entityService == null) {
	LOG.warn(MessageFormat.format("No entity service registered for entities of type {0}", entityClass.getName()));
	return null;
	}
	T entity = null;
	try {
	entity = xstreamPersistence.loadEntity(entityService, uuid.toString(), getClassLoaders(entityClass),
	getMigrations(entityClass), getAliases(entityClass), getConverters(entityClass));
	} catch (IOException e) {
	LOG.warn(MessageFormat.format("Cannot load entity {0}/{1} of type {2}):",
	entityClass, uuid, entityClass.getName()), e);
	}

	// resolve the parent chain; if necessary, load missing entities from storage
	if (entity != null) {
	T parentEntity = getParentChain(entityClass, entity);
	if (parentEntity != null) {
	entity.setParentEntity(parentEntity);
	}
	}
	return entity;
	}

	@Override
	public <T extends EntityBase> T getEntity(Class<T> entityClass, UUID uuid) {
	loadModel(entityClass);
	return cache.getEntity(entityClass, uuid);
	}

	@Override
	public <T extends EntityBase> List<T> getEntities(Class<T> entityClass) {
	loadModel(entityClass);
	return cache.getEntities(entityClass);
	}

	@Override
	public <T extends EntityBase> List<T> getEntities(Class<T> entityClass, EntityFilter<T> filter) {
	loadModel(entityClass);
	return cache.getEntities(entityClass, filter);
	}

	@Override
	public <T extends EntityBase> int size(Class<T> entityClass) {
	loadModel(entityClass);
	return cache.size(entityClass);
	}

	@Override
	public <T extends EntityBase> Set<UUID> keySet(Class<T> entityClass) {
	loadModel(entityClass);
	return cache.keySet(entityClass);
	}

	@Override
	public <T extends EntityBase> T getEntity(Class<T> entityClass, EntityFilter<T> filter) {
	loadModel(entityClass);
	return cache.getEntity(entityClass, filter);
	}

	@Override
	public <T extends EntityBase> T getDeletedEntity(Class<T> entityClass, UUID uuid) {
	loadModel(entityClass);
	return deleted.getEntity(entityClass, uuid);
	}

	@Override
	public <T extends EntityBase> List<T> getDeletedEntities(Class<T> entityClass) {
	loadModel(entityClass);
	return deleted.getEntities(entityClass);
	}

	@Override
	public <T extends EntityBase> Set<UUID> deletedSet(Class<T> entityClass) {
	loadModel(entityClass);
	return deleted.keySet(entityClass);
	}

	@Override
	public <T extends EntityBase> void refresh(Class<T> entityClass) {
	cache.clearAll(entityClass);
	deleted.clearAll(entityClass);
	loadModel(entityClass);
	}

	@Override
	public void refreshAll() {
	Set<Class<? extends EntityBase>> entityClasses = new HashSet<Class<? extends EntityBase>>();
	entityClasses.addAll(cache.getEntityTypes());
	entityClasses.addAll(deleted.getEntityTypes());
	cache.clearAll();
	deleted.clearAll();
	for (Class<? extends EntityBase> entityClass : entityClasses) {
	loadModel(entityClass);
	}
	}

	/**
	* Loads all entities of a given class from storage.
	*
	* Resolves the parent/child hierarchy of the loaded entities and stores the
	* result in the model caches (deleted entities in {@link #deleted},
	* all others in {@link #cache}).
	* <p>
	* This method is package protected for testing purposes.
	*
	* @param entityClass the class of the entities to load.
	*/
	synchronized <T extends EntityBase> void loadModel(Class<T> entityClass) {
	if (cache.size(entityClass) > 0) {
	//nothing to do, all entities are already loaded in the cache :-)
	return;
	}
	if (xstreamPersistence == null) {
	LOG.warn(MessageFormat.format("Cannot load entities of type {0}: StorageService not available", entityClass));
	return;
	}
	EntityService<T> entityService = EntityServices.getByEntityClass(entityClass);
	if (entityService == null) {
	LOG.warn(MessageFormat.format("No entity service registered for entities of type {0}", entityClass.getName()));
	return;
	}
	registerEntityClass(entityClass);

	List<T> loadedEntities;
	try {
	loadedEntities = xstreamPersistence.loadEntities(entityService,
	getClassLoaders(entityClass), getMigrations(entityClass),
	getAliases(entityClass), getConverters(entityClass));
	} catch (IOException e) {
	throw new RuntimeException(e);
	}
	for (EntityBase loadedEntity : loadedEntities) {
	updateCache(loadedEntity);
	}
	resolveEntityRelations(entityClass);
	}

	<T extends EntityBase> T getCachedEntity(Class<T> entityClass, UUID uuid) {
	T entity = cache.getEntity(entityClass, uuid);
	if (entity == null) {
	entity = deleted.getEntity(entityClass, uuid);
	}
	return entity;
	}

	/**
	* Registers the given entity class with the caches. An entity class must be
	* registered prior to adding an instance of the entity class to the caches.
	* <p>
	* This method is package protected for testing purposes.
	*
	* @param entityClass the entity class to register.
	*/
	<T extends EntityBase> void registerEntityClass(Class<T> entityClass) {
	if (!cache.isRegistered(entityClass)) {
	cache.registerEntityClass(entityClass);
	}
	if (!deleted.isRegistered(entityClass)) {
	deleted.registerEntityClass(entityClass);
	}
	}

	/**
	* Adds the given entity to the cache (deleted entities in {@link #deleted},
	* all other in {@link #cache}).
	* <p>
	* This method is package protected for testing purposes.
	*
	* @param entity the entity to add.
	*/
	void updateCache(EntityBase entity) {
	if (entity.isDeleted()) {
	cache.removeEntity(entity);
	deleted.putEntity(entity);
	} else {
	deleted.removeEntity(entity);
	cache.putEntity(entity);
	}
	}

	/**
	* Resolves all parent/child relations between entities of the
	* given class (separately for deleted and non-deleted entities!).
	* This method assumes that the caches have already been filled from
	* storage so that all referenced parents/children/siblings of any
	* entity in the cache can be resolved without loading additional
	* data from storage.
	* <p>
	* This method is package protected for testing purposes.
	*
	* @param entityClass the class of entities to resolve relations for.
	*/
	<T extends EntityBase> void resolveEntityRelations(Class<T> entityClass) {
	resolveEntityRelations(entityClass, cache.getEntities(entityClass));
	resolveEntityRelations(entityClass, deleted.getEntities(entityClass));
	}

	/**
	* Resolves all parent/child relations between entities in a
	* given collection. This method assumes that the collection of entities
	* is "self contained", i.e. all referenced parents/children/siblings
	* are also contained in the given list.
	* <p>
	* This method is package protected for testing purposes.
	*
	* @param entityClass the class of entities to resolve relations for.
	* @param entities the entities to resolve relations for.
	*/
	<T extends EntityBase> void resolveEntityRelations(Class<T> entityClass, Collection<T> entities) {
	for (T entity : entities) {
	resolveEntityRelations(entityClass, entity);
	}
	}

	/**
	* Determines the parent of the given entity and inserts the entity as
	* child of that parent. This method assumes that the parent is already in the cache.
	* <p>
	* This method is package protected for testing purposes.
	*
	* @param entityClass the class of the entity.
	* @param entity the entity to resolve.
	*/
	<T extends EntityBase> void resolveEntityRelations(Class<T> entityClass, EntityBase entity) {
	T parentEntity = getParentEntity(entityClass, entity);
	entity.setParentEntity(parentEntity);
	if (parentEntity != null) {
	insertChildEntity(parentEntity, entity);
	}
	}

	/**
	* Adjusts the parent/child relations of an entity after it has been changed
	* or created. If the parent changed or the deleted flag has been switched,
	* the entity is removed from the old parent (if any) and assigned to
	* the new parent (if any). Furthermore, the children of the old entity
	* are assigned to the new entity.
	*
	* @param entityClass the class of the entity.
	* @param oldEntity the old entity instance, or <code>null</code> if the entity
	* did not exist before.
	* @param newEntity the new entity instance, never <code>null</code>.
	*/
	<T extends EntityBase> void adjustEntityRelations(Class<T> entityClass,
	EntityBase oldEntity, EntityBase newEntity) {
	T newParent = getParentEntity(entityClass, newEntity);
	if (oldEntity != null) {
	reassignChildren(oldEntity, newEntity);
	T oldParent = getParentEntity(entityClass, oldEntity);
	if (!ComparatorUtils.equals(oldParent, newParent)
	\|\| oldEntity.isDeleted() != newEntity.isDeleted()) {
	removeChildEntity(oldParent, oldEntity);
	}
	}
	insertChildEntity(newParent, newEntity);
	}

	/**
	* Re-assigns the children of the oldEntity to the newEntity, i.e.
	* iterates through the children of oldEntity and sets the parent
	* pointer to newEntity. Furthermore, the firstChild pointer of
	* newEntity is assigned from oldEntity.
	*
	* @param oldEntity the old entity.
	* @param newEntity the new entity.
	*/
	void reassignChildren(EntityBase oldEntity, EntityBase newEntity) {
	EntityBase next = oldEntity.getFirstChild();
	newEntity.setFirstChild(next);
	while (next != null) {
	next.setParentEntity(newEntity);
	next = next.getNextSibling();
	}
	}

	/**
	* Assigns a child entity to a given parent entity.
	* <p>
	* If there was no child yet, insert the entity as first child.
	* If an entity with the same uuid was already in the list of children,
	* replace the entity with the new value. Otherwise append the entity
	* to the end of the siblings chain. If the parent entity is <code>null</code>,
	* or parent and child have different deleted flags, the method does nothing.
	* <p>
	* This method is package protected for testing purposes.
	*
	* @param parentEntity the parent entity, or <code>null</code>.
	* @param entity the entity to replace or append.
	*/
	void insertChildEntity(EntityBase parentEntity, EntityBase entity) {
	if (parentEntity == null) {
	return;
	}
	entity.setParentEntity(parentEntity);
	if (parentEntity.isDeleted() != entity.isDeleted()) {
	return;
	}
	EntityBase next = parentEntity.getFirstChild();
	if (next == null) {
	parentEntity.setFirstChild(entity);
	return;
	}
	EntityBase prev = null;
	while (next != null) {
	if (next.equals(entity)) {
	if (prev != null) {
	prev.setNextSibling(entity);
	} else {
	parentEntity.setFirstChild(entity);
	}
	entity.setNextSibling(next.getNextSibling());
	return;
	}
	prev = next;
	next = next.getNextSibling();
	}
	prev.setNextSibling(entity);
	}

	/**
	* Removes a child entity from a given parent entity.
	* <p>
	* If the parent entity has no children, or there is no entity
	* with the same uuid among the children, this method does nothing.
	* Otherwise the child entity matching the uuid is removed and the
	* siblings chain is adjusted. If the parent entity is <code>null</code>,
	* the method does nothing.
	* <p>
	* This method is package protected for testing purposes.
	*
	* @param parentEntity the parent entity, or <code>null</code>.
	* @param entity the entity to remove.
	*/
	void removeChildEntity(EntityBase parentEntity, EntityBase entity) {
	if (parentEntity == null) {
	return;
	}
	EntityBase next = parentEntity.getFirstChild();
	if (next == null) {
	return;
	}
	EntityBase prev = null;
	while (next != null) {
	if (next.equals(entity)) {
	if (prev != null) {
	prev.setNextSibling(next.getNextSibling());
	} else {
	parentEntity.setFirstChild(next.getNextSibling());
	}
	next.setNextSibling(null);
	return;
	}
	prev = next;
	next = next.getNextSibling();
	}
	}

	/**
	* Loads the whole chain of parent entities from storage (if neccessary),
	* and returns the parent entity of the given entity.
	* <p>
	* This method is package protected for testing purposes.
	*
	* @param entityClass the class of the entity.
	* @param entity the entity for which to lookup the parent.
	*
	* @return the parent entity, or <code>null</code> if the entity has no parent, the parent
	* is deleted but the entity is not, or the parent entity could not be read from storage.
	*/
	<T extends EntityBase> T getParentChain(Class<T> entityClass, EntityBase entity) {
	T parentEntity = null;
	UUID parentId = entity.getParentEntityId();
	if (parentId != null) {
	parentEntity = getParentEntity(entityClass, entity);
	if (parentEntity == null) {
	parentEntity = loadEntity(entityClass, parentId);
	if (parentEntity == null) {
	LOG.warn(MessageFormat.format(
	"Entity {0} references entity {1} as parent entity but there is no such entity",
	entity.getUuid(), parentId));
	return null;
	}
	}
	if (parentEntity.isDeleted() && !entity.isDeleted()) {
	LOG.warn(MessageFormat.format(
	"Entity {0} cannot reference deleted entity {1} as parent entity",
	entity.getUuid(), parentId));
	return null;
	}
	}
	return parentEntity;
	}

	/**
	* Returns the parent entity of the given entity from the cache: If the given entity is
	* {@link EntityBase#isDeleted() deleted} the lookup is performed in the cache of
	* deleted entities. For all other entities the lookup is performed first in
	* the cache of non-deleted entities. If there is no match, the lookup is repeated
	* in the cache of deleted entities.
	* <p>
	* This method is package protected for testing purposes.
	*
	* @param entityClass the class of the entity.
	* @param entity the entity for which to lookup the parent.
	*
	* @return the parent entity, or <code>null</code> if the parent entity is not in the caches
	* or the entity has no parent.
	*/
	<T extends EntityBase> T getParentEntity(Class<T> entityClass, EntityBase entity) {
	T parentEntity = null;
	UUID parentId = entity.getParentEntityId();
	if (parentId != null) {
	if (!entity.isDeleted()) {
	// undeleted entities can only reference undeleted entities
	parentEntity = cache.getEntity(entityClass, parentId);
	}
	else {
	// deleted entities can reference deleted & undeleted entities
	parentEntity = cache.getEntity(entityClass, parentId);
	if (parentEntity == null) {
	parentEntity = deleted.getEntity(entityClass, parentId);
	}
	}
	}
	return parentEntity;
	}
	}