Middlewarepedia

Wednesday, April 1, 2015

Oracle Java Cloud Services – On-Premise (Intranet) Integration

Introduction

Scenario: You need to migrate you Java EE application to the Oracle Java cloud Services – PaaS. Your Java EE application has some dependencies on services that run in a restricted network (company, hotel, hospital) on a "server" which you want to access from outside that network. You cannot forward ports to that machine, but you can ssh outside (to your own server) from that “server” or from another machine under the same intranet/firewall with your “server”.

You need another server or even the same “server” to which you setup a persistent ssh connection with a reverse tunnel. You will ssh from one of the machine inside your intranet to the JCS virtual machine. On that ssh session you’ll configure a reverse tunnel that will tunnel your traffic on the port X from your sever to port Y on your JCS VM.

Make sure you have permission to do this from the administrators. They generally don't like holes in the firewall/security. They don't block it for no reason.

We need to make sure this kind of tunnel is highly available and this is why we will configure it as a service with the following properties:

Auto-recreation after failure
Auto-start during OS boot

As an example we will configure a VirtualBox VM running the VPN client, so being inside the organization intranet. This VBox VM will run 2 services: OpenLdap (port 389) and Oracle 11g XE Database(port 1521).

We’ll configure highly available reverse tunneling from the VBox VM to the Oracle Java Cloud Service Weblogic Admin Server vm for the upper mentioned traffic.

Then we will configure JCS Weblogic Admin Server to consume the upper mentioned LDAP and Database services that are running inside the Oracle Intranet.

VirtualBox VM

Step 1: Make sure your VirtualBox VM is inside the Intranet

Make sure your VPN connection is up:

Double check an Intranet IP has been allocated to your VirtualBox VM:

Set up your system proxy configurations:

Step 2: Check that OpenLDAP and Oracle Database are up and running on your VBox VM

Check that your local VBox VM database is up and running and listening on port 1521:

Check that your local VBox VM OpenLDAP is up and running and listening on port 389:

JCS WLS Admin Server VM – set up ssh reverse tunneling

Step 3: Get the IP of the JCS Admin Server VM

Go to the Java cloud Service console and copy the JCS Admin VM IP:

Add this ip to the VBox VM /etc/hosts file:

Using the provided key ssh from the VirtualBox VM to the JCS WLS Admin Server VM:

[oracle@cloud-vm Desktop]$ ssh -i /u01/JCS/Demos/eCommerce/labkey opc@jcsadmvm

Step 4: Configure paswordless root SSH by using public key authentication on JCS WLS AdminServer VM

Generate a new ssh key for root user on the JCS Admin WLS VM:

Switch to root on the JCS Admin Server WLS VM

[opc@venkyjcs2-wls-1 ~]$ sudo su -

Generate a new ssh key:

[root@venkyjcs2-wls-1 ~]# ssh-keygen

Set the file for the key to /home/opc/rootsshkey
Set empty passphrase

Create a new file called authorized_keys under /root/.ssh/

[root@venkyjcs2-wls-1 ~]# vi ~/.ssh/authorized_keys

Paste inside the /root/.ssh/authorized_keys the entire content of the public key created above: /home/opc/rootsshkey.pub

Set the proper permissions:

[root@venkyjcs2-wls-1 ~]# chmod 700 ~/.ssh [root@venkyjcs2-wls-1 ~]# chmod 600 ~/.ssh/*

To enable the key copy process change the ownership of the previously generated public keys:

[root@venkyjcs2-wls-1 ~]# chown opc:opc /home/opc/rootsshkey [root@venkyjcs2-wls-1 ~]# chmod 777/home/opc/rootsshkey

Copy the ssh key from the remote host(JCS VM) to the local host(VirtualBox VM)

[oracle@cloud-vm JCS]$ scp opc@jcsadmvm:/home/opc/rootsshkey /u01/JCS/Demos/eCommerce/

