The Java ReplicaConnection Class

 
    public class ReplicaConnection extends Connection 
    {
        /**
        * Switch to master after initial synchronization
        */
        public static final int MCO_HAMODE_FORCE_MASTER = 0x4000;
 
        /**
        * Force to use synchronous replication
        */
        public static final int MCO_HAMODE_FORCE_SYNC = 0x10000;
 
        /**
        * Send list of registered REST interfaces to master
        */
        public static final int MCO_HAMODE_SEND_RESTLIST = 0x20000;
 
        /**
        * Don't restore WRITE access to the database on master disconnection
        */
        public static final int MCO_HAMODE_EXPLICIT_WRITE_ACCESS = 0x40000;
 
        public ReplicaConnection(Database db) 
        {
            super(db);
        }
         
        public interface ReplicaNotifying 
        {
            public enum NotificationCode 
            {
                Connected,
                ConnectFailed,
                DbEqual,
                DbLoadBegin,
                DbLoadFailed,
                DbLoadOK,
                CommitFailed,
                ReplicaStopped,
                DbCreationFailed,
                HotSync,
                HotSyncEnd,
                StatefulSync,
                StatefulSyncEnd,
                MasterDbExtended,
                MasterDbCleaned
            }
 
            public void onNotify(NotificationCode code, long param);
        };
 
        /**
        * The replication connection parameters.
        */
        public static class Parameters
        {
            public static final int MSEC = 1000;
             
            /**
            * The timeout for read transaction data.
            */
            public int commitTimeout;
 
            /**
            * The timeout (wait limit) for initial synchronization.
            */
            public int initialTimeout;
             
            /**
            * The amount of time a replica waits for a next commit.
            */
            public int waitDataTimeout;
 
            /**
            * The number of times to repeat the commit if the master doesn't answer.
            */
            public int repeatCounter;
 
            /**
            * Multicast support
            */
            public int mcastPort;
            public String mcastAddr;
 
            /**
            * Disk commit policy during initial synchronization
            */
            public Database.CommitPolicy initialCommitPolicy;
 
            /**
            * Number of objects per transaction during initial synchronization
            */
            public int initialObjsInTrans;
 
            /**
            * A combination of MODE_* bit flags.
            */
            public int modeFlags;
            public ReplicaNotifying notifyCallback;
 
            public String cancelpointAddr;
            public TransIterator.Iterator iterator;
 
            /**
            SSL parameters or null if SSL not used
            */
            public Database.SSLParameters sslParameters = null;
 
            /**
            * Compression level: 0..9, 0 - no compression
            */
            public int compressionLevel;
 
            public Parameters(int mode) 
            {
                initParameters(this);
                modeFlags = mode;
            }
 
            public Parameters() 
            {
                initParameters(this);
            }
        }
 
        /**
        * Attach to the master application.
        * @param connectionString the master transport-layer-dependent connection string.
        * (For the TCP/UDP transport this must be "masterhost:port", where masterhost is the hostname or
        * IP-address of the master node, and "port" is the number of the listening port
        * (defined on the master side by the "masterport" parameter of attachReplica(); eg. '192.168.0.1:10000').
        * @param params the replication connection parameters.
        * @param timeout the connection timeout period.
        * @return true when the master is connected sucessfully, false if the master can not be connected within
        * the specified timeout period.
        */
        public boolean attachMaster(String connectionString, ReplicaConnection.Parameters params, int timeout) 
        {
            return attachMaster(id, connectionString, params, timeout);
        }
 
        /**
        * Terminate the replica's wait for updates.
        */
        public void stopReplication() 
        {
            stopReplication(id);
        }
 
        /**
        * Enable or disable replication filter for "local" classes
        */
        public void enableFilter(boolean enabled) 
        {
            enableFilter(id, enabled);
        }
 
        public static native void cancel(String cancelAddr, int timeout);
 
        private native boolean attachMaster(long id, String connectionString, ReplicaConnection.Parameters params, int timeout);
        private native void stopReplication(long id);
        private native void enableFilter(long id, boolean enabled);
        private static native void initParameters(ReplicaConnection.Parameters params);
    }