<project name="Eclipse Persistence Services JPA WLS CacheCoordination Testing" basedir=".">

    <property name="env" environment="env" value="env"/>

    <!-- Allows a user to overide certain user specific properties. -->

    <property name="eclipselink.jpa.test" value="."/>

    <property file="${eclipselink.jpa.test}/build.properties"/>

    <property file="${user.home}/weblogic.properties"/>

        <property file="test.properties"/>

<!-- *********** CacheCoordination Test Targets -->

    <target name="weblogic-start-cachecoordination">

      <ant antfile="${eclipselink.jpa.test}/cachecoordination_${server.name}.xml" target="${server.name}-start-cachecoordination" inheritRefs="true"/>

    </target>

    <target name="weblogic-run-test-cachecoordination">       

       <antcall target="build-deploy-cachecoordination-wls"/>

       <antcall target="runclient-cachecoordination-wls"/>

       	<!--antcall target="generate-report" inheritRefs="true"/-->

		<ant antfile="${eclipselink.jpa.test}/build.xml" target="generate-report" inheritRefs="true"/>

	<antcall target="server-undeploy-cachecoordination-server2" inheritRefs="true">

            <param name="application.name" value="eclipselink-sessionbean-model-server2"/>

        </antcall>	

	<antcall target="server-undeploy-cachecoordination-server1" inheritRefs="true">

            <param name="application.name" value="eclipselink-sessionbean-model-server1"/>

        </antcall>	

	<ant antfile="${eclipselink.jpa.test}/cachecoordination_${server.name}.xml" target="${server.name}-stop-cachecoordination" inheritRefs="true"/>	

	<delete includeEmptyDirs="true" failonerror="false">

            <fileset dir="${weblogic.domain}/servers/server2/tmp"/>

            <fileset dir="${weblogic.domain}/servers/server1/tmp"/>

	    <fileset dir="${weblogic.domain}/servers/myserver/tmp"/>

	</delete> 	

    </target>

    <target name="build-deploy-cachecoordination-wls">

       <sequential>

        <antcall target="cachecoordination-build-and-deploy-server1" inheritRefs="true">

            <param name="PERSISTENCE_UNIT_NAME" value="sessionbean"/>

            <param name="MODEL_DIR" value="org/eclipse/persistence/testing/models/jpa/sessionbean"/>

            <param name="MODEL_DIR2" value="org/eclipse/persistence/testing/models/jpa/fieldaccess/advanced"/>

            <param name="MODEL_NAME" value="eclipselink-sessionbean-model"/>

            <param name="TEST_DIR" value="org/eclipse/persistence/testing/tests/jpa/sessionbean"/>

            <param name="TEST_NAME" value="eclipselink-sessionbean-model"/>

            <param name="EAR_NAME" value="eclipselink-sessionbean-model-server1"/>

            <param name="TEST_SUITE" value="org.eclipse.persistence.testing.tests.jpa.sessionbean.SessionBeanTestsRCM"/>

            <param name="eclipselink.jpa.test.dir" value="."/>

        </antcall>

	<antcall target="cachecoordination-build-and-deploy-server2" inheritRefs="true">

            <param name="PERSISTENCE_UNIT_NAME" value="sessionbean"/>

            <param name="MODEL_DIR" value="org/eclipse/persistence/testing/models/jpa/sessionbean"/>

            <param name="MODEL_DIR2" value="org/eclipse/persistence/testing/models/jpa/fieldaccess/advanced"/>

            <param name="MODEL_NAME" value="eclipselink-sessionbean-model"/>

            <param name="TEST_DIR" value="org/eclipse/persistence/testing/tests/jpa/sessionbean"/>

            <param name="TEST_NAME" value="eclipselink-sessionbean-model"/>

            <param name="EAR_NAME" value="eclipselink-sessionbean-model-server2"/>

            <param name="TEST_SUITE" value="org.eclipse.persistence.testing.tests.jpa.sessionbean.SessionBeanTestsRCM"/>

            <param name="eclipselink.jpa.test.dir" value="."/>

        </antcall>	

	</sequential>

    </target>

      <target name="runclient-cachecoordination-wls">

       	<antcall target="server-run-test-cachecoordination" inheritRefs="true">

            <param name="PERSISTENCE_UNIT_NAME" value="sessionbean"/>

            <param name="MODEL_DIR" value="org/eclipse/persistence/testing/models/jpa/sessionbean"/>

            <param name="MODEL_DIR2" value="org/eclipse/persistence/testing/models/jpa/fieldaccess/advanced"/>

            <param name="MODEL_NAME" value="eclipselink-sessionbean-model"/>

            <param name="TEST_DIR" value="org/eclipse/persistence/testing/tests/jpa/sessionbean"/>

            <param name="TEST_NAME" value="eclipselink-sessionbean-model"/>

            <param name="EAR_NAME" value="eclipselink-sessionbean-model-server2"/>

            <param name="TEST_SUITE" value="org.eclipse.persistence.testing.tests.jpa.sessionbean.SessionBeanTestsRCM"/>

            <param name="eclipselink.jpa.test.dir" value="."/>

        </antcall>

    </target>

    <target name="set-app-name-cachecoordination">

        <property name="APP_NAME" value="${MODEL_NAME}"/>

        <property name="DS_NAME" value="jdbc/EclipseLinkDS"/>

    </target>

        <!-- Build and deploy to Server1 -->

    <target name="cachecoordination-build-and-deploy-server1" depends="set-app-name-cachecoordination">

	    <copy overwrite="true" file="${eclipselink.jpa.test}/persistence.xml" tofile="${eclipselink.jpa.test}/${resource.dir}/server/persistence.xml"/>

        <copy overwrite="true" file="${eclipselink.jpa.test}/JPASessionCustomizer_${cachecoordination.protocol}_server1.java" 

          tofile="${eclipselink.jpa.test}/${src.dir}/org/eclipse/persistence/testing/models/jpa/sessionbean/JPASessionCustomizer.java" />

	<ant antfile="${eclipselink.jpa.test}/build.xml" target="server-build" inheritRefs="true"/>

        <antcall target="server-deploy-cachecoordination-server1" inheritRefs="true">

            <param name="ear.name" value="${EAR_NAME}.ear"/>

            <param name="application.name" value="${EAR_NAME}"/>

        </antcall>	

    </target>

    <target name="cachecoordination-build-and-deploy-server2" depends="set-app-name-cachecoordination">

        <copy overwrite="true" file="${eclipselink.jpa.test}/JPASessionCustomizer_${cachecoordination.protocol}_server2.java" 

          tofile="${eclipselink.jpa.test}/${src.dir}/org/eclipse/persistence/testing/models/jpa/sessionbean/JPASessionCustomizer.java" />

	<ant antfile="${eclipselink.jpa.test}/build.xml" target="server-build" inheritRefs="true"/>

        <antcall target="server-deploy-cachecoordination-server2" inheritRefs="true">

            <param name="ear.name" value="${EAR_NAME}.ear"/>

            <param name="application.name" value="${EAR_NAME}"/>

        </antcall>

    </target>    

    <target name="server-deploy-cachecoordination-server1">

        <ant antfile="${eclipselink.jpa.test}/cachecoordination_${server.name}.xml" target="${server.name}-deploy" inheritRefs="true">

            <property name="ear.name" value="${ear.name}"/>

            <property name="application.name" value="${application.name}"/>

	    <property name="target.server" value="server1"/>

        </ant>

    </target>

    <target name="server-deploy-cachecoordination-server2">

        <ant antfile="${eclipselink.jpa.test}/cachecoordination_${server.name}.xml" target="${server.name}-deploy" inheritRefs="true">

            <property name="ear.name" value="${ear.name}"/>

            <property name="application.name" value="${application.name}"/>

	    <property name="target.server" value="server2"/>

        </ant>

    </target>    

    <target name="server-undeploy-cachecoordination-server1">

        <ant antfile="${eclipselink.jpa.test}/cachecoordination_${server.name}.xml" target="${server.name}-undeploy" inheritRefs="true">

            <property name="application.name" value="${application.name}"/>

	    <property name="target.server" value="server1"/>

        </ant>

    </target>

    <target name="server-undeploy-cachecoordination-server2">

        <ant antfile="${eclipselink.jpa.test}/cachecoordination_${server.name}.xml" target="${server.name}-undeploy" inheritRefs="true">

            <property name="application.name" value="${application.name}"/>

	    <property name="target.server" value="server2"/>

        </ant>

    </target>

    <target name="server-run-test-cachecoordination" depends="config-compile-path">

        <property file="${eclipselink.jpa.test}/cachecoordination.properties"/>

        <property file="${user.home}/${server.name}.properties"/>

        <property file="${eclipselink.jpa.test}/${server.name}.properties"/>

        <path id="run.path">

            <pathelement path="${eclipselink.jpa.test}/${build.dir}/${TEST_NAME}_client.jar"/>

            <pathelement path="${eclipselink.jpa.test}/${build.dir}/${MODEL_NAME}_ejb.jar"/>

            <fileset dir="${server.lib}" includes="${server.depend}"/>

            <path refid="compile.server.path"/>

        </path>

        <echo>Running test ${EAR_NAME} on ${server.name}</echo>

        <mkdir dir="${eclipselink.jpa.test}/${report.dir}"/>

        <junit printsummary="yes" haltonfailure="yes" failureproperty="junit.failed" fork="yes" showoutput="true" maxmemory="256m" dir="${run.dir}">

            <sysproperty key="server.platform" value="${server.platform}"/>

            <sysproperty key="server.user" value="${server.user}"/>

            <sysproperty key="server.password" value="${server.pwd}"/>

            <sysproperty key="server.url" value="${server2.url}${MODEL_NAME}"/>

            <sysproperty key="server.testrunner" value="${server.testrunner}"/>

            <sysproperty key="server.run" value="TRUE"/>

            <classpath refid="run.path"/>

            <formatter type="xml"/>

            <test name="${TEST_SUITE}" haltonfailure="no" outfile="${report.dir}/${TEST_SUITE}-test-results"/>

        </junit>

    </target>

    <target name="config-compile-path">

        <path id="compile.path">

            <pathelement path="${eclipselink.core.dir}/${classes.dir}"/>

            <pathelement path="${eclipselink.jpa}/${classes.dir}"/>

            <pathelement path="${eclipselink.core.test.dir}/${classes.dir}"/>

            <pathelement path="${eclipselink.core.test.dir}/${eclipselink.tests.jar}"/>

            <fileset dir="${eclipselink.jpa}/../${plugins.dir}"

                includes="${eclipselink.jpa.depend}"/>

            <fileset

                dir="${eclipselink.core.lib.dir}"

                includes="${eclipselink.core.depend}"/>

            <pathelement path="${eclipselink.moxy.dir}/${classes.dir}"/>

            <fileset

                dir="${eclipselink.moxy.lib.dir}"

                includes="${eclipselink.moxy.depend}"/>

            <pathelement path="${eclipselink.jar.name}"/>

            <pathelement path="${junit.lib}"/>

            <pathelement path="${eclipselink.plugins}/${antlr}"/>

            <pathelement path="${eclipselink.plugins}/${asm}"/>

        </path>

        <path id="compile.server.path">

            <path refid="compile.path"/>

            <pathelement path="${jdbc.driver.jar}"/>

        </path>

    </target>