Set the right permissions for the root ssh key on the VBox VM:

[oracle@cloud-vm JCS]$ chmod 600 /u01/JCS/Demos/eCommerce/rootsshkey

Enable root passwordless ssh key login on the JCS WLS Admin VM:

As root on the JCS WLS Admin VM edit /etc/ssh/sshd_config

[root@venkyjcs2-wls-1 ~]# vi /etc/ssh/sshd_config

Set the following configuration:

PermitRootLogin yes AllowUsers opc oracle otools root

Restart sshd service on the JCS WLS Admin VM:

[root@venkyjcs2-wls-1 ~]# service sshd restart

SSH without using the password and by using the generated key from the VBox VM to the JCS WLS Admin VM:

[oracle@cloud-vm JCS]$ ssh -i /u01/JCS/Demos/eCommerce/rootsshkeys root@jcsadmvm

Step 5: Create the reverse ssh tunnel

Note: SSH –R: Specifies that the given port on the remote (server) host is to be forwarded to the given host and port on the local side. This works by allocating a socket to listen to port on the remote side, and whenever a connection is made to this port, the connection is forwarded over the secure channel, and a connection is made to host port hostport from the local machine.

By default, the listening socket on the server will be bound to the loopback interface only. This may be overridden by specifying a bind_address. An empty bind_address, or the address ‘*’, indicates that the remote socket should listen on all interfaces. Specifying a remote bind_address will only succeed if the server's GatewayPorts option is enabled.

Check that there is nothing listening on the JCS WLS Admin VM on ports 1522, respectively 389.

[root@venkyjcs2-wls-1 ~]# netstat -ant | grep 1522 [root@venkyjcs2-wls-1 ~]# netstat -ant | grep 389

Let’s reverse tunnel (forward) traffic on ports 1521 and 389 from the intranet VBox VM to the JCS WLS Admin VM ports: 1522 and, respectively 389. We’ll do this in a SSH session started on the VBox VM against the JCS WLS Admin VM:

[oracle@cloud-vm JCS]$ ssh -i /u01/JCS/Demos/eCommerce/rootsshkey -R 1522:localhost:1521 -R 389:localhost:389 root@jcslb

Check if the JCS WLS Admin VM is listening now on ports 1522 and 389:

[root@venkyjcs2-lb-1 ~]# netstat -ant | grep 1522 [root@venkyjcs2-lb-1 ~]# netstat -ant | grep 38

Create a highly available ssh reverse tunnel

High availability is the most important concern of this approach.

In the next section will transform the ssh tunnel configured above in a linux service that will also auto restart the tunnel in case of failure. This linux service should run the ssh tunneling process as a background process.

We will also make this service start at OS boot.

STEP 6: Creating an SSH tunnel high available linux service

For creating a high available ssh tunnel linux service we can create our own /etc/ini.d/ script or we can use an already existing tool. In this document we will use an already existing tool called autossh.

Note: Autossh is a program to start an instance of ssh and monitor it, restarting it as necessary should it die or stop passing traffic. The idea is from rstunnel (Reliable SSH Tunnel), but implemented in C. Connection monitoring is done using a loop of port forwardings. It backs off on the rate of connection attempts when experiencing rapid failures such as connection refused.

Download the autossh rpm for Red Hat/Oracle Enterprise Linux from here.

Create the autossh ssh tunneling session from the VBox VM to the JCS WLS Admin VM. First make sure you have killed your previous tunneling sessions.

[oracle@cloud-vm JCS]$ autossh -f -N -M 5122 -i /u01/JCS/Demos/eCommerce/rootkeys -R 1522:localhost:1521 389:localhost:389 root@jcsadmvm

Now you have a highly available service like background process that creates to reverse tunnels.

STEP 7: Make this service start at OS boot

For making this service start at boot we can either create a /etc/rc.d/ script or use a simple Oracle Linux UI menu feature called: Startup Applications.
Navigate to System -> Preferences -> Startup Applications

