EDIT

    public static CdmApplicationRemoteController NewInstance(Resource applicationContextResource,

            ICdmRemoteSource remoteSource,

            boolean omitTermLoading,

            IProgressMonitor progressMonitor,

            List<ApplicationListener> listeners) {

        return new CdmApplicationRemoteController(applicationContextResource,

                remoteSource,

                omitTermLoading,

                progressMonitor,

                listeners);

    }

            boolean omitTermLoading,

                omitTermLoading,

            boolean omitTermLoading,

        setNewRemoteSource(remoteSource, omitTermLoading, listeners);

    protected boolean setNewRemoteSource(ICdmRemoteSource remoteSource,

            boolean omitTermLoading,

        GenericApplicationContext applicationContext

            = generateApplicationContext(remoteSource, applicationContextResource, listeners, progressMonitor, false);

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

        applicationContext.refresh();

        applicationContext.start();

        progressMonitor.subTask("Cleaning up.");

        setApplicationContext(applicationContext);

        progressMonitor.worked(1);

        progressMonitor.done();

        return true;

    }

    public static GenericApplicationContext generateApplicationContext(ICdmRemoteSource remoteSource,

            Resource applicationContextResource,

            List<ApplicationListener> listeners,

            IProgressMonitor progressMonitor,

            boolean validateXml) {

        RemotingMonitoredGenericApplicationContext applicationContext =  new RemotingMonitoredGenericApplicationContext();

        int refreshTasks = 45;

        int nTasks = 5 + refreshTasks;

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

        applicationContext.getEnvironment().setActiveProfiles("remoting");

        progressMonitor.worked(1);

            xmlReader.setValidationMode(XmlBeanDefinitionReader.VALIDATION_NONE);

        progressMonitor.subTask("Registering resources.");

        progressMonitor.worked(1);

        return applicationContext;

// $Id$

/**

* Copyright (C) 2009 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.io.Serializable;

import org.apache.log4j.Logger;

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

import org.springframework.beans.factory.support.DefaultListableBeanFactory;

import org.springframework.context.support.GenericApplicationContext;

import org.springframework.core.LocalVariableTableParameterNameDiscoverer;

/**

 * {@link GenericApplicationContext Generic application context} which allows progress monitoring.

 * @author a.mueller

 * @date 29.09.2011

 *

 */

public class RemotingMonitoredGenericApplicationContext extends GenericApplicationContext implements Serializable {

    @SuppressWarnings("unused")

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

    final int countInvokeBeanFactoryPostProcessors = 10;

    final int countFinishBeanFactoryInitialization = 90;

    private final int countTasks = countInvokeBeanFactoryPostProcessors + countFinishBeanFactoryInitialization;

   // private IProgressMonitor currentMonitor;

    /**

     * Constructor.

     * @param progressMonitor

     */

//    public RemotingMonitoredGenericApplicationContext() {

////		MonitoredListableBeanFactory beanFactory =

//        super(new RemotingMonitoredListableBeanFactory());

//        //taken from empty constructor of GenericApplicationContext

//        ((RemotingMonitoredListableBeanFactory)getBeanFactory()).setSerializationId(getId());

//        ((RemotingMonitoredListableBeanFactory)getBeanFactory()).setParameterNameDiscoverer(new LocalVariableTableParameterNameDiscoverer());

//        ((RemotingMonitoredListableBeanFactory)getBeanFactory()).setAutowireCandidateResolver(new QualifierAnnotationAutowireCandidateResolver());

//    }

    public RemotingMonitoredGenericApplicationContext() {

//      MonitoredListableBeanFactory beanFactory =

        super();

        //taken from empty constructor of GenericApplicationContext

        ((DefaultListableBeanFactory)getBeanFactory()).setSerializationId(getId());

        ((DefaultListableBeanFactory)getBeanFactory()).setParameterNameDiscoverer(new LocalVariableTableParameterNameDiscoverer());

        ((DefaultListableBeanFactory)getBeanFactory()).setAutowireCandidateResolver(new QualifierAnnotationAutowireCandidateResolver());

    }

//    public int countTasks(){

//        return countTasks;

//    }

//

//    @Override

//    protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory){

//        String task = "Invoke bean factory post processors";

////        checkMonitorCancelled(currentMonitor);

////        currentMonitor.subTask(task);

//        super.invokeBeanFactoryPostProcessors(beanFactory);

////        currentMonitor.worked(countInvokeBeanFactoryPostProcessors);

////        checkMonitorCancelled(currentMonitor);

//    }

//

//    @Override

//    protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory){

////        checkMonitorCancelled(currentMonitor);

//        String task = "Finish bean factory initialization";

////        currentMonitor.subTask(task);

////        IProgressMonitor subMonitor	= new SubProgressMonitor(currentMonitor, countFinishBeanFactoryInitialization);

////        getMyBeanFactory().setCurrentMonitor(subMonitor);

//        super.finishBeanFactoryInitialization(beanFactory);

////        checkMonitorCancelled(currentMonitor);

//

//    }

//    /**

//     * @param progressMonitor the progressMonitor to set

//     */

//    public void setCurrentMonitor(IProgressMonitor monitor) {

////        this.currentMonitor = monitor;

//    }

//

//    /**

//     *

//     */

//    public IProgressMonitor getCurrentMonitor() {

////        return currentMonitor;

//        return null;

//    }

//    /* (non-Javadoc)

//     * @see org.springframework.context.support.AbstractApplicationContext#refresh()

//     */

//    @Override

//    public void refresh() throws BeansException, IllegalStateException {

//        //checkMonitorCancelled(monitor);

//        String message = "Refresh application context. This might take a while ...";

////        currentMonitor = monitor;

//        beginTask(message, countTasks);

//        super.refresh();

//        taskDone();

//        //checkMonitorCancelled(monitor);

//    }

    /**

     *

     */

//    private void taskDone() {

////        if (currentMonitor != null){

////            currentMonitor.done();

////        }

//    }

//    /**

//     * @param monitor

//     * @param message

//     */

//    private void beginTask(String message, int countTasks) {

////        if (currentMonitor != null){

////            currentMonitor.beginTask(message, countTasks);

////        }

//    }

//    private RemotingMonitoredListableBeanFactory getMyBeanFactory(){

//        return (RemotingMonitoredListableBeanFactory)getBeanFactory();

//    }

//

//

//    private void checkMonitorCancelled(IProgressMonitor monitor) {

//        if (monitor != null && monitor.isCanceled()){

//            throw new CancellationException();

//        }

//    }

}

// $Id$

/**

* Copyright (C) 2009 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.Arrays;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import java.util.concurrent.CancellationException;

import org.apache.log4j.Logger;

import org.springframework.beans.BeansException;

import org.springframework.beans.factory.support.DefaultListableBeanFactory;

import org.springframework.beans.factory.support.RootBeanDefinition;

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

/**

 * @author a.mueller

 * @date 29.09.2011

 *

 */

public class RemotingMonitoredListableBeanFactory extends DefaultListableBeanFactory {

	@SuppressWarnings("unused")

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

	private boolean isInitializingBeans = false;

	private IProgressMonitor currentMonitor;

	private static List<String> beansToMonitor = Arrays.asList("sessionFactory","defaultBeanInitializer","persistentTermInitializer");

	private final Set<String> alreadyMonitoredBeans = new HashSet<String>();

	public RemotingMonitoredListableBeanFactory(){

	}

//	@Override

//	protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {

//		if (registeredBeanNames.contains(beanName)){

//			return super.getMergedLocalBeanDefinition(beanName);

//

//		}

////		String message = "Handle bean '%s'";

////		message = String.format(message, beanName);

////		currentMonitor.subTask(message);

//		RootBeanDefinition result = super.getMergedLocalBeanDefinition(beanName);

////		currentMonitor.worked(1);

////		registeredBeanNames.add(beanName);

//		return result;

//	}

	@Override

    public void preInstantiateSingletons() throws BeansException {

		isInitializingBeans = true;

		checkMonitorCancelled(currentMonitor);

		int countBeans = 0;

		for (String beanName : getBeanDefinitionNames()) {

			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);

			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit() && beansToMonitor.contains(beanName) ){

				countBeans++;

			}

		}

		String message = "preinstantiate singletons";

		currentMonitor.beginTask(message, countBeans);

		super.preInstantiateSingletons();

		isInitializingBeans = false;

		currentMonitor.done();

	}