</project>

<!--/*******************************************************************************

* This program and the accompanying materials are made available under the 

* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 

* which accompanies this distribution. 

* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html

* and the Eclipse Distribution License is available at 

* http://www.eclipse.org/org/documents/edl-v10.php.

*

*   Ant naming conventions:

*   - regardless of the actual OS platform,'/' is the directory separator

*     (Ant will convert as appropriate).

*   - multi-word properties use periods '.'

*   - multi-word targets use hyphens '-' 

*   - multi-word macros use underscores '_'

*   - multi-word macro attributes are concatinated

*     e.g. 'runpathref'  

*   - multi-word tasks (taskdef) names are concatinated

*     e.g. 'validateconnection'

*   - OS environment variables are in ALLCAPS and have 'env' as a prefix

*     e.g. ${env.XXX}.

*   - Ant properties are lower case.

*

* Contributors:

*     pvijayar

#******************************************************************************/-->

<!-- This ant project includes the following tasks:

        ....

-->

<project name="Eclipse Persistence Services JPA WLS CacheCoordination Testing" basedir=".">

    <property name="env" environment="env" value="env"/>

    <!-- Allows a user to overide certain user specific properties. -->

    <property file="${user.home}/weblogic.properties"/>

    <property file="test.properties"/>

    <!-- WebLogic ant tasks -->

    <taskdef name="wlserver" classname="weblogic.ant.taskdefs.management.WLServer">

        <classpath>

            <pathelement location="${weblogic.home}/lib/weblogic.jar"/>

        </classpath>

    </taskdef>

    <taskdef name="wlconfig" classname="weblogic.ant.taskdefs.management.WLConfig">

        <classpath>

            <pathelement location="${weblogic.home}/lib/weblogic.jar"/>

        </classpath>

    </taskdef>

    <taskdef name="wldeploy" classname="weblogic.ant.taskdefs.management.WLDeploy">

        <classpath>

            <pathelement location="${weblogic.home}/lib/weblogic.jar"/>

        </classpath>

    </taskdef>

    <!-- Stop all servers. -->

    <target name="weblogic-stop-cachecoordination" depends="weblogic-stop-server3,weblogic-stop-server2,weblogic-stop-server1"/>

    <!-- Stop the managed server1 -->

    <target name="weblogic-stop-server1">

        <wlserver fork="true" failonerror="false" weblogichome="${weblogic.home}"

            dir="${weblogic.domain}" host="${weblogic.host}" domainname="mydomain" servername="server1" port="${cachecoordination.wls.server1.port}"

            username="${server.user}" password="${server.pwd}" action="shutdown">

        </wlserver>

    </target>

    <!-- Stop the managed server2 -->

    <target name="weblogic-stop-server2">

        <wlserver fork="true" failonerror="false" weblogichome="${weblogic.home}"

            dir="${weblogic.domain}" host="${weblogic.host}" domainname="mydomain" servername="server2" port="${cachecoordination.wls.server2.port}"

            username="${server.user}" password="${server.pwd}" action="shutdown">

        </wlserver>

    </target>

    <!-- Stop the admin server -->

    <target name="weblogic-stop-server3">

        <wlserver fork="true" failonerror="false" weblogichome="${weblogic.home}"

            dir="${weblogic.domain}" host="${weblogic.host}" domainname="mydomain" servername="server3" port="${cachecoordination.wls.server3.port}"

            username="${server.user}" password="${server.pwd}" action="shutdown">

        </wlserver>

    </target>

    <!--

        Deploy the application ear to the server.

        Note: WLS server must be running.

    -->

    <target name="weblogic-deploy">

        <wldeploy action="deploy"

            name="${application.name}" source="build/${ear.name}"

            user="${server.user}" password="${server.pwd}"

            adminurl="${server.url}" targets="${target.server}"

            failonerror="false">

        </wldeploy>

    </target>

    <!--

        Undeploy the application ear to the server.

        Note: WLS server must be running.

    -->

    <target name="weblogic-undeploy">

        <wldeploy action="undeploy" name="${application.name}"

            user="${server.user}" password="${server.pwd}"

            adminurl="${server.url}" targets="${target.server}"

            failonerror="false">

        </wldeploy>

    </target>

    <!-- initialize WL props for target 'run-cachecoordination-wls' -->

    <target name="init-wls">

		<property name="weblogic.domain" value="${weblogic.domain}"/>

		<property name="POLICY_OPTION" value="trackchanges"/>

		<path id="build.wls.path">

                 <pathelement path="${weblogic.home}/lib/weblogic.jar"/>

		         <pathelement path="${weblogic.home}/lib/wlclient.jar"/>

                 <pathelement path="${weblogic.domain}/lib/${eclipselink.jar.name}"/>

                 <pathelement path="${eclipselink.jpa.depend}"/>

		         <pathelement path="${junit.lib}"/>

		</path>

		<property name="SERVER_NAME" value="server1"/>

		<property name="SERVER_VERSION" value="10.3"/>

		<property name="is.wls" value="true"/>

    </target>

    <!-- Main target to run RCM-enabled Sessionbean tests.

         ** This target starts all servers on preconfigured domain and DataSource.

	 -->

    <target name="weblogic-start-cachecoordination" depends="init-wls">

        <delete file="${weblogic.domain}/edit.lok"/>

        <delete file="${cachecoordination.wls.server1.name}.log"/>

        <delete file="${cachecoordination.wls.server2.name}.log"/>

	<delete file="${cachecoordination.wls.server3.name}.log"/>

		<parallel>

			<echo message="*** starting WebLogic Server1 (also act as AdminServer)"/>

			<java classname="weblogic.Server" 

				fork="true"

				failonerror="true">

				<jvmarg value="-server"/>

						<jvmarg value="-Xms512m"/>

						<jvmarg value="-Xmx960m"/>

						<jvmarg value="-XX:MaxPermSize=256m"/>

				<env key="PATH" value="${env.JAVA_HOME}/bin:${env.PATH}"/>

				<sysproperty key="eclipselink.changePolicy" value="${POLICY_OPTION}"/>

				<sysproperty key="weblogic.Name" value="${weblogic.Name}"/>

				<sysproperty key="bea.home" value="${bea.root.dir}"/>

				<sysproperty key="weblogic.management.username" value="${server.user}"/>

				<sysproperty key="weblogic.management.password" value="${server.pwd}"/>

				<sysproperty key="java.security.police" value='"${weblogic.home}/lib/weblogic.policy"'/>

				<sysproperty key="weblogic.RootDirectory" value="${weblogic.domain}"/>

				<sysproperty key="weblogic.Stdout" value="${cachecoordination.wls.server1.name}.log"/>

				<sysproperty key="weblogic.Stderr" value="${cachecoordination.wls.server1.name}.err"/>

				<classpath refid="build.wls.path"/>

			</java>

			<sequential>

				<waitfor>

					<socket server="${cachecoordination.wls.server1.httphost}" port="${cachecoordination.wls.server1.port}"/>

				</waitfor>				

				<parallel>

				        <echo message="*** starting managed server: Server2 "/>

					<java classname="weblogic.Server" 

						fork="true"

						failonerror="true">

						<jvmarg value="-server"/>

						<jvmarg value="-Xms512m"/>

						<jvmarg value="-Xmx960m"/>

						<jvmarg value="-XX:MaxPermSize=256m"/>

						<env key="PATH" value="${env.JAVA_HOME}/bin:${env.PATH}"/>

						<sysproperty key="eclipselink.changePolicy" value="${POLICY_OPTION}"/>

						<sysproperty key="weblogic.Name" value="${cachecoordination.wls.server2.name}"/>

						<sysproperty key="bea.home" value="${bea.root.dir}"/>

						<sysproperty key="weblogic.management.server" value="${cachecoordination.wls.server1.httphost}:${cachecoordination.wls.server1.port}"/>

						<sysproperty key="weblogic.management.username" value="${server.user}"/>

						<sysproperty key="weblogic.management.password" value="${server.pwd}"/>

						<sysproperty key="java.security.police" value='"${weblogic.home}/lib/weblogic.policy"'/>

						<sysproperty key="weblogic.RootDirectory" value="${weblogic.domain}"/>

						<sysproperty key="weblogic.Stdout" value="${cachecoordination.wls.server2.name}.log"/>

						<sysproperty key="weblogic.Stderr" value="${cachecoordination.wls.server2.name}.err"/>

						<classpath refid="build.wls.path"/>

					</java>

					<echo message="*** starting managed server: Server3 "/>

					<java classname="weblogic.Server" 

						fork="true"

						failonerror="true">

						<jvmarg value="-server"/>

						<jvmarg value="-Xms512m"/>

						<jvmarg value="-Xmx960m"/>

						<jvmarg value="-XX:MaxPermSize=256m"/>

						<env key="PATH" value="${env.JAVA_HOME}/bin:${env.PATH}"/>

						<sysproperty key="eclipselink.changePolicy" value="${POLICY_OPTION}"/>

						<sysproperty key="weblogic.Name" value="${cachecoordination.wls.server3.name}"/>

						<sysproperty key="bea.home" value="${bea.root.dir}"/>

						<sysproperty key="weblogic.management.server" value="${cachecoordination.wls.server1.httphost}:${cachecoordination.wls.server1.port}"/>

						<sysproperty key="weblogic.management.username" value="${server.user}"/>

						<sysproperty key="weblogic.management.password" value="${server.pwd}"/>

						<sysproperty key="java.security.police" value='"${weblogic.home}/lib/weblogic.policy"'/>

						<sysproperty key="weblogic.RootDirectory" value="${weblogic.domain}"/>

						<sysproperty key="weblogic.Stdout" value="${cachecoordination.wls.server3.name}.log"/>

						<sysproperty key="weblogic.Stderr" value="${cachecoordination.wls.server3.name}.err"/>

						<classpath refid="build.wls.path"/>

					</java>

					<sequential>

						<waitfor>

							<and>

								<socket server="${cachecoordination.wls.server2.httphost}" port="${cachecoordination.wls.server2.port}"/>

								<socket server="${cachecoordination.wls.server3.httphost}" port="${cachecoordination.wls.server3.port}"/>

							</and>

						</waitfor>

						<sleep seconds="60"/>

					</sequential>

				</parallel>

			</sequential>

		</parallel>  

	</target>

