EDIT

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/taxeditor/remoting/cache/CacheLoader.java -text

eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/handler/OpenInspectSessionsHandler.java -text

import eu.etaxonomy.cdm.model.common.DefinedTermBase;

import eu.etaxonomy.taxeditor.remoting.cache.CacheLoader;

public class CdmServiceCacher extends CdmCacher{

	private CacheLoader cacheLoader;

	    DefinedTermBase.setCacher(this);

		cacheLoader = new CacheLoader(this);

		return cacheLoader.load(term, true);

// $Id$

/**

 * Copyright (C) 2015 EDIT

 * European Distributed Institute of Taxonomy

 * http://www.e-taxonomy.eu

 *

 * The contents of this file are subject to the Mozilla Public License Version 1.1

 * See LICENSE.TXT at the top of this package for the full license terms.

 */

package eu.etaxonomy.taxeditor.remoting.cache;

import java.lang.reflect.Field;

import java.util.Collection;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import javassist.util.proxy.ProxyFactory;

import net.sf.ehcache.Cache;

import net.sf.ehcache.Element;

import org.apache.log4j.Logger;

import org.hibernate.collection.spi.PersistentCollection;

import org.hibernate.proxy.HibernateProxy;

import org.hibernate.proxy.LazyInitializer;

import org.springframework.util.ReflectionUtils;

import eu.etaxonomy.cdm.model.ICdmCacher;

import eu.etaxonomy.cdm.model.common.CdmBase;

/**

 * @author cmathew

 * @date 19 Feb 2015

 *

 */

public class CacheLoader {

    private static final Logger logger = Logger.getLogger(CacheLoader.class);

    private static boolean isRecursiveEnabled = true;

    private final ICdmCacher cdmCacher;

    private final Cache cdmlibModelCache;

    public CacheLoader(ICdmCacher cdmCacher) {

        this.cdmCacher = cdmCacher;

        this.cdmlibModelCache = CdmRemoteCacheManager.getInstance().getCdmModelGetMethodsCache();

    }

    public CdmModelFieldPropertyFromClass getFromCdmlibModelCache(String className) {

        Element e = cdmlibModelCache.get(className);

        if (e == null) {

            return null;

        } else {

            return (CdmModelFieldPropertyFromClass) e.getObjectValue();

        }

    }

    @SuppressWarnings("unchecked")

    public <T extends Object> T load(T obj, boolean recursive) {

        if(obj == null) {

            return null;

        }

        if(obj instanceof CdmBase) {

            return (T) load((CdmBase)obj, recursive);

        } else if (obj instanceof Map) {

            return (T) load((Map<T,T>)obj, recursive);

        } else if (obj instanceof Collection) {

            return (T) load((Collection<T>)obj, recursive);

        }

        return obj;

    }

    @SuppressWarnings("unchecked")

    private <T extends Object> T loadRecursive(T obj, Set<CdmBase> alreadyVisitedEntities) {

        if(obj == null) {

            return null;

        }

        if(obj instanceof CdmBase) {

            return (T) loadRecursive((CdmBase)obj, alreadyVisitedEntities);

        } else if (obj instanceof Map) {

            return (T) load((Map<T,T>)obj, alreadyVisitedEntities);

        } else if (obj instanceof Collection) {

            return (T) load((Collection<T>)obj, alreadyVisitedEntities);

        }

        logger.info("No caching yet for type " + obj.getClass().getName());

        return obj;

    }

    public <T extends Object> Map<T,T> load(Map<T,T> map, boolean recursive){

        if(map == null) {

            return null;

        }

        if(isRecursiveEnabled && recursive) {

            logger.info("---- starting recursive load for cdm entity map");

            Set<CdmBase> alreadyVisitedEntities = new HashSet<CdmBase>();

            Map<T,T> cachedMap = load(map, alreadyVisitedEntities);

            alreadyVisitedEntities.clear();

            logger.info("---- ending recursive load for cdm entity map \n");

            return cachedMap;

        } else {

            return load(map, null);

        }

    }