Create a new entry there that will contain the autossh command above:

Connect from JCS WLS Server to the on premise (intranet) Database and OpenLDAP servers

Check that your JCS WLS Admin VM is listening on ports: localhost:1522 for database and locahost:389 for OpenLDAP

STEP 8: Create a JCS WLS datasource connection against the Oracle 11g XE Database that runs inside Oracle intranet

Access the JCS Weblogic admin console and configure a new datasource with the following details:

Data source: Generic Data Source Name: test JNDI Name: jdbc/test Database Type: Oracle Database Name: XE Host Name: localhost Port: 1522 Database User Name: oe Database Password: oe Driver Class Name: oracle.jdbc.xa.client.OracleXADataSource URL: jdbc:oracle:thin:@localhost:1522:XE

STEP 9: Create a JCS WLS OpenLDAP authentication provider against the OpenLDAP server that runs inside Oracle intranet

We have already created an OpenLDAP provider called OpenLDAPIntranet that can be found under: JCS WLS Admin Console -> security Realms -> myrealm -> Providers:

The OpenLDAP provider relevant configuration is:

Host: localhost Port: 389 Principal: cn=Manager,dc=my-domain,dc=com Credential: secret

In order to test the OpenLDAPIntranet provider navigate to JCS WLS Admin Console -> security Realms -> myrealm -> Users and Groups and identify the OpenLDAPIntranet users:

Technorati Tags: Java Cloud Service,JCS,JavaEE,Cloud Oracle Public Cloud,Integration,VPN,Intranet

Thursday, February 21, 2013

One solution for: “weblogic.jms.common.JMSException: No failover destination.”

Today was playing with Uniform distributed Queue in a WLS 12.1.1.0 cluster and after several tests, without any setting changed in the servers, I’ve got this exception:
weblogic.jms.common.JMSException: No failover destination.
In the logs there was another exception that appeared in each of the managed servers after a restart, exactly before the server changed its status to RUNNING.
The exception was:
java.io.NotSerializableException: com.sun.jersey.server.impl.cdi.CDIExtension
According to BUG 13975839, this is an issue in WLS 12.1.1.0 that have been fixed in WLS 12.1.2.0. The BUG description says that: “CDI beans are not replicated as they are not serializable”.
The workaround in WLS 12.1.1.0 is to add this in your managed server start parameters:
-Dcom.sun.jersey.server.impl.cdi.lookupExtensionInBeanManager=true
Adding this start option fixed also my initial issue with jms. Now, regarding the relation between the initial issue and the CDI serialization bug, for the moment I can just guess but after further investigations I’ll update you all – stay tuned…

Thursday, February 7, 2013

Coherence - How to develop a custom push replication publisher

CoherencePushReplicationDB.zip

In the example bellow I'm describing a way of developing a custom push replication publisher that publishes data to a database via JDBC. This example can be easily changed to publish data to other receivers (JMS,...) by performing changes to step 2 and small changes to step 3, steps that are presented bellow. I've used Eclipse as the development tool.

To develop a custom push replication publisher we will need to go through 6 steps:

Step 1: Create a custom publisher scheme class
Step 2: Create a custom publisher class that should define what the publisher is doing.
Step 3: Create a class data that is performing the actions (publish to JMS, DB, etc ) for the custom publisher.
Step 4: Register the new publisher against a ContentHandler.
Step 5: Add the new custom publisher to the cache configuration file.
Step 6: Add the custom publisher scheme class to the POF configuration file.

All these steps are detailed bellow.
The coherence project is attached and conclusions are presented at the end.
Step 1: In the Coherence Eclipse project create a class called CustomPublisherScheme that should implement com.oracle.coherence.patterns.pushreplication.publishers.AbstractPublisherScheme. In this class define the elements of the custom-publisher-scheme element.
For instance for a CustomPublisherScheme that looks like that:

<sync:publisher>

    <sync:publisher-name>Active2-JDBC-Publisher</sync:publisher-name>

    <sync:publisher-scheme>

        <sync:custom-publisher-scheme>

            <sync:jdbc-string>jdbc:oracle:thin:@machine-name:1521:XE</sync:jdbc-string>

            <sync:username>hr</sync:username>

            <sync:password>hr</sync:password>

        </sync:custom-publisher-scheme>

    </sync:publisher-scheme>

</sync:publisher>



the code is:

package com.oracle.coherence;

  

import java.io.DataInput;

import java.io.DataOutput;

import java.io.IOException;

import com.oracle.coherence.patterns.pushreplication.Publisher;

import com.oracle.coherence.configuration.Configurable;

import com.oracle.coherence.configuration.Mandatory;

import com.oracle.coherence.configuration.Property;

import com.oracle.coherence.configuration.parameters.ParameterScope;

import com.oracle.coherence.environment.Environment;

import com.tangosol.io.pof.PofReader;

import com.tangosol.io.pof.PofWriter;

import com.tangosol.util.ExternalizableHelper;

  

@Configurable

public class CustomPublisherScheme

        extends

        com.oracle.coherence.patterns.pushreplication.publishers.AbstractPublisherScheme

{

    /**

* 

*/

    private static final long serialVersionUID = 1L;

    private String jdbcString;

    private String username;

    private String password;

  

    public String getJdbcString()

    {

        return this.jdbcString;

    }

  

    @Property("jdbc-string")

    @Mandatory

    public void setJdbcString(String jdbcString)

    {

        this.jdbcString = jdbcString;

    }

  

    public String getUsername()

    {

        return username;

    }

  

    @Property("username")

    @Mandatory

    public void setUsername(String username)

    {

        this.username = username;

    }

  

    public String getPassword()

    {

        return password;

    }

  

    @Property("password")

    @Mandatory

    public void setPassword(String password)

    {

        this.password = password;

    }

  

    public Publisher realize(Environment environment, ClassLoader classLoader,

            ParameterScope parameterScope)

    {

        return new CustomPublisher(getJdbcString(), getUsername(),

                getPassword());

    }

  

    public void readExternal(DataInput in) throws IOException

    {

        super.readExternal(in);

        this.jdbcString = ExternalizableHelper.readSafeUTF(in);

        this.username = ExternalizableHelper.readSafeUTF(in);

        this.password = ExternalizableHelper.readSafeUTF(in);

    }

  

    public void writeExternal(DataOutput out) throws IOException

    {

        super.writeExternal(out);

        ExternalizableHelper.writeSafeUTF(out, this.jdbcString);

        ExternalizableHelper.writeSafeUTF(out, this.username);

        ExternalizableHelper.writeSafeUTF(out, this.password);

    }

  

    public void readExternal(PofReader reader) throws IOException

    {

        super.readExternal(reader);

        this.jdbcString = reader.readString(100);

        this.username = reader.readString(101);

        this.password = reader.readString(102);

    }

  

    public void writeExternal(PofWriter writer) throws IOException

    {

        super.writeExternal(writer);

        writer.writeString(100, this.jdbcString);

        writer.writeString(101, this.username);

        writer.writeString(102, this.password);

    }

}

Step 2: Define what the CustomPublisher should basically do by creating a new java class called CustomPublisher that implements com.oracle.coherence.patterns.pushreplication.Publisher

package com.oracle.coherence;

  

import com.oracle.coherence.patterns.pushreplication.EntryOperation;

import com.oracle.coherence.patterns.pushreplication.Publisher;

import com.oracle.coherence.patterns.pushreplication.exceptions.PublisherNotReadyException;

import java.io.BufferedWriter;

import java.util.Iterator;

  

public class CustomPublisher implements Publisher

{

    private String jdbcString;