</project>

package org.eclipse.persistence.testing.models.jpa.sessionbean;

import org.eclipse.persistence.config.SessionCustomizer;

import org.eclipse.persistence.sessions.Session;

import org.eclipse.persistence.sessions.DatabaseSession;

import org.eclipse.persistence.internal.sessions.DatabaseSessionImpl;

import org.eclipse.persistence.sessions.coordination.RemoteCommandManager;

import org.eclipse.persistence.sessions.coordination.TransportManager;

import org.eclipse.persistence.sessions.coordination.jms.JMSTopicTransportManager;

import java.io.*;

import java.util.*;

public class JPASessionCustomizer implements SessionCustomizer {

	    private String serverHost="localhost";   //server1 host name, which is also adminserver

        private String serverPort="7001";    //adminServer port

        private String wlsUserName="weblogic";

        private String wlsPassword="weblogic";

    public void customize(Session session) {

	    RemoteCommandManager rcm = new RemoteCommandManager((DatabaseSessionImpl)session);

        JMSTopicTransportManager tm = new JMSTopicTransportManager(rcm);

	    tm.setTopicHostUrl("t3://" + serverHost + ":" + serverPort);	  

	    tm.setTopicName("jms/TopLinkTopic");

	    tm.setTopicConnectionFactoryName("jms/TopLinkTopicConnectionFactory");

        tm.setUserName(wlsUserName);

	    tm.setPassword(wlsPassword);

	    rcm.setTransportManager(tm);

	    ((DatabaseSessionImpl)session).setName("Session1");

	    System.out.println("====the session name is " + session.getName());

	    rcm.setShouldPropagateAsynchronously(false);

	    rcm.getTransportManager().setNamingServiceType(TransportManager.JNDI_NAMING_SERVICE);

        rcm.getTransportManager().setInitialContextFactoryName("weblogic.jndi.WLInitialContextFactory");

	    rcm.getTransportManager().setShouldRemoveConnectionOnError(true);

        rcm.setServerPlatform(((org.eclipse.persistence.sessions.DatabaseSession)session).getServerPlatform());

	    ((DatabaseSessionImpl)session).setCommandManager(rcm);

	    ((DatabaseSessionImpl)session).setShouldPropagateChanges(true);

            rcm.initialize();

			// Sleep to allow RCM to startup and find each session.

            try {

                  Thread.sleep(2000);

            } catch (Exception ignore) {

            }

        }

}