    private <T extends Object> Map<T,T> load(Map<T,T> map, Set<CdmBase> alreadyVisitedEntities){

        if(map == null || map.isEmpty()) {

            return map;

        }

        int originalMapSize = map.size();

        Object[] result = new Object[ map.size() * 2 ];

        Iterator<Map.Entry<T,T>> iter = map.entrySet().iterator();

        int i=0;

        while ( iter.hasNext() ) {

            Map.Entry<T,T> e = iter.next();

            result[i++] = e.getKey();

            result[i++] = e.getValue();

        }

        for(i=0; i<result.length;i++) {

            if(alreadyVisitedEntities == null) {

                result[i] = load(result[i], false);

            } else {

                result[i] = loadRecursive(result[i], alreadyVisitedEntities);

            }

        }

        map.clear();

        for(i = 0; i < originalMapSize; i+=2 ) {

            map.put(

                    (T)result[i],

                    (T)result[i+1]

                    );

        }

        return map;

    }

    public <T extends Object> Collection<T> load(Collection<T> collection, boolean recursive){

        if(collection == null) {

            return null;

        }

        Collection<T> loadedCollection;

        if(isRecursiveEnabled && recursive) {

            logger.info("---- starting recursive load for cdm entity collection");

            Set<CdmBase> alreadyVisitedEntities = new HashSet<CdmBase>();

            Collection<T> cachedCollection = load(collection, alreadyVisitedEntities);

            alreadyVisitedEntities.clear();

            logger.info("---- ending recursive load for cdm entity collection \n");

            loadedCollection = cachedCollection;

        } else {

            loadedCollection = load(collection, null);

        }

        return loadedCollection;

    }

    @SuppressWarnings("unchecked")

    private <T extends Object> Collection<T> load(Collection<T> collection, Set<CdmBase> alreadyVisitedEntities){

        int length = collection.size();

        Object[] result = new Object[length];

        Iterator<T> collectionItr = collection.iterator();

        int count = 0;

        while(collectionItr.hasNext()) {

            Object obj = collectionItr.next();

            if(alreadyVisitedEntities == null) {

                result[count] = load(obj, false);

            } else {

                result[count] = loadRecursive(obj, alreadyVisitedEntities);

            }

            count++;

        }

        collection.clear();

        for ( int i = 0; i < length; i++ ) {

            collection.add((T)result[i]);

        }

        return collection;

    }

    /**

     * Puts the (Key,Value) pair of ({@link java.util.UUID}, {@link eu.etaxonomy.cdm.model.common.CdmBase}),

     * in the cache corresponding to the given cache id

     *

     * @param cacheId

     * @param uuid

     * @param cdmEntity

     */

    public CdmBase load(CdmBase cdmEntity, boolean recursive) {

        if(cdmEntity == null) {

            return null;

        }

        // start by looking up the cdm entity in the cache

        CdmBase cachedCdmEntity = cdmCacher.getFromCache(cdmEntity);

        if(cachedCdmEntity != null) {

            // if cdm entity was found in cache then

            logger.info(" - object of type " + cdmEntity.getClass().getName() + " with id " + cdmEntity.getId() + " already exists");

            // .. return if the cached and input objects are identical, else (this is a newly loaded object so) continue

            if(cachedCdmEntity == cdmEntity) {

                return cachedCdmEntity;

            }

            return cachedCdmEntity;

        }

        CdmBase loadedCdmBase;

        if(isRecursiveEnabled && recursive) {

            logger.info("---- starting recursive load for cdm entity " + cdmEntity.getClass().getName() + " with id " + cdmEntity.getId());

            Set<CdmBase> alreadyVisitedEntities = new HashSet<CdmBase>();

            CdmBase cb =  loadRecursive(cdmEntity, alreadyVisitedEntities);

            alreadyVisitedEntities.clear();

            logger.info("---- ending recursive load for cdm entity " + cdmEntity.getClass().getName() + " with id " + cdmEntity.getId() + "\n");

            loadedCdmBase =  cb;

        } else {

            loadedCdmBase = load(cdmEntity);

        }

        return loadedCdmBase;

    }