    private String username;

    private String password;

    private transient BufferedWriter bufferedWriter;

  

    public CustomPublisher()

    {

    }

  

    public CustomPublisher(String jdbcString, String username, String password)

    {

        this.jdbcString = jdbcString;

        this.username = username;

        this.password = password;

        this.bufferedWriter = null;

    }

  

    public String getJdbcString()

    {

        return this.jdbcString;

    }

  

    public String getUsername()

    {

        return username;

    }

  

    public String getPassword()

    {

        return password;

    }

  

    public void publishBatch(String cacheName, String publisherName,

            Iterator<EntryOperation> entryOperations)

    {

        DatabasePersistence databasePersistence = new DatabasePersistence(

                jdbcString, username, password);

        while (entryOperations.hasNext())

        {

            EntryOperation entryOperation = (EntryOperation) entryOperations

                    .next();

            databasePersistence.databasePersist(entryOperation);

        }

    }

  

    public void start(String cacheName, String publisherName)

            throws PublisherNotReadyException

    {

        System.err

                .printf("Started: Custom JDBC Publisher for Cache %s with Publisher %s\n",

                        new Object[] { cacheName, publisherName });

    }

  

    public void stop(String cacheName, String publisherName)

    {

        System.err

                .printf("Stopped: Custom JDBC Publisher for Cache %s with Publisher %s\n",

                        new Object[] { cacheName, publisherName });

    }

}

In the publishBatch method from above we inform the publisher that he is supposed to persist data to a database:

  

DatabasePersistence databasePersistence = new DatabasePersistence(

                jdbcString, username, password);

        while (entryOperations.hasNext())

        {

            EntryOperation entryOperation = (EntryOperation) entryOperations

                    .next();

            databasePersistence.databasePersist(entryOperation);

        }

Step 3: The class that deals with the persistence is a very basic one that uses JDBC to perform inserts/updates against a database.

package com.oracle.coherence;

  

import com.oracle.coherence.patterns.pushreplication.EntryOperation;

import java.sql.*;

import java.text.SimpleDateFormat;

import com.oracle.coherence.Order;

  

public class DatabasePersistence

{

    public static String INSERT_OPERATION = "INSERT";

    public static String UPDATE_OPERATION = "UPDATE";

    public Connection dbConnection;

  

    public DatabasePersistence(String jdbcString, String username,

            String password)

    {

        this.dbConnection = createConnection(jdbcString, username, password);

    }

  

    public Connection createConnection(String jdbcString, String username,

            String password)

    {

        Connection connection = null;

        System.err.println("Connecting to: " + jdbcString + " Username: "

                + username + " Password: " + password);

        try

        {

            // Load the JDBC driver

            String driverName = "oracle.jdbc.driver.OracleDriver";

            Class.forName(driverName);

            // Create a connection to the database

            connection = DriverManager.getConnection(jdbcString, username,

                    password);

            System.err.println("Connected to:" + jdbcString + " Username: "

                    + username + " Password: " + password);

        }

        catch (ClassNotFoundException e)

        {

            e.printStackTrace();

        }

        // driver

        catch (SQLException e)

        {

            e.printStackTrace();

        }

        return connection;

    }

  

    public void databasePersist(EntryOperation entryOperation)

    {

        if (entryOperation.getOperation().toString()

                .equalsIgnoreCase(INSERT_OPERATION))

        {

            insert(((Order) entryOperation.getPublishableEntry().getValue()));

        }

        else

            if (entryOperation.getOperation().toString()

                    .equalsIgnoreCase(UPDATE_OPERATION))

            {

                update(((Order) entryOperation.getPublishableEntry().getValue()));

            }

    }

  

    public void update(Order order)