package org.eclipse.persistence.testing.models.jpa.sessionbean;

import org.eclipse.persistence.config.SessionCustomizer;

import org.eclipse.persistence.sessions.Session;

import org.eclipse.persistence.sessions.DatabaseSession;

import org.eclipse.persistence.internal.sessions.DatabaseSessionImpl;

import org.eclipse.persistence.sessions.coordination.RemoteCommandManager;

import org.eclipse.persistence.sessions.coordination.TransportManager;

import org.eclipse.persistence.sessions.coordination.jms.JMSTopicTransportManager;

import java.io.*;

import java.util.*;

public class JPASessionCustomizer implements SessionCustomizer {

	    private String serverHost="localhost";   //server2 host name

        private String serverPort="7001";    //adminServer port

        private String wlsUserName="weblogic";

        private String wlsPassword="weblogic";

    public void customize(Session session) {

	    RemoteCommandManager rcm = new RemoteCommandManager((DatabaseSessionImpl)session);

        JMSTopicTransportManager tm = new JMSTopicTransportManager(rcm);

	    tm.setTopicHostUrl("t3://" + serverHost + ":" + serverPort);	  

	    tm.setTopicName("jms/TopLinkTopic");

	    tm.setTopicConnectionFactoryName("jms/TopLinkTopicConnectionFactory");

        tm.setUserName(wlsUserName);

	    tm.setPassword(wlsPassword);

	    rcm.setTransportManager(tm);

	    ((DatabaseSessionImpl)session).setName("Session2");

	    System.out.println("====the session name is " + session.getName());

	    rcm.setShouldPropagateAsynchronously(false);

	    rcm.getTransportManager().setNamingServiceType(TransportManager.JNDI_NAMING_SERVICE);

        rcm.getTransportManager().setInitialContextFactoryName("weblogic.jndi.WLInitialContextFactory");

	    rcm.getTransportManager().setShouldRemoveConnectionOnError(true);

        rcm.setServerPlatform(((org.eclipse.persistence.sessions.DatabaseSession)session).getServerPlatform());

	    ((DatabaseSessionImpl)session).setCommandManager(rcm);

	    ((DatabaseSessionImpl)session).setShouldPropagateChanges(true);

            rcm.initialize();

			// Sleep to allow RCM to startup and find each session.

            try {

                  Thread.sleep(2000);

            } catch (Exception ignore) {

            }

        }

}