//	protected <T> T doGetBean(final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly){

//		boolean doMonitor = isInitializingBeans && !monitoredBeanNames.contains(name);

//		if (doMonitor){

//			String message = "Handle bean '%s'";

//			message = String.format(message, name);

//			currentMonitor.subTask(message);

//			monitoredBeanNames.add(name);

//		}

//		T result = super.doGetBean(name, requiredType, args, typeCheckOnly);

//		if (doMonitor){

//			currentMonitor.worked(1);

//		}

//		return result;

//	}

	@Override

    protected Object createBean(final String name, final RootBeanDefinition mbd, final Object[] args){

		boolean doMonitor = isInitializingBeans && beansToMonitor.contains(name) && !alreadyMonitoredBeans.contains(name);

		checkMonitorCancelled(currentMonitor);

		if (doMonitor){

			String message;

			if (name.equals("sessionFactory")){

				message = "Initializing persistence context ...";

			}else if(name.equals("persistentTermInitializer")){

				message = "Loading terms ...";

			}else{

				message = "Handling '%s'";

				message = String.format(message, name);

			}

			currentMonitor.subTask(message);

			alreadyMonitoredBeans.add(name);

		}

		Object result = super.createBean(name, mbd, args);

		if (doMonitor){

			checkMonitorCancelled(currentMonitor);

			currentMonitor.worked(1);

		}

		return result;

	}

	/**

	 * @param mainMonitor the mainMonitor to set

	 */

	public void setCurrentMonitor(IProgressMonitor monitor) {

		this.currentMonitor = monitor;

	}

	private void checkMonitorCancelled(IProgressMonitor monitor) {

		if (monitor != null && monitor.isCanceled()){

			throw new CancellationException();

		}

	}

}

	public void cacheGetters() {

		Configuration configuration = new Configuration().configure("/eu/etaxonomy/cdm/mappings/hibernate.cfg.xml");

		configuration.buildMappings();

		Iterator<PersistentClass> classMappingIterator = configuration.getClassMappings();

		Cache cache = CdmRemoteCacheManager.getInstance().getCdmModelGetMethodsCache();

		cache.removeAll();

		while(classMappingIterator.hasNext()) {

			PersistentClass persistentClass = classMappingIterator.next();

			Class mappedClass = persistentClass.getMappedClass();

			String mappedClassName = mappedClass.getName();

			CdmModelFieldPropertyFromClass cmgmfc = new CdmModelFieldPropertyFromClass(mappedClassName);

			Iterator propertyIt = persistentClass.getPropertyIterator();

			logger.info("Adding class : " + mappedClassName + " to cache");

			while(propertyIt.hasNext())

			{

				Property property = (Property)propertyIt.next();

				Getter getter = property.getGetter(mappedClass);

				if(getter != null && getter.getMember() != null) {

					Field field = (Field)getter.getMember();

					String getMethod = getMethodNameFromFieldName(field.getName(), field.getType().getName());

					logger.info(" - getMethod : " + getMethod + " for type " + field.getType().getName());

					cmgmfc.addGetMethods(getMethod);

				}

			}

			cache.put(new Element(mappedClassName, cmgmfc));

		}

		cache.flush();

	}

		cache.flush();

