EDIT

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/cdm/api/application/CdmApplicationRemoteConfiguration.java -text

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/cdm/api/application/CdmApplicationRemoteController.java -text

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/cdm/api/cache/CdmServiceCacher.java -text

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/cdm/api/lazyloading/CdmLazyLoader.java -text

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/cdm/remote/CdmPersistentRemoteSource.java -text

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/cdm/remote/CdmRemoteSource.java -text

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/cdm/remote/CdmRemoteSourceBase.java -text

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/cdm/remote/CdmRemoteSourceException.java -text

eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/cdm/remote/ICdmRemoteSource.java -text

eu.etaxonomy.taxeditor.cdmlib/src/main/java/org/hibernate/collection/internal/AbstractPersistentCollection.java -text

eu.etaxonomy.taxeditor.cdmlib/src/main/java/org/hibernate/proxy/AbstractLazyInitializer.java -text

 eu.etaxonomy.cdm.api.lazyloading,

 eu.etaxonomy.cdm.remote,

   javax.servlet.http"

/**

* Copyright (C) 2014 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.cdm.api.application;

import javax.sql.DataSource;

import org.hibernate.SessionFactory;

import org.apache.log4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;

import org.springframework.transaction.PlatformTransactionManager;

import org.springframework.transaction.TransactionStatus;

import eu.etaxonomy.cdm.api.conversation.ConversationHolder;

import eu.etaxonomy.cdm.api.conversation.ConversationHolderMock;

import eu.etaxonomy.cdm.api.service.IDatabaseService;

import eu.etaxonomy.cdm.ext.geo.IEditGeoService;

/**

 * CDM Application Configuration class which manages the configuration for remoting

 * clients

 *

 */

@Component

public class CdmApplicationRemoteConfiguration extends CdmApplicationDefaultConfiguration {

	@SuppressWarnings("unused")

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

	@Autowired

	IEditGeoService editGeoService;

	public CdmApplicationRemoteConfiguration() {

	}

    /* (non-Javadoc)

     * @see eu.etaxonomy.cdm.api.application.CdmApplicationDefaultConfiguration#getTransactionManager()

     */

    @Override

    public PlatformTransactionManager getTransactionManager() throws UnsupportedOperationException {

		throw new UnsupportedOperationException("getTransactionManager is not implemented for CdmApplicationRemoteConfiguration");

	}

    /* (non-Javadoc)

     * @see eu.etaxonomy.cdm.api.application.ICdmApplicationConfiguration#startTransaction()

     */

    @Override

    public TransactionStatus startTransaction() throws UnsupportedOperationException {

		throw new UnsupportedOperationException("startTransaction is not implemented for CdmApplicationRemoteConfiguration");

	}

    /* (non-Javadoc)

     * @see eu.etaxonomy.cdm.api.application.ICdmApplicationConfiguration#startTransaction()

     */

    @Override

    public TransactionStatus startTransaction(Boolean readOnly) throws UnsupportedOperationException {

		throw new UnsupportedOperationException("startTransaction is not implemented for CdmApplicationRemoteConfiguration");

	}

    /* (non-Javadoc)

     * @see eu.etaxonomy.cdm.api.application.CdmApplicationDefaultConfiguration#commitTransaction(org.springframework.transaction.TransactionStatus)

     */

    @Override