package org.eclipse.persistence.testing.models.jpa.sessionbean;

import org.eclipse.persistence.config.SessionCustomizer;

import org.eclipse.persistence.sessions.Session;

import org.eclipse.persistence.sessions.DatabaseSession;

import org.eclipse.persistence.internal.sessions.DatabaseSessionImpl;

import org.eclipse.persistence.sessions.coordination.RemoteCommandManager;

import org.eclipse.persistence.sessions.coordination.TransportManager;

import org.eclipse.persistence.sessions.coordination.jms.JMSTopicTransportManager;

import java.io.*;

import java.util.*;

public class JPASessionCustomizer implements SessionCustomizer {

	    private String serverHost="localhost";   //server3 host name

        private String serverPort="7001";    //adminServer port

        private String wlsUserName="weblogic";

        private String wlsPassword="weblogic";

    public void customize(Session session) {

	    RemoteCommandManager rcm = new RemoteCommandManager((DatabaseSessionImpl)session);

            JMSTopicTransportManager tm = new JMSTopicTransportManager(rcm);

	    tm.setTopicHostUrl("t3://" + serverHost + ":" + serverPort);	  

	    tm.setTopicName("jms/TopLinkTopic");

	    tm.setTopicConnectionFactoryName("jms/TopLinkTopicConnectionFactory");

            tm.setUserName(wlsUserName);

	    tm.setPassword(wlsPassword);

	    rcm.setTransportManager(tm);

	    ((DatabaseSessionImpl)session).setName("Session3");

	    System.out.println("====the session name is " + session.getName());

	    rcm.setShouldPropagateAsynchronously(false);

	    rcm.getTransportManager().setNamingServiceType(TransportManager.JNDI_NAMING_SERVICE);

            rcm.getTransportManager().setInitialContextFactoryName("weblogic.jndi.WLInitialContextFactory");

	    rcm.getTransportManager().setShouldRemoveConnectionOnError(true);

            rcm.setServerPlatform(((org.eclipse.persistence.sessions.DatabaseSession)session).getServerPlatform());

	    ((DatabaseSessionImpl)session).setCommandManager(rcm);

	    ((DatabaseSessionImpl)session).setShouldPropagateChanges(true);

            rcm.initialize();

			// Sleep to allow RCM to startup and find each session.

            try {

                  Thread.sleep(2000);

            } catch (Exception ignore) {

            }

        }

}

package org.eclipse.persistence.testing.models.jpa.sessionbean;

import org.eclipse.persistence.config.SessionCustomizer;

import org.eclipse.persistence.sessions.Session;

import org.eclipse.persistence.sessions.DatabaseSession;

import org.eclipse.persistence.internal.sessions.DatabaseSessionImpl;

import org.eclipse.persistence.sessions.coordination.RemoteCommandManager;

import org.eclipse.persistence.sessions.coordination.TransportManager;

import java.io.*;

import java.util.*;

public class JPASessionCustomizer implements SessionCustomizer {

	private String serverHost="localhost";   //server1 (also adminserver)

        private String serverPort="7001";

        private String wlsUserName="weblogic";

        private String wlsPassword="weblogic";

    public void customize(Session session) {

	    RemoteCommandManager rcm = new RemoteCommandManager((DatabaseSessionImpl)session);

	    ((DatabaseSessionImpl)session).setName("Session1");

	    System.out.println("====the session name is " + session.getName());

            ((DatabaseSessionImpl)session).setShouldPropagateChanges(true);

            ((DatabaseSessionImpl)session).setCommandManager(rcm);

	    rcm.setShouldPropagateAsynchronously(false);

	    //discovery

	    //rcm.getDiscoveryManager().setAnnouncementDelay(0);

	   ((DatabaseSessionImpl)session).getCommandManager().getDiscoveryManager().setAnnouncementDelay(1000);

            ((DatabaseSessionImpl)session).getCommandManager().getDiscoveryManager().setMulticastGroupAddress("239.192.0.0");

            ((DatabaseSessionImpl)session).getCommandManager().getDiscoveryManager().setMulticastPort(3121);

           ((DatabaseSessionImpl)session).getCommandManager().getDiscoveryManager().setPacketTimeToLive(2);

            //jndi-naming-service

	    rcm.getTransportManager().setNamingServiceType(TransportManager.JNDI_NAMING_SERVICE);

	    rcm.setUrl("t3://" + serverHost + ":" + serverPort);

            rcm.getTransportManager().setUserName(wlsUserName);

	    rcm.getTransportManager().setPassword(wlsPassword);

            rcm.getTransportManager().setInitialContextFactoryName("weblogic.jndi.WLInitialContextFactory");

	    rcm.getTransportManager().setShouldRemoveConnectionOnError(true);

            rcm.setServerPlatform(((org.eclipse.persistence.sessions.DatabaseSession)session).getServerPlatform());

            rcm.initialize();

			// Sleep to allow RCM to startup and find each session.

            try {

                  Thread.sleep(2000);

            } catch (Exception ignore) {

            }

        }

}