    private CdmBase load(CdmBase cdmEntity) {

        logger.info("loading object of type " + cdmEntity.getClass().getName() + " with id " + cdmEntity.getId());

        // start by looking up the cdm entity in the cache

        CdmBase cachedCdmEntity = cdmCacher.getFromCache(cdmEntity);

        if(cachedCdmEntity != null) {

            // if cdm entity was found in cache then return ...

            logger.info(" - object of type " + cdmEntity.getClass().getName() + " with id " + cdmEntity.getId() + " already exists");

            return cachedCdmEntity;

        } else {

            // ... else save the entity in the cache

            cdmCacher.put(cdmEntity);

            logger.info(" - object of type " + cdmEntity.getClass().getName() + " with id " + cdmEntity.getId() + " put in cache");

            return cdmEntity;

        }

    }

    private CdmBase loadRecursive(CdmBase cdmEntity,  Set<CdmBase> alreadyVisitedEntities) {

        CdmBase cachedCdmEntity = load(cdmEntity);

        // we want to recursive through the cdmEntity (and not the cachedCdmEntity)

        // since there could be new or deleted objects in the cdmEntity sub-graph

        // start by getting the fields from the cdm entity

        String className = cdmEntity.getClass().getName();

        CdmModelFieldPropertyFromClass cmgmfc = getFromCdmlibModelCache(className);

        if(cmgmfc != null) {

            alreadyVisitedEntities.add(cdmEntity);

            List<String> fields = cmgmfc.getFields();

            for(String field : fields) {

                // retrieve the actual object corresponding to the field.

                // this object will be either a CdmBase or a Collection / Map

                // with CdmBase as the generic type

                CdmBase cdmEntityInSubGraph = getCdmBaseTypeFieldValue(cdmEntity, cachedCdmEntity, field, alreadyVisitedEntities);

                if(cdmEntityInSubGraph != null) {

                    //checkForIdenticalCdmEntity(alreadyVisitedEntities, cdmEntityInSubGraph);

                    if(!alreadyVisitedEntities.contains(cdmEntityInSubGraph)) {

                        logger.info("recursive loading object of type " + cdmEntityInSubGraph.getClass().getName() + " with id " + cdmEntityInSubGraph.getId());

                        loadRecursive(cdmEntityInSubGraph, alreadyVisitedEntities);

                    } else {

                        logger.info("object of type " + cdmEntityInSubGraph.getClass().getName() + " with id " + cdmEntityInSubGraph.getId() + " already visited");

                    }

                }

            }

        } else {

            throw new CdmClientCacheException("CdmEntity with class " + cdmEntity.getClass().getName() + " is not found in the cdmlib model cache. " +

                    "The cache may be corrupted or not in sync with the latest model version" );

        }

        return cachedCdmEntity;

    }