    {

        String update = "UPDATE Orders set QUANTITY= '"

                + order.getQuantity()

                + "', AMOUNT='"

                + order.getAmount()

                + "', ORD_DATE= '"

                + (new SimpleDateFormat("dd-MMM-yyyy")).format(order

                        .getOrdDate()) + "' WHERE SYMBOL='" + order.getSymbol()

                + "'";

        System.err.println("UPDATE = " + update);

        try

        {

            Statement stmt = getDbConnection().createStatement();

            stmt.execute(update);

            stmt.close();

        }

        catch (SQLException ex)

        {

            System.err.println("SQLException: " + ex.getMessage());

        }

    }

  

    public void insert(Order order)

    {

        String insert = "insert into Orders values('"

                + order.getSymbol()

                + "',"

                + order.getQuantity()

                + ","

                + order.getAmount()

                + ",'"

                + (new SimpleDateFormat("dd-MMM-yyyy")).format(order

                        .getOrdDate()) + "')";

        System.err.println("INSERT = " + insert);

        try

        {

            Statement stmt = getDbConnection().createStatement();

            stmt.execute(insert);

            stmt.close();

        }

        catch (SQLException ex)

        {

            System.err.println("SQLException: " + ex.getMessage());

        }

    }

  

    public Connection getDbConnection()

    {

        return dbConnection;

    }

  

    public void setDbConnection(Connection dbConnection)

    {

        this.dbConnection = dbConnection;

    }

}

Step 4: Now we need to register our publisher against a ContentHandler. In order to achieve that we need to create in our eclipse project a new class called CustomPushReplicationNamespaceContentHandler that should extend the com.oracle.coherence.patterns.pushreplication.configuration.PushReplicationNamespaceContentHandler. In the constructor of the new class we define a new handler for our custom publisher.

package com.oracle.coherence;

  

import com.oracle.coherence.configuration.Configurator;

import com.oracle.coherence.environment.extensible.ConfigurationContext;

import com.oracle.coherence.environment.extensible.ConfigurationException;

import com.oracle.coherence.environment.extensible.ElementContentHandler;

import com.oracle.coherence.patterns.pushreplication.PublisherScheme;

import com.oracle.coherence.environment.extensible.QualifiedName;

import com.oracle.coherence.patterns.pushreplication.configuration.PushReplicationNamespaceContentHandler;

import com.tangosol.run.xml.XmlElement;

  

public class CustomPushReplicationNamespaceContentHandler extends

        PushReplicationNamespaceContentHandler

{

    public CustomPushReplicationNamespaceContentHandler()

    {

        super();

        registerContentHandler("custom-publisher-scheme",

                new ElementContentHandler()

                {

                    public Object onElement(ConfigurationContext context,

                            QualifiedName qualifiedName, XmlElement xmlElement)

                            throws ConfigurationException

                    {

                        PublisherScheme publisherScheme = new CustomPublisherScheme();

                        Configurator.configure(publisherScheme, context,

                                qualifiedName, xmlElement);

                        return publisherScheme;

                    }

                });

    }

}

Step 5: Now we should define our CustomPublisher in the cache configuration file according to the following documentation.