package org.eclipse.persistence.testing.models.jpa.sessionbean;

import org.eclipse.persistence.config.SessionCustomizer;

import org.eclipse.persistence.sessions.Session;

import org.eclipse.persistence.sessions.DatabaseSession;

import org.eclipse.persistence.internal.sessions.DatabaseSessionImpl;

import org.eclipse.persistence.sessions.coordination.RemoteCommandManager;

import org.eclipse.persistence.sessions.coordination.TransportManager;

import java.io.*;

import java.util.*;

public class JPASessionCustomizer implements SessionCustomizer {

	private String serverHost="localhost";   //server1 (also adminserver)

        private String serverPort="7021";

        private String wlsUserName="weblogic";

        private String wlsPassword="weblogic";

    public void customize(Session session) {

	    RemoteCommandManager rcm = new RemoteCommandManager((DatabaseSessionImpl)session);

	    ((DatabaseSessionImpl)session).setName("Session2");

	    System.out.println("====the session name is " + session.getName());

            ((DatabaseSessionImpl)session).setShouldPropagateChanges(true);

            ((DatabaseSessionImpl)session).setCommandManager(rcm);

	    rcm.setShouldPropagateAsynchronously(false);

	    //discovery

	    //rcm.getDiscoveryManager().setAnnouncementDelay(0);

	   ((DatabaseSessionImpl)session).getCommandManager().getDiscoveryManager().setAnnouncementDelay(1000);

            ((DatabaseSessionImpl)session).getCommandManager().getDiscoveryManager().setMulticastGroupAddress("239.192.0.0");

            ((DatabaseSessionImpl)session).getCommandManager().getDiscoveryManager().setMulticastPort(3121);

           ((DatabaseSessionImpl)session).getCommandManager().getDiscoveryManager().setPacketTimeToLive(2);

            //jndi-naming-service

	    rcm.getTransportManager().setNamingServiceType(TransportManager.JNDI_NAMING_SERVICE);

	    rcm.setUrl("t3://" + serverHost + ":" + serverPort);

            rcm.getTransportManager().setUserName(wlsUserName);

	    rcm.getTransportManager().setPassword(wlsPassword);

            rcm.getTransportManager().setInitialContextFactoryName("weblogic.jndi.WLInitialContextFactory");

	    rcm.getTransportManager().setShouldRemoveConnectionOnError(true);

            rcm.setServerPlatform(((org.eclipse.persistence.sessions.DatabaseSession)session).getServerPlatform());

            rcm.initialize();

			// Sleep to allow RCM to startup and find each session.

            try {

                  Thread.sleep(2000);

            } catch (Exception ignore) {

            }

        }

}

package org.eclipse.persistence.testing.models.jpa.sessionbean;

import org.eclipse.persistence.config.SessionCustomizer;

import org.eclipse.persistence.sessions.Session;

import org.eclipse.persistence.sessions.DatabaseSession;

import org.eclipse.persistence.internal.sessions.DatabaseSessionImpl;

import org.eclipse.persistence.sessions.coordination.RemoteCommandManager;

import org.eclipse.persistence.sessions.coordination.TransportManager;

import java.io.*;

import java.util.*;

public class JPASessionCustomizer implements SessionCustomizer {

	private String serverHost="localhost";   //server1 (also adminserver)

        private String serverPort="7031";

        private String wlsUserName="weblogic";

        private String wlsPassword="weblogic";

    public void customize(Session session) {

	    RemoteCommandManager rcm = new RemoteCommandManager((DatabaseSessionImpl)session);

	    ((DatabaseSessionImpl)session).setName("Session3");

	    System.out.println("====the session name is " + session.getName());

            ((DatabaseSessionImpl)session).setShouldPropagateChanges(true);

            ((DatabaseSessionImpl)session).setCommandManager(rcm);

	    rcm.setShouldPropagateAsynchronously(false);

	    //discovery

	    //rcm.getDiscoveryManager().setAnnouncementDelay(0);

	   ((DatabaseSessionImpl)session).getCommandManager().getDiscoveryManager().setAnnouncementDelay(1000);

            ((DatabaseSessionImpl)session).getCommandManager().getDiscoveryManager().setMulticastGroupAddress("239.192.0.0");

            ((DatabaseSessionImpl)session).getCommandManager().getDiscoveryManager().setMulticastPort(3121);

           ((DatabaseSessionImpl)session).getCommandManager().getDiscoveryManager().setPacketTimeToLive(2);

            //jndi-naming-service

	    rcm.getTransportManager().setNamingServiceType(TransportManager.JNDI_NAMING_SERVICE);

	    rcm.setUrl("t3://" + serverHost + ":" + serverPort);

            rcm.getTransportManager().setUserName(wlsUserName);

	    rcm.getTransportManager().setPassword(wlsPassword);

            rcm.getTransportManager().setInitialContextFactoryName("weblogic.jndi.WLInitialContextFactory");

	    rcm.getTransportManager().setShouldRemoveConnectionOnError(true);

            rcm.setServerPlatform(((org.eclipse.persistence.sessions.DatabaseSession)session).getServerPlatform());

            rcm.initialize();

			// Sleep to allow RCM to startup and find each session.

            try {

                  Thread.sleep(2000);

            } catch (Exception ignore) {

            }

        }

}

<persistence xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence persistence_1_0.xsd" version="1.0">

    <persistence-unit name="%%default%%">

        <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>

        <jta-data-source>%%data-source-name%%</jta-data-source>

	<class>org.eclipse.persistence.testing.models.jpa.fieldaccess.advanced.Employee</class>

	<class>org.eclipse.persistence.testing.models.jpa.fieldaccess.advanced.Address</class>

        <properties>

	  <property name="eclipselink.session.customizer" value="org.eclipse.persistence.testing.models.jpa.sessionbean.JPASessionCustomizer"/>

            <property name="eclipselink.target-server" value="%%server-platform%%"/>

            <property name="eclipselink.validate-existence" value="true"/>

            <!--property name="eclipselink.logging.level" value="FINEST"/-->

        </properties>

    </persistence-unit>