    private CdmBase getCdmBaseTypeFieldValue(CdmBase cdmEntity,

            CdmBase cachedCdmEntity,

            String fieldName,

            Set<CdmBase> alreadyVisitedEntities) {

        // this method attempts to make sure that for any two objects found in

        // the object graph, if they are equal then they should also be the same,

        // which is crucial for the merge to work

        if(cachedCdmEntity == null) {

            throw new CdmClientCacheException("When trying to set field value, the cached cdm entity cannot be null");

        }

        Class<?> clazz = cdmEntity.getClass();

        try {

            // this call will search in the provided class as well as

            // the super classes until it finds the field

            Field field = ReflectionUtils.findField(clazz, fieldName);

            if(field == null) {

                throw new CdmClientCacheException("Field '" + fieldName

                        + "' not found when searching in class '" + clazz.getName() + "' and its supercalsses");

            }

            field.setAccessible(true);

            Object o = field.get(cdmEntity);

            if(o != null && o instanceof HibernateProxy) {

                LazyInitializer hli = ((HibernateProxy)o).getHibernateLazyInitializer();

                if(!hli.isUninitialized()) {

                    o = ((HibernateProxy) o).getHibernateLazyInitializer().getImplementation();

                    field.set(cdmEntity, o);

                }

            }

            if(o != null && o instanceof PersistentCollection) {

                PersistentCollection pc = ((PersistentCollection)o);

                if(pc.wasInitialized()) {

                    o = ProxyUtils.getObject(pc);

                    field.set(cdmEntity, o);

                }

            }

            CdmBase cdmEntityInSubGraph = null;

            if(o != null

                    && !ProxyFactory.isProxyClass(o.getClass())

                    && !(o instanceof PersistentCollection) ) {

                if(CdmBase.class.isAssignableFrom(o.getClass())) {

                    logger.info("found initialised cdm entity '" + fieldName + "' in object of type " + clazz.getName() + " with id " + cdmEntity.getId());

                    cdmEntityInSubGraph  = (CdmBase)o;

                    CdmBase cachedCdmEntityInSubGraph = cdmCacher.getFromCache(cdmEntityInSubGraph);

                    // making sure that the field in cached cdm entity is always

                    // up-to-date by setting to the value of the cdm entity being loaded

                    // the only execption to this is found below

                    field.set(cachedCdmEntity, o);

                    // the only exception to updating the field to the latest value

                    // is the case where the field has been already initialised, cached and

                    // is not the same as the one in the cache, in which case we set the value

                    // of the field to the one found in the cache

                    if(cachedCdmEntityInSubGraph != null) {

                        if(cachedCdmEntityInSubGraph != cdmEntityInSubGraph) {

                            logger.info("setting cached + real value to '" + fieldName + "' in object of type " + clazz.getName() + " with id " + cdmEntity.getId());

                            field.set(cachedCdmEntity, cachedCdmEntityInSubGraph);

                            field.set(cdmEntity, cachedCdmEntityInSubGraph);

                        }

                        cdmEntityInSubGraph = null;

                    }

                } else if(o instanceof Map) {

                    loadRecursive((Map)o, alreadyVisitedEntities);

                } else if(o instanceof Collection) {

                    loadRecursive((Collection)o, alreadyVisitedEntities);

                }

            }

            // we return the original cdm entity in the sub graph because we

            // want to continue to recurse on the input cdm entity graph

            // and not the one in the cache

            return cdmEntityInSubGraph;

        } catch (SecurityException e) {

            throw new CdmClientCacheException(e);

        } catch (IllegalArgumentException e) {

            throw new CdmClientCacheException(e);

        } catch (IllegalAccessException e) {

            throw new CdmClientCacheException(e);

        }

    }

    private boolean checkForIdenticalCdmEntity(Set<CdmBase> cbSet, CdmBase cbToCompare) {

        if(cbToCompare != null) {

            for(CdmBase cb : cbSet) {

                if(cb == cbToCompare) {

                    return true;

                } else {

                    if(cb.equals(cbToCompare)) {

                        logger.info("equal but non identical object found of type " + cbToCompare.getUserFriendlyTypeName() + " with id " + cbToCompare.getId());

                    }

                }

            }

        }

        return false;

    }

    public static boolean isRecursiveEnabled() {

        return isRecursiveEnabled;

    }

    public static void  setRecursiveEnabled(boolean ire) {

        isRecursiveEnabled = ire;

    }

}

import eu.etaxonomy.cdm.model.ICdmCacher;

public class CdmTransientEntityCacher implements ICdmCacher {

    private final ICdmEntitySessionManager cdmEntitySessionManager;

    private final String cacheId;

    private final Cache cache;

    private final CacheLoader cacheLoader;

        CdmRemoteCacheManager.getInstance().getDefaultCacheManager().addCache(cache);

        cacheLoader = new CacheLoader(this);

        return  CdmRemoteCacheManager.getInstance().getDefaultCacheManager().getCache(cacheId);

        return cacheLoader.load(obj, recursive);

        return cacheLoader.load(map, recursive);

        return cacheLoader.load(collection, recursive);

        return cacheLoader.load(cdmEntity, recursive);