    public void commitTransaction(TransactionStatus txStatus) throws UnsupportedOperationException {

		throw new UnsupportedOperationException("commitTransaction is not implemented for CdmApplicationRemoteConfiguration");

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.api.application.CdmApplicationDefaultConfiguration#NewConversation()

	 */

	@Override

	public ConversationHolder NewConversation() {		

		return new ConversationHolderMock();

	}

	/**

	 * @return

	 */

	public IEditGeoService getEditGeoService() {

		return this.editGeoService;

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.api.application.CdmApplicationDefaultConfiguration#setDataSource(javax.sql.DataSource)

	 */

	@Override

	public void setDataSource(DataSource dataSource) {        		

    }

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.api.application.CdmApplicationDefaultConfiguration#setTransactionManager(org.springframework.transaction.PlatformTransactionManager)

	 */

	@Override

	public void setTransactionManager(PlatformTransactionManager transactionManager) {        

    }

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.api.application.CdmApplicationDefaultConfiguration#setSessionFactory(org.hibernate.SessionFactory)

	 */

	@Override

    public void setSessionFactory(SessionFactory sessionFactory) {    	

    }

}

/**

* Copyright (C) 2014 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.cdm.api.application;

import java.util.List;

import java.util.Properties;

import org.apache.log4j.Logger;

import org.hibernate.collection.internal.AbstractPersistentCollection;

import org.hibernate.proxy.AbstractLazyInitializer;

import org.springframework.beans.MutablePropertyValues;

import org.springframework.beans.factory.config.BeanDefinition;

import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;

import org.springframework.context.ApplicationListener;

import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;

import org.springframework.core.io.ClassPathResource;

import org.springframework.core.io.Resource;

import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;

import eu.etaxonomy.cdm.common.monitor.NullProgressMonitor;

import eu.etaxonomy.cdm.common.monitor.SubProgressMonitor;

import eu.etaxonomy.cdm.remote.ICdmRemoteSource;

/**

 * CDM Application Controller class for remoting clients

 * 

 * FIXME:Remoting extending {@link CdmApplicationController} is a temporary workaround.

 * The {@link CdmApplicationController} should be split into a CdmApplicationControllerBase

 * class with {@link CdmApplicationController} and this class as subclasses

 *

 */

public class CdmApplicationRemoteController  extends CdmApplicationController {

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

    public static final Resource DEFAULT_REMOTE_APPLICATION_CONTEXT_RESOURCE = 

    		new ClassPathResource("/eu/etaxonomy/cdm/remotingApplicationContext.xml");

    private final Resource applicationContextResource;

    private final IProgressMonitor progressMonitor;

    /**

     * Creates new instance of CdmApplicationRemoteController

     * 

     * @param applicationContextResource

     * @param remoteSource

     * @param omitTermLoading

     * @param progressMonitor

     * @param listeners

     * @return

     */

    public static CdmApplicationRemoteController NewInstance(Resource applicationContextResource, 

			ICdmRemoteSource remoteSource, 				

			boolean omitTermLoading, 

			IProgressMonitor progressMonitor, 

			List<ApplicationListener> listeners) {

    	return new CdmApplicationRemoteController(applicationContextResource, 

    			remoteSource, 

    			omitTermLoading, 

    			progressMonitor, 

				listeners);

    }

    /**

     * Creates new instance of CdmApplicationRemoteController

     * 

     * @param applicationContextResource

     * @param remoteSource

     * @param omitTermLoading

     * @param progressMonitor

     * @param listeners

     * @return

     */

    public static CdmApplicationRemoteController NewInstance(ICdmRemoteSource remoteSource, 				

			boolean omitTermLoading, 

			IProgressMonitor progressMonitor, 

			List<ApplicationListener> listeners) {

    	return new CdmApplicationRemoteController(DEFAULT_REMOTE_APPLICATION_CONTEXT_RESOURCE, 

    			remoteSource, 

    			omitTermLoading, 

    			progressMonitor, 

				listeners);

    }

	/**

	 * Constructs CdmApplicationRemoteController

	 * 

	 * @param applicationContextResource

	 * @param remoteSource

	 * @param omitTermLoading

	 * @param progressMonitor

	 * @param listeners

	 */

	private CdmApplicationRemoteController(Resource applicationContextResource, 

				ICdmRemoteSource remoteSource, 				

				boolean omitTermLoading, 

				IProgressMonitor progressMonitor, 

				List<ApplicationListener> listeners){

		logger.info("Start CdmApplicationRemoteController with remote source: " + remoteSource.getName());

        this.applicationContextResource = 

        		applicationContextResource != null ? applicationContextResource : DEFAULT_REMOTE_APPLICATION_CONTEXT_RESOURCE;

        this.progressMonitor = progressMonitor != null ? progressMonitor : new NullProgressMonitor();

        setNewRemoteSource(remoteSource, omitTermLoading, listeners);

	}

    /**

     * Creates and starts a new spring application context

     * 

     * @param remoteSource object for connecting to an http-invoker server

     * @param omitTermLoading

     * @param listeners

     * @return

     */

    protected boolean setNewRemoteSource(ICdmRemoteSource remoteSource, 

    		boolean omitTermLoading, 

    		List<ApplicationListener> listeners){

        logger.info("Connecting to '" + remoteSource.getName() + "'");

        MonitoredGenericApplicationContext applicationContext =  new MonitoredGenericApplicationContext();

        int refreshTasks = 45;

        int nTasks = 5 + refreshTasks;

        progressMonitor.beginTask("Connecting to '" + remoteSource.getName() + "'", nTasks);

        progressMonitor.subTask("Registering remote source.");

        PropertySourcesPlaceholderConfigurer pspc = new PropertySourcesPlaceholderConfigurer();

        Properties properties = new Properties();

        properties.setProperty("remoteServer", remoteSource.getServer());

        properties.setProperty("remotePort", String.valueOf(remoteSource.getPort()));

        properties.setProperty("remoteContext", remoteSource.getContextPath());

        pspc.setProperties(properties);

        applicationContext.addBeanFactoryPostProcessor(pspc);

        progressMonitor.worked(1);

        XmlBeanDefinitionReader xmlReader = new XmlBeanDefinitionReader(applicationContext);

        //xmlReader.setValidationMode(XmlBeanDefinitionReader.VALIDATION_NONE);

        progressMonitor.subTask("Registering resources.");

        xmlReader.loadBeanDefinitions(applicationContextResource);

        progressMonitor.worked(1);

        //omitTerms

        if (omitTermLoading == true){

            String initializerName = "persistentTermInitializer";

            BeanDefinition beanDef = applicationContext.getBeanDefinition(initializerName);

            MutablePropertyValues values = beanDef.getPropertyValues();

            values.addPropertyValue("omit", omitTermLoading);

        }

        if (listeners != null){

            for(ApplicationListener listener : listeners){

                applicationContext.addApplicationListener(listener);

            }

        }

        applicationContext.refresh(new SubProgressMonitor(progressMonitor, refreshTasks));

        applicationContext.start();

        progressMonitor.subTask("Cleaning up.");

        setApplicationContext(applicationContext);

        progressMonitor.worked(1);

        progressMonitor.done();

        return true;

    }

    /* (non-Javadoc)

     * @see eu.etaxonomy.cdm.api.application.CdmApplicationController#init()

     */

    @Override

    protected void init(){    

        configuration = (ICdmApplicationConfiguration)applicationContext.getBean("cdmApplicationRemoteConfiguration");

		AbstractLazyInitializer.setConfiguration(this);

		AbstractPersistentCollection.setConfiguration(this);

    }

}

package eu.etaxonomy.cdm.api.cache;

import java.util.UUID;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;

import eu.etaxonomy.cdm.api.service.ITermService;

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

/**

 * Class which uses CDM services to cache cdm entities

 *

 * FIXME: Currently only handles terms entities. It would be

 *        interesting to have a generic method which finds the

 *        correct service to load / cache the entity.

 *

 * @author cmathew

 *

 * @param <T>

 */

@Component

public class CdmServiceCacher<T extends CdmBase> extends CdmCacher<T> {

	@Autowired

	ITermService termService;

	@Override

	protected T findByUuid(UUID uuid) {

		return (T)termService.findWithoutFlush(uuid);

	}

    /* (non-Javadoc)

     * @see eu.etaxonomy.cdm.api.cache.CdmCacher#setup()

     */

    @Override

    protected void setup() {

        // TODO Auto-generated method stub

    }

}

package eu.etaxonomy.cdm.api.lazyloading;

import java.lang.reflect.Field;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.TreeMap;

import java.util.TreeSet;

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.Around;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Pointcut;

import org.hibernate.collection.internal.PersistentList;

import org.hibernate.collection.internal.PersistentMap;

import org.hibernate.collection.internal.PersistentSet;

import org.hibernate.collection.internal.PersistentSortedMap;

import org.hibernate.collection.internal.PersistentSortedSet;

import org.hibernate.collection.spi.PersistentCollection;

import org.hibernate.proxy.LazyInitializer;

import org.springframework.beans.factory.annotation.Autowire;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Configurable;

import org.springframework.stereotype.Component;

import eu.etaxonomy.cdm.api.service.ICommonService;

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

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

@Aspect

@Component

@Configurable(autowire = Autowire.BY_TYPE)

public class CdmLazyLoader {

	private Set classes = new HashSet();

	public static boolean enableWeaving = true;

	private static Set<String> classesToIgnore = new HashSet<String>();

	@Autowired

	private ICommonService commonService;

	public CdmLazyLoader() {

		//classesToIgnore.add("eu.etaxonomy.cdm.model.common.TermVocabulary");

		//classesToIgnore.add("eu.etaxonomy.cdm.model.common.OrderedTermVocabulary");

	}

	/**

	 *  Point cut for the 'initialize' method of the AbstractLazyInitializer.

	 *  

	 */

	@Pointcut("execution(* org.hibernate.proxy.AbstractLazyInitializer.initialize())")

	public void possibleEntityLazyInitializationException() {

	}

	/**

	 *  'Around' advice for the initialization of CDM Entity Objects

	 *  

	 */

	@Around(value = "possibleEntityLazyInitializationException()")

	public Object preloadEntityOnDemand(ProceedingJoinPoint pjp) throws Throwable {		 

		if(enableWeaving) {

			LazyInitializer ll = (LazyInitializer)pjp.getTarget();		

			if(ll.isUninitialized()) {				

				int classid = ((Integer)ll.getIdentifier()).intValue();

				System.out.print("--> AspectJ Compile-Time Weaving " + ll.getEntityName() + " with id " + classid);

				Class clazz = (Class<? extends CdmBase>) Class.forName(ll.getEntityName());

				CdmBase cdmBase = CdmBase.deproxy(commonService.find(clazz,classid),clazz);

				ll.setImplementation(cdmBase);

				System.out.println("....Done");

			}

		}

		return pjp.proceed();		  	    	  

	}

	/**

	 *  Point cut for the 'initialize' method of the AbstractPersistentCollection.

	 *  

	 */

	@Pointcut("execution(protected final void org.hibernate.collection.internal.AbstractPersistentCollection.initialize(..))")

	public void possibleCollectionLazyInitializationException() {

	}

	/**

	 *  'Around' advice for the initialization of Collection objects

	 *  

	 */

	@Around(value = "possibleCollectionLazyInitializationException()")	

	public Object preloadCollectionOnDemand(ProceedingJoinPoint pjp) throws Throwable {		 

		if(enableWeaving) {

			PersistentCollection ps = (PersistentCollection) pjp.getTarget();

			if (ps.getOwner() != null && !classesToIgnore.contains(ps.getOwner().getClass().getName()) && !ps.wasInitialized() &&  !classes.contains(ps.getKey())) {

				System.out.print("--> AspectJCompile-Time Weaving " + ps.getRole());                

				classes.add(ps.getKey());

				try {

					String role = ps.getRole();

					String fieldName = role.substring(role.lastIndexOf(".") + 1);

					System.out.print(", field : " + fieldName);

					Object owner = ps.getOwner();

					PersistentCollection col = commonService.initializeCollection(ps); 

					ps.afterInitialize();

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

					if (clazz != null) {	

						CollectionField cf = getCollectionField(col);

						Field field = clazz.getDeclaredField(cf.getFieldName());

						field.setAccessible(true);

						field.set(ps, cf.getCollection());			       

					}		

				} catch (Exception ex) {

					ex.printStackTrace();

					System.out.println("Error in ReattachSessionAspect : " + ex.getMessage());

				} finally {

					classes.remove(ps.getKey());

					System.out.println("....Done");

				}	

			}

		} 

		return pjp.proceed();

	}

	private CollectionField getCollectionField(PersistentCollection pc) {

		if(pc != null) {

			if(pc instanceof PersistentSet) {

				return new CollectionField(new HashSet((Set)pc), "set");

			}

			if(pc instanceof PersistentSortedSet) {

				return new CollectionField(new TreeSet((Set)pc), "set");

			}

			if(pc instanceof PersistentList) {

				return new CollectionField(new ArrayList((List)pc), "list");

			}

			if(pc instanceof PersistentMap || pc instanceof PersistentMultiLanguageText) {

				return new CollectionField(new HashMap((Map)pc), "map");

			}

			if(pc instanceof PersistentSortedMap) {

				return new CollectionField(new TreeMap((Map)pc), "map");

			}

		}

		return null;

	}

	private String getCollectionFieldName(PersistentCollection pc) {

		if(pc != null) {

			if(pc instanceof PersistentSet || pc instanceof PersistentSortedSet) {

				return "set";

			}			

			if(pc instanceof PersistentList) {

				return "list";

			}

			if(pc instanceof PersistentMap || pc instanceof PersistentMultiLanguageText) {

				return "map";

			}

		}

		return null;

	}

	private class CollectionField {

		private Object col;

		private String fieldName;

		public CollectionField(Object col, String fieldName) {

			this.col = col;

			this.fieldName = fieldName;

		}

		public Object getCollection() {

			return this.col;

		}

		public String getFieldName() {

			return this.fieldName;

		}

	}

}

/**

* Copyright (C) 2014 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.cdm.remote;

import static eu.etaxonomy.cdm.common.XmlHelp.getBeansRoot;

import static eu.etaxonomy.cdm.common.XmlHelp.insertXmlBean;

import static eu.etaxonomy.cdm.common.XmlHelp.insertXmlValueProperty;

import static eu.etaxonomy.cdm.common.XmlHelp.saveToXml;

import java.util.ArrayList;

import java.util.Enumeration;

import java.util.List;

import java.util.Properties;

import org.apache.log4j.Logger;

import org.jdom.Attribute;

import org.jdom.Element;

import eu.etaxonomy.cdm.common.CdmUtils;

import eu.etaxonomy.cdm.common.XmlHelp;

import eu.etaxonomy.cdm.config.CdmPersistentSourceUtils;

import eu.etaxonomy.cdm.config.CdmPersistentXMLSource;

import eu.etaxonomy.cdm.config.CdmSourceException;

import eu.etaxonomy.cdm.config.ICdmPersistentSource;

import eu.etaxonomy.cdm.config.CdmPersistentXMLSource.CdmSourceProperties;

import eu.etaxonomy.cdm.database.CdmDataSource;

import eu.etaxonomy.cdm.database.CdmPersistentDataSource;

import eu.etaxonomy.cdm.database.DataSourceNotFoundException;

import eu.etaxonomy.cdm.database.DatabaseTypeEnum;

import eu.etaxonomy.cdm.database.ICdmDataSource;

import eu.etaxonomy.cdm.database.types.IDatabaseType;

import eu.etaxonomy.cdm.model.name.NomenclaturalCode;

/**

 * Class representing a CDM remote source which can be persisted to a source config file

 *

 */

public class CdmPersistentRemoteSource extends CdmRemoteSourceBase implements ICdmPersistentSource{

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

	public static final String REMOTESOURCE_BEAN_POSTFIX = "RemoteSource";

	private String beanName;

	private Properties cdmSourceProperties;

	private List<Attribute> cdmSourceAttributes;

	/**

	 * Creates a new instance of CdmPersistentRemoteSource

	 * 

	 * @param name

	 * @param server

	 * @param port

	 * @param contextPath

	 * @param nomenclaturalCode

	 * @return

	 * @throws CdmRemoteSourceException 

	 */

	public static CdmPersistentRemoteSource NewInstance(String remoteSource) throws CdmRemoteSourceException {

		if(exists(remoteSource)) {

			return new CdmPersistentRemoteSource(remoteSource);

		} else {

			throw new CdmRemoteSourceException("Remote source '" + remoteSource + "' does not exist in sources setting file");

		}

	}

	/**S

	 * Creates a new CdmPersistentRemoteSource

	 * 

	 * @param name

	 * @param server

	 * @param port

	 * @param contextPath

	 * @param nomenclaturalCode

	 * @throws CdmRemoteSourceException 

	 */

	private CdmPersistentRemoteSource(String remoteSource) throws CdmRemoteSourceException { 

		CdmPersistentXMLSource cdmPersistentXMLSource = CdmPersistentXMLSource.NewInstance(remoteSource, REMOTESOURCE_BEAN_POSTFIX);

		if(cdmPersistentXMLSource.getElement() != null) {

			beanName = cdmPersistentXMLSource.getBeanName();

			// properties from the persistent xml file 

			cdmSourceProperties = cdmPersistentXMLSource.getCdmSourceProperties();

			cdmSourceAttributes = cdmPersistentXMLSource.getCdmSourceAttributes();

			checkProperties(cdmSourceProperties);

		} else {

			throw new CdmRemoteSourceException("Remote source '" + remoteSource + "' does not exist in settings file");

		}		

		initDatabaseConnection();

	}

	private static void checkProperties(Properties cdmSourceProperties) throws CdmRemoteSourceException {

		if(!cdmSourceProperties.containsKey(CdmSourceProperties.SERVER.toString())) {

			throw new CdmRemoteSourceException("Could not initialise remote source. Required property '" + CdmSourceProperties.SERVER.toString() + "' is missing");			

		}

		String port = (String)cdmSourceProperties.get(CdmSourceProperties.PORT.toString());

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

			throw new CdmRemoteSourceException("Could not initialise remote source. Required property '" + CdmSourceProperties.SERVER.toString() + "' is missing");			

		}	

		if(!cdmSourceProperties.containsKey(CdmSourceProperties.CONTEXTPATH.toString())) {

			throw new CdmRemoteSourceException("Could not initialise remote source. Required property '" + CdmSourceProperties.SERVER.toString() + "' is missing");			

		}	

		// default NomenclaturalCode is always ICNAFP

		if(!cdmSourceProperties.containsKey(CdmSourceProperties.NOMENCLATURAL_CODE.toString())) {				

			cdmSourceProperties.put(CdmSourceProperties.NOMENCLATURAL_CODE.toString(), NomenclaturalCode.ICNAFP.name());

		}			

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.config.ICdmPersistentSource#getBeanName()

	 */

	@Override

	public String getBeanName() {

		return beanName;

	}

	@Override

	public String getServer() {

		return cdmSourceProperties.getProperty(CdmSourceProperties.SERVER.toString());

	}

	@Override

	public int getPort() {

		String port = CdmUtils.Nz(cdmSourceProperties.getProperty(CdmSourceProperties.PORT.toString()));

		if (port == null || "".equals(port)){

			return -1;

		}else{

			//TODO exception if non integer

			return Integer.valueOf(port);

		}

	}

	@Override

	public String getContextPath() {

		return cdmSourceProperties.getProperty(CdmSourceProperties.CONTEXTPATH.toString());

	}

	@Override

	public NomenclaturalCode getNomenclaturalCode() {

		return NomenclaturalCode.fromString(cdmSourceProperties.getProperty(CdmSourceProperties.NOMENCLATURAL_CODE.toString()));

	}

	public static CdmPersistentRemoteSource save(String strRemoteSourceName, ICdmRemoteSource remoteSource) throws CdmRemoteSourceException {

		Properties cdmSourceProperties = new Properties();

		cdmSourceProperties.put(CdmSourceProperties.SERVER.toString(), remoteSource.getServer());

		cdmSourceProperties.put(CdmSourceProperties.PORT.toString(), String.valueOf(remoteSource.getPort()));

		cdmSourceProperties.put(CdmSourceProperties.CONTEXTPATH.toString(), remoteSource.getContextPath());

		cdmSourceProperties.put(CdmSourceProperties.NOMENCLATURAL_CODE.toString(), remoteSource.getNomenclaturalCode().name());

		checkProperties(cdmSourceProperties);

		return save(strRemoteSourceName, cdmSourceProperties);

	}

	private static CdmPersistentRemoteSource save(String strRemoteSourceName,Properties cdmSourceProperties) throws CdmRemoteSourceException {

		//root

		Element root = getBeansRoot(CdmPersistentSourceUtils.getCdmSourceInputStream());

		if (root == null){

			return null;

		}

		//bean

		Element bean = XmlHelp.getFirstAttributedChild(root, "bean", "id", CdmPersistentSourceUtils.getBeanName(strRemoteSourceName, REMOTESOURCE_BEAN_POSTFIX));

		if (bean != null){

			bean.detach();  //delete old version if necessary

		}

		bean = insertXmlBean(root, CdmPersistentSourceUtils.getBeanName(strRemoteSourceName, REMOTESOURCE_BEAN_POSTFIX), CdmPersistentRemoteSource.class.getName());

		Properties props = cdmSourceProperties;

		Enumeration e = props.propertyNames();

		while (e.hasMoreElements()) {

			String key = (String) e.nextElement();

			insertXmlValueProperty(bean, key, props.getProperty(key));

		}

		//save

		saveToXml(root.getDocument(), 

				CdmPersistentSourceUtils.getResourceDirectory(), 

				CdmPersistentXMLSource.CDMSOURCE_FILE_NAME, 

				XmlHelp.prettyFormat );

		return NewInstance(strRemoteSourceName) ;

	}

	/**

	 * @param strDataSourceName

	 * @param dataSource

	 * @param code 

	 * @return

	 * 			the updated dataSource, null if not succesful

	 */

	public static CdmPersistentRemoteSource update(String strRemoteSourceName,

			ICdmRemoteSource remoteSource) throws CdmRemoteSourceException {

		CdmPersistentSourceUtils.delete(CdmPersistentSourceUtils.getBeanName(strRemoteSourceName,REMOTESOURCE_BEAN_POSTFIX));

		return save(strRemoteSourceName, remoteSource);

	}

	/**

	 * Tests existing of the datsource in the according config  file.

	 * @return true if a datasource with the given name exists in the according datasource config file.

	 */

	public static boolean exists(String strRemoteSourceName){

		Element bean = CdmPersistentSourceUtils.getCdmSourceBeanXml(strRemoteSourceName, REMOTESOURCE_BEAN_POSTFIX);

		return (bean != null);

	}

	/**

	 * Returns a list of all datasources stored in the datasource config file

	 * @return all existing data sources

	 * @throws CdmRemoteSourceException 

	 */

	@SuppressWarnings("unchecked")

	static public List<CdmPersistentRemoteSource> getAllRemoteSources() throws CdmRemoteSourceException{

		List<CdmPersistentRemoteSource> remoteSources = new ArrayList<CdmPersistentRemoteSource>();

		Element root = getBeansRoot(CdmPersistentSourceUtils.getCdmSourceInputStream());

		if (root == null){

			return null;

		}else{

	    	List<Element> lsChildren  = root.getChildren("bean", root.getNamespace());

	    	for (Element elBean : lsChildren){

	    		String strId = elBean.getAttributeValue("id");

	    		if (strId != null && strId.endsWith(REMOTESOURCE_BEAN_POSTFIX)){

	    			strId = strId.replace(REMOTESOURCE_BEAN_POSTFIX, "");

	    			remoteSources.add(new CdmPersistentRemoteSource(strId));

	    		}

	    	}

		}

		return remoteSources;

	}

	@Override

	public String toString(){

		if (getName() != null){

			return getName();

		}else{

			return null;

		}

	}

}

/**

* Copyright (C) 2014 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.cdm.remote;

import eu.etaxonomy.cdm.model.name.NomenclaturalCode;

/**

 * Class representing a CDM remote source 

 *

 */

public class CdmRemoteSource extends CdmRemoteSourceBase {

	/**

	 * Creates a new instance of CdmRemoteSource

	 * 

	 * @param name

	 * @param server

	 * @param port

	 * @param contextPath

	 * @param nomenclaturalCode

	 * @return

	 */

	public static CdmRemoteSource NewInstance() {

		return new CdmRemoteSource(DEFAULT_NAME, DEFAULT_SERVER, DEFAULT_PORT, DEFAULT_CONTEXT_PATH, DEFAULT_NOMENCLATURAL_CODE);

	}

	/**

	 * Creates a new instance of CdmRemoteSource

	 * 

	 * @param name

	 * @param server

	 * @param port

	 * @param contextPath

	 * @param nomenclaturalCode

	 * @return

	 */

	public static CdmRemoteSource NewInstance(String name, String server, int port, String contextPath, NomenclaturalCode nomenclaturalCode) {

		return new CdmRemoteSource(name, server, port, contextPath, nomenclaturalCode);

	}

	/**

	 * Creates a new CdmRemoteSource

	 * 

	 * @param name

	 * @param server

	 * @param port

	 * @param contextPath

	 * @param nomenclaturalCode

	 */

	private CdmRemoteSource(String name, String server, int port, String contextPath, NomenclaturalCode nomenclaturalCode) { 

		super(name, server, port, contextPath, nomenclaturalCode);

	}

}

/**

* Copyright (C) 2014 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.cdm.remote;

import java.util.Map;

import org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean;

import eu.etaxonomy.cdm.api.service.IDatabaseService;

import eu.etaxonomy.cdm.config.CdmSource;

import eu.etaxonomy.cdm.config.CdmSourceException;

import eu.etaxonomy.cdm.database.DatabaseTypeEnum;

import eu.etaxonomy.cdm.model.metadata.CdmMetaData.MetaDataPropertyName;

import eu.etaxonomy.cdm.model.name.NomenclaturalCode;

/**

 * Base class representing a CDM remote source. 

 * This class handles all the configuration relating to the remoting aspect of

 * a CDM source.

 *

 */

public class CdmRemoteSourceBase extends CdmSource implements ICdmRemoteSource {

	protected static final String DEFAULT_NAME = "default";

	protected static final String DEFAULT_SERVER = "127.0.0.1";

	protected static final int DEFAULT_PORT = 8080;

	protected static final String DEFAULT_CONTEXT_PATH = "";

	protected static final NomenclaturalCode DEFAULT_NOMENCLATURAL_CODE = NomenclaturalCode.ICNAFP;

	private String contextPath;

	private String baseUrl;

	private IDatabaseService databaseService;

	/**

	 * Constructs a CdmRemoteSourceBase object with default values.

	 * 

	 */

	protected CdmRemoteSourceBase() {

		setName(DEFAULT_NAME);

		setServer(DEFAULT_SERVER);

		setPort(DEFAULT_PORT);

		setContextPath(DEFAULT_CONTEXT_PATH);

		setNomenclaturalCode(DEFAULT_NOMENCLATURAL_CODE);

	}

	/**

	 * Constructs a CdmRemoteSourceBase

	 * 

	 * @param name

	 * @param server

	 * @param port

	 * @param contextPath

	 * @param nomenclaturalCode

	 */

	protected CdmRemoteSourceBase(String name, String server, int port, String contextPath, NomenclaturalCode nomenclaturalCode) {

		setName(name);

		setServer(server);

		setPort(port);

		setContextPath(contextPath);

		setNomenclaturalCode(nomenclaturalCode);			

		initDatabaseConnection();

	}

	protected void initDatabaseConnection() {

		if(getContextPath() == null || getContextPath().equals("")) {

			setBaseUrl("http://" + getServer() + ":" + String.valueOf(getPort()));

		} else {

			setBaseUrl("http://" + getServer()  + ":" + String.valueOf(getPort()) + "/" + getContextPath());

		}	

		// the database service needs to be initialised (before the spring

		// application context initialsation) since it is required to 

		// to make queries related to the source database

	    HttpInvokerProxyFactoryBean proxy = new HttpInvokerProxyFactoryBean();

	    proxy.setServiceInterface(IDatabaseService.class);

	    proxy.setServiceUrl(baseUrl + "/remoting/database.service");

	    proxy.afterPropertiesSet();

	    databaseService = (IDatabaseService) proxy.getObject();

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.remote.ICdmRemoteSource#getBaseUrl()

	 */

	@Override

	public String getBaseUrl() {

		return baseUrl;

	}

	/**

	 * Sets the base url for the http-invoker services as listed in 

	 * httpInvokerServicesClients.xml.

	 * e.g. for 'http://127.0.0.1:8080/col/remoting/common.service', the 

	 * base url would be 'http://127.0.0.1:8080/col'

	 * 

	 * @param baseUrl

	 */

	public void setBaseUrl(String baseUrl) {

		this.baseUrl = baseUrl;

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.remote.ICdmRemoteSource#getContextPath()

	 */

	@Override

	public String getContextPath() {

		return contextPath;

	}

	/**

	 * Sets the context path.

	 * e.g. for 'http://127.0.0.1:8080/col/remoting/common.service', the 

	 * context path would be 'col'

	 * 

	 * @param contextPath

	 */

	public void setContextPath(String contextPath) {

		this.contextPath = contextPath;

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.config.CdmSource#getDbSchemaVersion()

	 */

	@Override

	public String getDbSchemaVersion() throws CdmSourceException {

		return databaseService.getDbSchemaVersion();

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.config.CdmSource#isDbEmpty()

	 */

	@Override

	public boolean isDbEmpty() throws CdmSourceException {

		return databaseService.isDbEmpty();

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.config.CdmSource#checkConnection()

	 */

	@Override

	public boolean checkConnection() throws CdmSourceException {

		// assuming that database service works implies 

		// the connection is up

		// if no exception is thrown then we assume that the 

		// connection is up

		// FIXME:Remoting is this really correct?

		databaseService.getDbSchemaVersion();

		return true;

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.config.CdmSource#getConnectionMessage()

	 */

	@Override

	public String getConnectionMessage() {

		return "Conncting to Remote CDM Server " + getName();

	}

	@Override

	public Map<MetaDataPropertyName, String> getMetaDataMap() throws CdmSourceException {

		return databaseService.getCdmMetadataMap();

	}

}

/**

 * 

 */

package eu.etaxonomy.cdm.remote;

/**

 * 

 *

 */

public class CdmRemoteSourceException extends Exception {

	public CdmRemoteSourceException(String message) {

		super(message);

	}

	public CdmRemoteSourceException(Exception e) {

		super(e);

	}

}

/**

* Copyright (C) 2014 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.cdm.remote;

import eu.etaxonomy.cdm.config.ICdmSource;

/**

 * Interface representing a CDM remote source

 *

 */

public interface ICdmRemoteSource extends ICdmSource {

	/**

	 * Gets the context path.

	 * e.g. for 'http://127.0.0.1:8080/col/remoting/common.service', the 

	 * context path would be 'col'

	 */

	public String getContextPath();

	/**

	 * Gets the base url for the http-invoker services as listed in 

	 * httpInvokerServicesClients.xml.

	 * e.g. for 'http://127.0.0.1:8080/col/remoting/common.service', the 

	 * base url would be 'http://127.0.0.1:8080/col'

	 */

	public String getBaseUrl();	

}

/*

 * Hibernate, Relational Persistence for Idiomatic Java

 *

 * Copyright (c) 2008-2011, Red Hat Inc. or third-party contributors as

 * indicated by the @author tags or express copyright attribution

 * statements applied by the authors.  All third-party contributions are

 * distributed under license by Red Hat Inc.

 *

 * This copyrighted material is made available to anyone wishing to use, modify,

 * copy, or redistribute it subject to the terms and conditions of the GNU

 * Lesser General Public License, as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY

 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License

 * for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with this distribution; if not, write to:

 * Free Software Foundation, Inc.

 * 51 Franklin Street, Fifth Floor

 * Boston, MA  02110-1301  USA

 */

package org.hibernate.collection.internal;

import java.io.Serializable;

import java.lang.reflect.Field;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.ListIterator;

import java.util.Map;

import java.util.Set;

import java.util.TreeMap;

import java.util.TreeSet;

import javax.naming.NamingException;

import org.hibernate.AssertionFailure;

import org.hibernate.HibernateException;

import org.hibernate.LazyInitializationException;

import org.hibernate.Session;

import org.hibernate.collection.spi.PersistentCollection;

import org.hibernate.engine.internal.ForeignKeys;

import org.hibernate.engine.spi.CollectionEntry;

import org.hibernate.engine.spi.EntityEntry;

import org.hibernate.engine.spi.SessionFactoryImplementor;

import org.hibernate.engine.spi.SessionImplementor;

import org.hibernate.engine.spi.Status;

import org.hibernate.engine.spi.TypedValue;

import org.hibernate.internal.SessionFactoryRegistry;

import org.hibernate.internal.util.MarkerObject;

import org.hibernate.internal.util.collections.EmptyIterator;

import org.hibernate.internal.util.collections.IdentitySet;

import org.hibernate.persister.collection.CollectionPersister;

import org.hibernate.persister.entity.EntityPersister;

import org.hibernate.pretty.MessageHelper;

import org.hibernate.type.Type;

import org.jboss.logging.Logger;

import eu.etaxonomy.cdm.api.application.CdmApplicationRemoteController;

import eu.etaxonomy.cdm.api.application.ICdmApplicationConfiguration;

import eu.etaxonomy.cdm.api.service.ICommonService;

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

/**

 * Base class implementing {@link org.hibernate.collection.spi.PersistentCollection}

 *

 * @author Gavin King

 */

public abstract class AbstractPersistentCollection implements Serializable, PersistentCollection {

	private static final Logger log = Logger.getLogger( AbstractPersistentCollection.class );

	private static final long serialVersionUID = -7238232378593030571L;

	private transient SessionImplementor session;

	private boolean initialized;

	private transient List<DelayedOperation> operationQueue;

	private transient boolean directlyAccessible;

	private transient boolean initializing;

	private Object owner;

	private int cachedSize = -1;

	private String role;

	private Serializable key;

	// collections detect changes made via their public interface and mark

	// themselves as dirty as a performance optimization

	private boolean dirty;

	private Serializable storedSnapshot;

	private String sessionFactoryUuid;

	private boolean specjLazyLoad = false;

	public final String getRole() {

		return role;

	}

	public final Serializable getKey() {

		return key;

	}

	public final boolean isUnreferenced() {

		return role == null;

	}

	public final boolean isDirty() {

		return dirty;

	}

	public final void clearDirty() {

		dirty = false;

	}

	public final void dirty() {

		dirty = true;

	}

	public final Serializable getStoredSnapshot() {

		return storedSnapshot;

	}

	//Careful: these methods do not initialize the collection.

	/**

	 * Is the initialized collection empty?

	 */

	public abstract boolean empty();

	/**

	 * Called by any read-only method of the collection interface

	 */

	protected final void read() {

		initialize( false );

	}

	/**

	 * Called by the {@link Collection#size} method

	 */

	@SuppressWarnings({"JavaDoc"})

	protected boolean readSize() {

		if ( !initialized ) {

			if ( cachedSize != -1 && !hasQueuedOperations() ) {

				return true;

			}

			else {

				// In remoting we are sure that session is null

				// both when using property paths and switching off conversations

				if(session == null && remoting) {				

					log.info("--> readSize, of " + getRole() + " with key " + getKey());

					read();								

				} else {

					boolean isExtraLazy = withTemporarySessionIfNeeded(

							new LazyInitializationWork<Boolean>() {

								@Override

								public Boolean doWork() {

									CollectionEntry entry = session.getPersistenceContext().getCollectionEntry( AbstractPersistentCollection.this );

									if ( entry != null ) {

										CollectionPersister persister = entry.getLoadedPersister();

										if ( persister.isExtraLazy() ) {

											if ( hasQueuedOperations() ) {

												session.flush();

											}

											cachedSize = persister.getSize( entry.getLoadedKey(), session );

											return true;

										}

										else {

											read();

										}

									}

									else{

										throwLazyInitializationExceptionIfNotConnected();

									}

									return false;

								}

							}

							);

					if ( isExtraLazy ) {

						return true;

					}

				}

			}

		}

		return false;

	}

	public static interface LazyInitializationWork<T> {

		public T doWork();

	}

	private <T> T withTemporarySessionIfNeeded(LazyInitializationWork<T> lazyInitializationWork) {

		SessionImplementor originalSession = null;

		boolean isTempSession = false;

		boolean isJTA = false;

		if ( session == null ) {

			if ( specjLazyLoad ) {

				session = openTemporarySessionForLoading();

				isTempSession = true;

			}

			else {

				throwLazyInitializationException( "could not initialize proxy - no Session" );

			}

		}

		else if ( !session.isOpen() ) {