</persistence>

    List findByFirstName(String fname);

    void delete(Employee employee);

    public List findByFirstName(String fname) {

        //NamedQuery("findAllFieldAccessEmployeesByFirstName")

        Query query = entityManager.createQuery("SELECT e FROM Employee e where e.firstName = :fname").setParameter("fname", fname);

	query.setHint("eclipselink.cache-usage", "CheckCacheOnly");

        return query.getResultList();

    }

   public void delete(Employee employee) {

         Employee emp = entityManager.find(Employee.class, employee.getId());       

        entityManager.remove(emp);

    }

/*******************************************************************************

 * Copyright (c) 1998, 2008 Oracle. All rights reserved.

 * This program and the accompanying materials are made available under the 

 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 

 * which accompanies this distribution. 

 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html

 * and the Eclipse Distribution License is available at 

 * http://www.eclipse.org/org/documents/edl-v10.php.

 *

 * Contributors:

 *     Oracle - initial API and implementation from Oracle TopLink

 ******************************************************************************/  

 package org.eclipse.persistence.testing.tests.jpa.sessionbean;

import java.util.Iterator;

import java.util.List;

import java.util.Properties;

import javax.naming.Context;

import javax.naming.InitialContext;

import javax.naming.NameNotFoundException;

import javax.rmi.PortableRemoteObject;

import junit.framework.*;

import org.eclipse.persistence.exceptions.ValidationException;

import org.eclipse.persistence.testing.framework.junit.JUnitTestCase;

import org.eclipse.persistence.testing.models.jpa.fieldaccess.advanced.Department;

import org.eclipse.persistence.testing.models.jpa.fieldaccess.advanced.Employee;

import org.eclipse.persistence.testing.models.jpa.fieldaccess.advanced.Address;

import org.eclipse.persistence.testing.models.jpa.fieldaccess.advanced.AdvancedTableCreator;

import org.eclipse.persistence.testing.models.jpa.sessionbean.EmployeeService;

import org.eclipse.persistence.expressions.Expression;

import org.eclipse.persistence.expressions.ExpressionBuilder;

import org.eclipse.persistence.queries.ReadObjectQuery;

/**

 * EJB 3 SessionBean tests.

 * Testing using EclipseLink JPA in a JEE EJB 3 SessionBean environment.

 * These tests can only be run with a server.

 */

public class SessionBeanTestsRCM extends JUnitTestCase {

    protected EmployeeService service;

	private String wlsUserName="weblogic";

	private String wlsPassword="weblogic";

	private String server1Url = "t3://localhost:7001";

	private String server2Url = "t3://localhost:7021";

	private String server3Url = "t3://localhost:7031";

	int empId = 0;

	private Employee employeeCached = null; 	

    public SessionBeanTestsRCM() {

        super();

    }

    public SessionBeanTestsRCM(String name) {

        super(name);

    }

    public SessionBeanTestsRCM(String name, boolean shouldRunTestOnServer) {

        super(name);

        this.shouldRunTestOnServer = shouldRunTestOnServer;

    }

    public static Test suite() {

        TestSuite suite = new TestSuite("SessionBeanTestsRCM");

	suite.addTest(new SessionBeanTestsRCM("testSetupRcmOnServer2", true));

	suite.addTest(new SessionBeanTestsRCM("testSetupForDeleteOnServer2", true));

	suite.addTest(new SessionBeanTestsRCM("testSetupRcmOnServer1", true));

	suite.addTest(new SessionBeanTestsRCM("testPerformDeleteOnServer1", true));

	//suite.addTest(new SessionBeanTestsRCM("testReadFromServer2AfterUpdateNonJPQL", true));

        suite.addTest(new SessionBeanTestsRCM("testConfirmUpdateOnServer2", true));

        suite.addTest(new SessionBeanTestsRCM("testConfirmDeleteOnServer2", true));

        return suite;

    }

    /**

     * The setup is done as a test, both to record its failure, and to alow execution in the server2.

     */

    public void testSetupRcmOnServer2() throws Exception {

	    new AdvancedTableCreator().replaceTables(JUnitTestCase.getServerSession("sessionbean"));

    }

    public EmployeeService getEmployeeService(String url) throws Exception {

        if (service == null) {

            Properties properties = new Properties();

            //System.getProperty("server2.url");

            if (url != null) {

                properties.put("java.naming.provider.url", url);

            }

            Context context = new InitialContext(properties);

            try {

                service = (EmployeeService) PortableRemoteObject.narrow(context.lookup("java:comp/env/ejb/EmployeeService"), EmployeeService.class);

            } catch (NameNotFoundException notFoundException) {

                try {

                    service = (EmployeeService) PortableRemoteObject.narrow(context.lookup("ejb/EmployeeService"), EmployeeService.class);

                } catch (NameNotFoundException notFoundException2) {

                    try {

                        // WLS likes this one.

                        service = (EmployeeService) PortableRemoteObject.narrow(context.lookup("EmployeeService#org.eclipse.persistence.testing.models.jpa.sessionbean.EmployeeService"), EmployeeService.class);

                    } catch (NameNotFoundException notFoundException3) {

                        try {

                             //jboss likes this one

                             service = (EmployeeService) PortableRemoteObject.narrow(context.lookup("EmployeeService/remote"), EmployeeService.class);

                        } catch (NameNotFoundException notFoundException4) {

                             throw new Error("All lookups failed.", notFoundException);

                        }

                    }

                }

            }

        }

        return service;

    }    

    /* CacheCoordination Delete Test Setup on Server2:

    *  This test insert an employee record, which will be deleted later using Server1

    */