import java.io.File;

import eu.etaxonomy.cdm.common.CdmUtils;

    	System.setProperty("ehcache.disk.store.dir", CdmUtils.getCdmHomeDir().getAbsolutePath() + File.separator + "cdmlib-model");

			cdmlibModelCacheManager = new CacheManager(in);

//		} catch (IOException e) {

//			throw new CdmClientCacheException(e);

//		}

	public static void checkCacheProperties() {

		String pathToCache = System.getProperty("ehcache.disk.store.dir");

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

			throw new CdmClientCacheException("'ehcache.disk.store.dir' property is not set");

		}

	}

  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd

    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">

  <bean id="agentService" 

  <bean id="annotationService"

  <bean id="auditeventService"

  <bean id="classificationService"

  <bean id="collectionService"

  <bean id="commonService"

  <bean id="descriptionService"

  <bean id="editGeoService"

  <bean id="featureNodeService"

  <bean id="featureTreeService"

  <bean id="groupService"

  <bean id="identificationKeyService"

  <bean id="locationService"

  <bean id="markerService"

  <bean id="mediaService"

  <bean id="nameService"

  <bean id="occurrenceService"

  <bean id="polytomousKeyNodeService"

  <bean id="polytomousKeyService"

  <bean id="referenceService"

  <bean id="taxonNodeService"

  <bean id="taxonService"

  <bean id="termService"

  <bean id="userService"

  <bean id="vocabularyService"

  <bean id="workingSetService"

  <bean id="grantedAuthorityService"

  <bean id="databaseService"

  <bean id="lsidAuthorityService"

  <bean id="lsidMetadataService"

  <bean id="lsiDataService"

  <bean id="authenticationManager"

    class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">

    <property name="serviceUrl">

      <value>http://${remoteServer}:${remotePort}/${remoteContext}/remoting/authenticationManager.service</value>

    </property>

    <property name="serviceInterface">

      <value>org.springframework.security.authentication.AuthenticationManager

      </value>

    </property>

    <property name="httpInvokerRequestExecutor">

      <bean

        class="eu.etaxonomy.taxeditor.service.CdmServiceRequestExecutor" />

    </property>

  </bean>

  <bean id="primerService"

  <bean id="amplificationService"

  <bean id="sequenceService"

  <bean id="entityValidationService"

  <bean id="entityConstraintViolationService"

  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd

    http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context-2.5.xsd">

  <!-- <bean id="remoteTermInitializer" class="eu.etaxonomy.cdm.remote.service.RemoteTermInitializer"/> -->

  <!-- <context:component-scan base-package="eu/etaxonomy/taxeditor/session" 

    /> -->

  <bean id="cdmEntitySessionManager"  class="eu.etaxonomy.taxeditor.session.CdmEntitySessionManager" />

  <!-- <import resource="classpath:/eu/etaxonomy/cdm/remoting_services_security.xml" 

    /> -->

