it_bus_pdk/rm_persistence.h

#ifndef _IT_BUS_PDK_RM_PERSISTENCE_H_
#define _IT_BUS_PDK_RM_PERSISTENCE_H_

// @Copyright 2006 IONA Technologies, Plc. All Rights Reserved.
//
#include <it_bus/types.h>

namespace IT_Bus
{
    class String;
    class QName;
    class BinaryBuffer;

    class RMSequencePersistentStore
    {
      public:

        virtual String
        get_sequence_id() = 0;

        virtual String
        get_acksto_uri() = 0;

        /*
         * Stores the message in the sequence's persistent store.
         * The is_last_message flag is used by RM source to indicate
         * if it's the last message of the sequence.
         * Returns true iff the message is successfully persisted;
         * false otherwise.
         */
        virtual bool
        store_message(
            IT_Bus::ULong message_id,
            BinaryBuffer& message,
            bool          is_last_message
        ) = 0;

        /*
         * Removes the message from the sequence's persistent store.
         * The second parameter is used by RM destination (that provides
         * InOrder delivery assurance to indicate if the message being
         * removed is the highest delivered message id.
         */
        virtual void
        remove_message(
            IT_Bus::ULong message_id,
            bool          highest_delivered_message_id
        ) = 0;

        /*
         * Called by the RM destination upon receipt of a WSRM
         * acknowledgement to store a stringified representation
         * of the WSRM ack.
         */
        virtual void
        store_acknowledgement(
            const String& stringified_ack_range
        ) = 0;

        /*
         * Returns the last message ID. For RM source, it is the last
         * message of the sequence (with the wsrm:LastMessage element),
         * or returns 0, if the last message has not been persisted.
         * For the RM destination, it determines the highest delivered
         * message ID for an in-order delivery assurance, and 0 otherwise.
         */
        virtual IT_Bus::ULong
        get_last_message_id() = 0;

        /*
         * Called when a WSRM sequence is terminated.
         */
        virtual void
        sequence_terminated() = 0;

        /*
         * After the endpoint recovers from a previous crash, this method
         * is called in an iterative fashion to get the next message in
         * the sequence persistence store.
         * The out parameter is the message id of the recovered message.
         * It returns 0 if there are no more messages in the store.
         * This API is not expected to be called concurrently.
         */
        virtual BinaryBuffer*
        get_next_message_to_recover(
            IT_Bus::ULong& message_id
        ) = 0;
    };

    class RMEndpointPersistentStore
    {
      public:

        virtual const QName&
        get_service_name() = 0;

        virtual String
        get_port_name() = 0;

        virtual String
        get_address() = 0;

        virtual String
        get_stringified_epr() = 0;

        /*
         * Called by a non-recovering destination endpoint
         * to store endpoint address.
         */
        virtual void
        store_address(
            const String& endpoint_address
        ) = 0;

        /*
         * Called when a WSRM sequence is created.
         */
        virtual RMSequencePersistentStore*
        sequence_created(
            const String& sequence_id,
            const String& acksto_uri
        ) = 0;

        /* Returns true if the RMEndpointPersistentStore
         * was already present in the DB, in which case,
         * it needs to recover, OR, if it was a new
         * entry in the DB, in which case, it returns false.
         */
        virtual bool
        endpoint_needs_recovery() = 0;

        /*
         * The following method is called after an endpoint
         * recovers from a crash. It returns the next sequence
         * to be recovered, or 0, if there are no more sequences
         * to be recovered. It SHOULD NOT be called concurrently.
         */
        virtual RMSequencePersistentStore*
        get_next_sequence_to_recover() = 0;
    };

    /*
     * The following interface creates and manages
     * RMEndpointPersistentStore.
     */
    class RMPersistentManager
    {
      public:

        /*
         * Called when an RM source endpoint is created.
         */
        virtual RMEndpointPersistentStore*
        rm_source_endpoint_created(
            const QName&  wsdl_service_qname,
            const String& wsdl_port_name,
            const String& stringified_wsa_epr,
            const String& endpoint_address
        ) = 0;

        /*
         * Called when an RM source endpoint is created.
         */
        virtual RMEndpointPersistentStore*
        rm_destination_endpoint_created(
            const QName&  wsdl_service_qname,
            const String& wsdl_port_name,
            const String& stringified_wsa_epr
        ) = 0;

        /*
         * Called when the endpoint is closed.
         */
        virtual void
        rm_endpoint_closed(
            RMEndpointPersistentStore* ep_store
        ) = 0;

        virtual RMEndpointPersistentStore*
        get_next_source_endpoint_to_recover() = 0;

        virtual void
        cleanup_persistent_store() = 0;
    };
}

#endif  

---