    public CdmModelFieldPropertyFromClass getFromCdmlibModelCache(String className) {

        return cacheLoader.getFromCdmlibModelCache(className);

    @Override

        Element cachedCdmEntityElement = cdmServiceCacher.getCacheElement(cdmEntity.getUuid());

        if(cachedCdmEntityElement != null) {

            logger.info("Cdm Entity with id : " + cdmEntity.getId() + " already exists in permanent cache. Ignoring put.");

            return;

    @Override

        CdmRemoteCacheManager.getInstance().getDefaultCacheManager().removeCache(cacheId);

import java.util.HashSet;

import java.util.Set;

    StringBuilder debugOutput = new StringBuilder();

                String out = toString(duplicateCdmEntityMap, notInCacheList, rootEntity);

                System.out.println(out);

                debugOutput.append(out);

    private void print(Map<CdmEntityInfo, CdmEntityInfo> duplicateCdmEntityMap,

            List<CdmEntityInfo> notInCacheList,

            CdmBase rootEntity) {

        System.out.println(toString(duplicateCdmEntityMap, notInCacheList, rootEntity));

        return debugOutput.toString();

    }

    private String toString(Map<CdmEntityInfo, CdmEntityInfo> duplicateCdmEntityMap,

            List<CdmEntityInfo> notInCacheList,

            CdmBase rootEntity) {

        sb.append(System.getProperty("line.separator"));

        sb.append("<<< Root Entity " + rootEntity.getUserFriendlyTypeName() + " with id " + rootEntity.getId() + " >>>");

        sb.append(System.getProperty("line.separator"));

                Object cbParent = cei.getParent().getObject();

                Object dupCbParent = dupCei.getParent().getObject();

                        " as member " + cei.getField().getName() +

                        " of entity " + cbParent.getClass().getCanonicalName());

                        " of entity " + dupCbParent.getClass().getCanonicalName());

                Object cbParent = cei.getParent().getObject();

                        " of entity" + cbParent.getClass().getCanonicalName());

        sb.append(System.getProperty("line.separator"));

        Set<CdmEntityInfo> alreadyVisitedEntities = new HashSet<CdmEntityInfo>();

            Set<CdmEntityInfo> alreadyVisitedEntities,

            debug((Map<T,T>)obj, alreadyVisitedEntities, cei);

            Set<CdmEntityInfo> alreadyVisitedEntities,

            Set<CdmEntityInfo> alreadyVisitedEntities,

            Set<CdmEntityInfo> alreadyVisitedEntities,

            alreadyVisitedEntities.add(cei);