<cache-config

    xmlns:sync="class:com.oracle.coherence.CustomPushReplicationNamespaceContentHandler"

    xmlns:cr="class:com.oracle.coherence.environment.extensible.namespaces.InstanceNamespaceContentHandler">

    <caching-schemes>

        <sync:provider pof-enabled="false">

            <sync:coherence-provider />

        </sync:provider>

        <caching-scheme-mapping>

            <cache-mapping>

                <cache-name>publishing-cache</cache-name>

                <scheme-name>distributed-scheme-with-publishing-cachestore</scheme-name>

                <autostart>true</autostart>

                <sync:publisher>

                    <sync:publisher-name>Active2 Publisher</sync:publisher-name>

                    <sync:publisher-scheme>

                        <sync:remote-cluster-publisher-scheme>

                            <sync:remote-invocation-service-name>remote-site1

                            </sync:remote-invocation-service-name>

                            <sync:remote-publisher-scheme>

                                <sync:local-cache-publisher-scheme>

                                    <sync:target-cache-name>publishing-cache

                                    </sync:target-cache-name>

                                </sync:local-cache-publisher-scheme>

                            </sync:remote-publisher-scheme>

                            <sync:autostart>true</sync:autostart>

                        </sync:remote-cluster-publisher-scheme>

                    </sync:publisher-scheme>

                </sync:publisher>

                <sync:publisher>

                    <sync:publisher-name>Active2-Output-Publisher</sync:publisher-name>

                    <sync:publisher-scheme>

                        <sync:stderr-publisher-scheme>

                            <sync:autostart>true</sync:autostart>

                            <sync:publish-original-value>true</sync:publish-original-value>

                        </sync:stderr-publisher-scheme>

                    </sync:publisher-scheme>

                </sync:publisher>

                <sync:publisher>

                    <sync:publisher-name>Active2-JDBC-Publisher</sync:publisher-name>

                    <sync:publisher-scheme>

                        <sync:custom-publisher-scheme>

                            <sync:jdbc-string>jdbc:oracle:thin:@machine_name:1521:XE

                            </sync:jdbc-string>

                            <sync:username>hr</sync:username>

                            <sync:password>hr</sync:password>

                        </sync:custom-publisher-scheme>

                    </sync:publisher-scheme>

                </sync:publisher>

            </cache-mapping>

        </caching-scheme-mapping>

        <!-- The following scheme is required for each remote-site when using a 

            RemoteInvocationPublisher -->

        <remote-invocation-scheme>

            <service-name>remote-site1</service-name>

            <initiator-config>

                <tcp-initiator>

                    <remote-addresses>

                        <socket-address>

                            <address>localhost</address>

                            <port>20001</port>

                        </socket-address>

                    </remote-addresses>

                    <connect-timeout>2s</connect-timeout>

                </tcp-initiator>

                <outgoing-message-handler>

                    <request-timeout>5s</request-timeout>

                </outgoing-message-handler>

            </initiator-config>

        </remote-invocation-scheme>

        <!-- END: com.oracle.coherence.patterns.pushreplication -->

        <proxy-scheme>

            <service-name>ExtendTcpProxyService</service-name>

            <acceptor-config>

                <tcp-acceptor>

                    <local-address>

                        <address>localhost</address>

                        <port>20002</port>

                    </local-address>

                </tcp-acceptor>

            </acceptor-config>

            <autostart>true</autostart>

        </proxy-scheme>

    </caching-schemes>

</cache-config>

As you can see in the red-marked text from above I've:
- set new Namespace Content Handler
- define the new custom publisher that should work together with other publishers like: stderr and remote publishers in our case.

Step 6: Add the com.oracle.coherence.CustomPublisherScheme to your custom-pof-config file:

<pof-config>

    <user-type-list>

        <!-- Built in types -->

        <include>coherence-pof-config.xml</include>

        <include>coherence-common-pof-config.xml</include>

        <include>coherence-messagingpattern-pof-config.xml</include>

        <include>coherence-pushreplicationpattern-pof-config.xml</include>

        <!-- Application types -->

        <user-type>

            <type-id>1901</type-id>

            <class-name>com.oracle.coherence.Order</class-name>

            <serializer>

                <class-name>com.oracle.coherence.OrderSerializer</class-name>

            </serializer>

        </user-type>

        <user-type>

            <type-id>1902</type-id>

            <class-name>com.oracle.coherence.CustomPublisherScheme</class-name>

        </user-type>

    </user-type-list>

</pof-config>

CONCLUSIONSThis approach allows for publishers to publish data to almost any other receiver (database, JMS, MQ, ...). The only thing that needs to be changed is the DatabasePersistence.java class that should be adapted to the chosen receiver. Only minor changes are needed for the rest of the code (to publishBatch method from CustomPublisher class).