<!--   <context:component-scan base-package="eu.etaxonomy.taxeditor.service" /> -->

  <bean id="cdmServiceRequestExecutor"

    class="eu.etaxonomy.cdm.persistence.hibernate.permission.UnanimousBasedUnrevokable">

  <bean id="cdmPermissionEvaluator"

  <bean id="securityHibernateInterceptor"

<!--   <bean id="authenticationManager" -->

<!--     class="org.springframework.security.authentication.ProviderManager"> -->

<!--     <property name="providers"> -->

<!--       <list> -->

<!--         <ref local="daoAuthenticationProvider" /> -->

<!--       </list> -->

<!--     </property> -->

<!--   </bean> -->

<!--   <bean id="daoAuthenticationProvider" -->

<!--     class="org.springframework.security.authentication.dao.DaoAuthenticationProvider"> -->

<!--     <property name="userDetailsService" ref="userService" /> -->

<!--     <property name="saltSource" ref="saltSource" /> -->

<!--     <property name="passwordEncoder" ref="passwordEncoder" /> -->

<!--   </bean> -->

<!--   <bean id="passwordEncoder" -->

<!--     class="org.springframework.security.authentication.encoding.Md5PasswordEncoder" /> -->

<!--   <bean id="saltSource" -->

<!--     class="org.springframework.security.authentication.dao.ReflectionSaltSource"> -->

<!--     <property name="userPropertyToUse" value="getUsername" /> -->