                if(!childCei.isProxy()) {

                    Object object = childCei.getObject();

                    if(object != null && object instanceof CdmBase) {

                        CdmBase cdmEntityInSubGraph = (CdmBase)object;

                        if(!containsIdenticalCdmEntity(alreadyVisitedEntities, cdmEntityInSubGraph)) {

                            logger.info("recursive debugging object of type " + cdmEntityInSubGraph.getClass().getName() + " with id " + cdmEntityInSubGraph.getId());

                            debugRecursive(cdmEntityInSubGraph, alreadyVisitedEntities, childCei);

                        } else {

                            logger.info("object of type " + cdmEntityInSubGraph.getClass().getName() + " with id " + cdmEntityInSubGraph.getId() + " already visited");

                        }

            Set<CdmEntityInfo> alreadyVisitedEntities,

            CdmBase cdmEntityInSubGraph = null;

            boolean isHibernateProxy = false;

            boolean isPersistentCollection = false;

            childCei = new CdmEntityInfo(o);

            cei.addChild(childCei);

            childCei.setField(field);

                    } else {

                        isHibernateProxy = true;

                    } else {

                        isPersistentCollection = true;

                childCei.setObject(o);

                childCei.setProxy(isHibernateProxy || isPersistentCollection);

                if(!isHibernateProxy && !isPersistentCollection) {

                    if(CdmBase.class.isAssignableFrom(o.getClass())) {

                        logger.info("found initialised cdm entity '" + fieldName + "' in object of type " + clazz.getName() + " with id " + cdmEntity.getId());

                        cdmEntityInSubGraph  = (CdmBase)o;

                        CdmEntityInfo dupCei = getDuplicate(alreadyVisitedEntities, cdmEntityInSubGraph);

                        if(dupCei != null) {

                            addDuplicateEntity(childCei, dupCei);

                        }

                        CdmBase cachedCdmEntityInSubGraph = cacher.getFromCache(cdmEntityInSubGraph);

                        // the only exception to updating the field to the latest value

                        // is the case where the field has been already initialised, cached and

                        // is not the same as the one in the cache, in which case we set the value

                        // of the field to the one found in the cache

                        if(cachedCdmEntityInSubGraph == null) {

                            // found a cdm entity which is not in cache - need to record this

                            //logger.info("  - found entity not in cache " + fieldName + "' in object of type " + clazz.getName() + " with id " + cdmEntity.getId());

                            addEntityNotInCache(childCei);

                        }

                    } else if(o instanceof Map) {

                        debugRecursive((Map)o, alreadyVisitedEntities, childCei);

                    } else if(o instanceof Collection) {

                        debugRecursive((Collection)o, alreadyVisitedEntities, childCei);

    private CdmEntityInfo getDuplicate(Set<CdmEntityInfo> alreadyVisitedEntities, Object objectToCompare) {

        if(objectToCompare != null) {

            for(CdmEntityInfo cei: alreadyVisitedEntities) {

                if(objectToCompare.equals(cei.getObject()) && objectToCompare != cei.getObject()) {

                    return cei;

                }

            }

        }

        return null;

    }

    private boolean containsIdenticalCdmEntity(Set<CdmEntityInfo> ceiSet, Object objectToCompare) {

        if(objectToCompare != null) {

            for(CdmEntityInfo cei : ceiSet) {

                if(cei.getObject() == objectToCompare) {

                    return true;

                }

            }

        }

        return false;

    }

        private Object object;

        private boolean isProxy;

            isProxy = false;

                    label = "[" + className + "] " + fieldName + " : " + String.valueOf(((Collection)object).size());

                    label = "[" + className + "] " + fieldName + " : " + String.valueOf(((Map)object).size());

                    label = "[" + className + "] " + fieldName + " : " + object.toString();

        public void setObject(Object object) {

            this.object = object;

        }

        public boolean isProxy() {

            return isProxy;

        }

        public void setProxy(boolean isProxy) {

            this.isProxy = isProxy;

        }

        //debug(cdmBase);

		if(session == activeSession) {

		    activeSession = null;

		}

			expression="eu\.etaxonomy\.cdm\.api\.cache\.CdmTermCacher" />

      <command

            defaultHandler="eu.etaxonomy.taxeditor.handler.OpenInspectSessionsHandler"

            id="eu.etaxonomy.taxeditor.store.open.InspectSessionsDialog"

            name="Inspect Active Session">

      </command>

// $Id$

/**

* Copyright (C) 2015 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.taxeditor.handler;

import java.util.List;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.ExecutionException;

import org.eclipse.core.commands.IHandler;

import org.eclipse.swt.SWT;

import eu.etaxonomy.cdm.model.common.CdmBase;

import eu.etaxonomy.taxeditor.model.AbstractUtility;

import eu.etaxonomy.taxeditor.model.MessagingUtils;

import eu.etaxonomy.taxeditor.session.ICdmEntitySession;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.view.sessions.InspectSessionsDialog;

/**

 * @author cmathew

 * @date 18 Feb 2015

 *

 */

public class OpenInspectSessionsHandler extends AbstractHandler implements IHandler {

    /* (non-Javadoc)

     * @see org.eclipse.core.commands.IHandler#execute(org.eclipse.core.commands.ExecutionEvent)

     */

    /** {@inheritDoc} */

    @Override

    public Object execute(ExecutionEvent event) throws ExecutionException {

        Object principal = CdmStore.getCurrentAuthentiation().getPrincipal();

        ICdmEntitySession activeSession = CdmStore.getCurrentSessionManager().getActiveSession();

        if(activeSession == null) {

            MessagingUtils.warningDialog("No Active Session", this, "Active Session is null");

        } else {

            List<CdmBase> rootEntities = activeSession.getRootEntities();

            if(rootEntities == null || rootEntities.isEmpty()) {

                MessagingUtils.warningDialog("No Root Entities", this, "No root entities to inspect");

            } else {

                InspectSessionsDialog dialog = new InspectSessionsDialog(AbstractUtility.getShell(), SWT.NONE);

                dialog.open();

            }

        }

        return null;

    }

}

import org.eclipse.core.commands.NotEnabledException;

import org.eclipse.core.commands.NotHandledException;

import org.eclipse.core.commands.common.NotDefinedException;