   public void testSetupForDeleteOnServer2() throws Exception {  

       	/* Create an Employee record using Server2 */

        Employee employee = new Employee();

        employee.setFirstName("Jane2");

        employee.setLastName("Doe2");

	employee.setAddress(new Address());

        employee.getAddress().setCity("Ottawa2");

	Employee manager = new Employee();

        manager.setFirstName("John2");

        manager.setLastName("Done2");

        employee.setManager(manager);

        int empID = getEmployeeService(server2Url).insert(employee); 

       try{    

        employee = getEmployeeService(server2Url).findById(empID);

	if(employee == null){

          fail("Server2 CacheCoordination Setup Failure: New employee added from Server2 is not found in cache or DB.");

        }

       } catch(Exception e){

	       throw new Error("Following Emp ID not found: " + empID); 

       }      

   }  

    /**

     * CacheCoordination Update Test setup on Server1:

     * This test insert an employee record, which is then updated using Server1. Later on,  this update will be verified on Server2.

     * The setup is done as a test, both to record its failure, and to alow execution in the server1.

     */

    public void testSetupRcmOnServer1() throws Exception {

       	/* Create an Employee record in Server1 */

        Employee employee = new Employee();

        employee.setFirstName("Jane1");

        employee.setLastName("Doe1");

        employee.setAddress(new Address());

        employee.getAddress().setCity("Ottawa1");

	Employee manager = new Employee();

        manager.setFirstName("John1");

        manager.setLastName("Done1");

        employee.setManager(manager);

        empId = getEmployeeService(server1Url).insert(employee);	

	/* read Employee from cache and/or DB */

	Employee jane1 = (Employee) getEmployeeService(server1Url).findById(empId);

	/* update employee on Server1 */

        jane1.setLastName("LastNameUpdatedOnServer1");

        jane1.getAddress().setCity("newCity");

        getEmployeeService(server1Url).update(jane1);

        if (!jane1.getLastName().equals("LastNameUpdatedOnServer1")) {

		fail("UpdateTest Setup on Server1 failed");

        } 

    }

     /**

     * CacheCoordination Test setup for Delete on Server1:

     * Find employee created on Server2, then delete it using Server1.

     */

    public void testPerformDeleteOnServer1() throws Exception {

	List result = getEmployeeService(server1Url).findByFirstName("Jane2");

	int count = 0;

	for(Iterator i = result.iterator(); i.hasNext();){

		 employeeCached = (Employee) i.next();

	}

	if(employeeCached == null){

          fail("Perform Delete Test failed: New employee was not found in distributed cache to delete");

        }

        getEmployeeService(server1Url).delete(employeeCached);   	

    }

    /* CacheCoordination Test - Verify that Object Update done on Server1 is sync with Server2 thru cache:

    *  This test uses JPQL to read object on Server2.

    */

   public void testConfirmUpdateOnServer2() throws Exception {  

        /* verify updates are in sync: read Employee from using Server2 URL */

	List result = getEmployeeService(server2Url).findByFirstName("Jane1");

	int count = 0;

	for(Iterator i = result.iterator(); i.hasNext();){

		 employeeCached = (Employee) i.next();

	}

	if(employeeCached == null){

          fail("Object Update Test verification failed: New employee was not found in distributed cache");

        }

        if (!employeeCached.getLastName().equals("LastNameUpdatedOnServer1")) {

		fail("Object Update Test verification failed: Changes from server1 is not seen by server2 from distributed cache");

        } 

   }  

   /* CacheCoordination Test - Verify that Object Delete done on Server1 is sync with Server2 thru cache:

    *    This test uses JPQL to read object on Server2.

    */

   public void testConfirmDeleteOnServer2() throws Exception {  

        /* verify deletes are in sync: read Employee from using Server2 URL */

	List result = getEmployeeService(server2Url).findByFirstName("Jane2");

	int count = 0;

	for(Iterator i = result.iterator(); i.hasNext();){

		 employeeCached = (Employee) i.next();

	}

	if(!( employeeCached == null)){

          fail("Object Delete Test verification failed: employee was not removed from cache as expected" );

        } 

   }   

    /* CacheCoordination Test - Verify changes are on cache and read onto Server2:

    *

    */

/*

   public void testReadFromServer2AfterUpdateNonJPQL() throws Exception {  

        // read Employee from using Server2 URL 

       ExpressionBuilder employees = new ExpressionBuilder();

       Expression expression = employees.get("firstName").equal("Jane1");

       ReadObjectQuery query = new ReadObjectQuery(Employee.class, expression);            

        // verify updates are in sync

	query.checkCacheOnly();

	//empID = getEmpID();

        Employee employeeCached = (Employee) (this.getServerSession("sessionbean")).executeQuery(query); 

	if(employeeCached == null){

          fail("Object_Exist_Test: New employee was not added to distributed cache: (SERVER2_URL) "+ (this.getServerSession("sessionbean")).getName() );

        }

        if (!employeeCached.getLastName().equals("LastNameUpdatedOnServer1")) {

		fail("Object_Update_Test: Changes from server1 is not seen by server2 from distributed cache");

        } 

   }

*/   

}

#******* CacheCoordination Env properties.

server.lib=../../../../bea103/wlserver_10.3/server/lib

weblogic.home=../../../../bea103/wlserver_10.3/server/

weblogic.domain=../../../../bea103/user_projects/domains/mydomain

jdbc.driver.jar=../../../extension.oracle.lib.external/ojdbc6_11.jar

eclipselink.jpa.depend=../plugins/javax.persistence_1.99.0.jar

# CacheCoordination common properties

#

cachecoordination.multicastgroup=

cachecoordination.multicastport=

# CacheCoordination Weblogic properties

#

#cachecoordination.wls.adminserver.httphost=${weblogic.host}

cachecoordination.wls.server1.httphost=${weblogic.host}

cachecoordination.wls.server2.httphost=${weblogic.host}

cachecoordination.wls.server3.httphost=${weblogic.host}

#cachecoordination.wls.adminserver.name=server1

cachecoordination.wls.server1.name=server1

cachecoordination.wls.server2.name=server2

cachecoordination.wls.server3.name=server3

#cachecoordination.wls.adminserver.port=${weblogic.port}

cachecoordination.wls.server1.port=7001

cachecoordination.wls.server2.port=7021

cachecoordination.wls.server3.port=7031

server1.url=t3://localhost:7001/

server2.url=t3://localhost:7021/

server3.url=t3://localhost:7031/

# test config using protocol: valid values jms or rmi

cachecoordination.protocol=jms