<!--   </bean> -->

  <context:component-scan base-package="eu.etaxonomy.cdm.api.cache">

    <!-- FIXME:Remoting Temp workaround to make remoting work -->

    <context:exclude-filter type="regex"

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

  </context:component-scan>

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"

  xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"

  xsi:schemaLocation="http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans-3.2.xsd

    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd

    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd

    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd

    ">

    <!--

      ============================== SECURITY ==============================

    -->

    <bean id="accessDecisionManager" class="eu.etaxonomy.cdm.persistence.hibernate.permission.UnanimousBasedUnrevokable">

        <property name="decisionVoters">

            <list>

                <bean class="eu.etaxonomy.cdm.persistence.hibernate.permission.voter.GrantAlwaysVoter" />

                <bean class="eu.etaxonomy.cdm.persistence.hibernate.permission.voter.TaxonNodeVoter" />

                <bean class="eu.etaxonomy.cdm.persistence.hibernate.permission.voter.TaxonBaseVoter" />

                <bean class="eu.etaxonomy.cdm.persistence.hibernate.permission.voter.DescriptionBaseVoter" />

                <bean class="eu.etaxonomy.cdm.persistence.hibernate.permission.voter.DescriptionElementVoter" />

            </list>

        </property>

    </bean>

    <!--

        CdmPermissionEvaluator.hasPermissions() evaluates the CdmPermissions like TAXONNODE.UPDATE{20c8f083-5870-4cbd-bf56-c5b2b98ab6a7}

    -->

    <bean id="cdmPermissionEvaluator" class="eu.etaxonomy.cdm.persistence.hibernate.permission.CdmPermissionEvaluator">

        <property name="accessDecisionManager" ref="accessDecisionManager" />

    </bean>

    <!-- The CdmSecurityHibernateInterceptor checks onSave() and on flushDirty() if the currently authenticated principal or token  has

    sufficient permissions on the entity to be persisted -->

    <bean id="securityHibernateInterceptor" class="eu.etaxonomy.cdm.persistence.hibernate.CdmSecurityHibernateInterceptor">

        <property name="permissionEvaluator" ref="cdmPermissionEvaluator" />

    </bean>

</beans>

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

  xmlns:context="http://www.springframework.org/schema/context"

  xmlns:security="http://www.springframework.org/schema/security"

  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd

    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd

    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd

    http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.1.xsd"

    >

    <import resource="classpath:/eu/etaxonomy/cdm/remoting_persistence_security.xml"/>

    <!--

        ======================================================================

          security specific configuration

        ======================================================================

     -->

<!--     <security:global-method-security pre-post-annotations="enabled" run-as-manager-ref="runAsManager" > -->

<!--         <security:expression-handler ref="expressionHandler" /> -->

<!--     </security:global-method-security> -->

    <!--

        To use "hasPermission()" in the Spring EL method annotations like @PreAuthorize we explicitly configure the permissionEvaluator

        the cdmPermissionEvaluator is already defined in the persistence security context

    -->

<!--     <bean id="expressionHandler" class="org.springframework.security.access.expression.method.DefaultMethodSecurityExpressionHandler"> -->

<!--         <property name="permissionEvaluator" ref="cdmPermissionEvaluator" /> -->

<!--     </bean> -->

    <bean id="authenticationManager" class="org.springframework.security.authentication.ProviderManager">

        <property name="providers">

            <list>

                <ref local="daoAuthenticationProvider"/>

            </list>

        </property>

    </bean>

    <bean id="daoAuthenticationProvider" class="org.springframework.security.authentication.dao.DaoAuthenticationProvider">

        <property name="userDetailsService" ref="userService"/>

        <property name="saltSource" ref="saltSource"/>

        <property name="passwordEncoder" ref="passwordEncoder"/>

    </bean>

    <bean id="passwordEncoder" class="org.springframework.security.authentication.encoding.Md5PasswordEncoder"/>

    <bean id="saltSource" class="org.springframework.security.authentication.dao.ReflectionSaltSource">

        <property name="userPropertyToUse" value="getUsername"/>

    </bean>

    <!--

        Run-As Authentication Replacement for system operations

        as e.g. performed by the eu.etaxonomy.cdm.api.application.FirstDataInserter

        the key must match FirstDataInserter.RUN_AS_KEY

     -->

<!--     <bean id="runAsManager" -->

<!--         class="org.springframework.security.access.intercept.RunAsManagerImpl"> -->

<!--       <property name="key" value="TtlCx3pgKC4l"/> -->

<!--     </bean> -->

</beans>

import org.springframework.security.authentication.ProviderManager;

    public ProviderManager getAuthenticationManager() {

import org.springframework.security.authentication.ProviderManager;

	private static UseObjectStore useObjectInitializer = new UseObjectStore(); 

	public static ProviderManager getAuthenticationManager() {

							false,

* 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.

*/

public class CdmApplicationRemoteControllerTest {

import eu.etaxonomy.taxeditor.session.ICdmEntitySessionManager;

                        false,