Interface PersistenceAdapter

    • Method Detail

      • createQueueMessageStore

        MessageStore createQueueMessageStore​(ActiveMQQueue destination)
                                      throws IOException
        Factory method to create a new queue message store with the given destination name
        Parameters:
        destination -
        Returns:
        the message store
        Throws:
        IOException
      • createTopicMessageStore

        TopicMessageStore createTopicMessageStore​(ActiveMQTopic destination)
                                           throws IOException
        Factory method to create a new topic message store with the given destination name
        Parameters:
        destination -
        Returns:
        the topic message store
        Throws:
        IOException
      • removeQueueMessageStore

        void removeQueueMessageStore​(ActiveMQQueue destination)
        Cleanup method to remove any state associated with the given destination. This method does not stop the message store (it might not be cached).
        Parameters:
        destination - Destination to forget
      • removeTopicMessageStore

        void removeTopicMessageStore​(ActiveMQTopic destination)
        Cleanup method to remove any state associated with the given destination This method does not stop the message store (it might not be cached).
        Parameters:
        destination - Destination to forget
      • createTransactionStore

        TransactionStore createTransactionStore()
                                         throws IOException
        Factory method to create a new persistent prepared transaction store for XA recovery
        Returns:
        transaction store
        Throws:
        IOException
      • beginTransaction

        void beginTransaction​(ConnectionContext context)
                       throws IOException
        This method starts a transaction on the persistent storage - which is nothing to do with JMS or XA transactions - its purely a mechanism to perform multiple writes to a persistent store in 1 transaction as a performance optimization.

        Typically one transaction will require one disk synchronization point and so for real high performance its usually faster to perform many writes within the same transaction to minimize latency caused by disk synchronization. This is especially true when using tools like Berkeley Db or embedded JDBC servers.

        Parameters:
        context -
        Throws:
        IOException
      • getLastMessageBrokerSequenceId

        long getLastMessageBrokerSequenceId()
                                     throws IOException
        Returns:
        last broker sequence
        Throws:
        IOException
      • deleteAllMessages

        void deleteAllMessages()
                        throws IOException
        Delete's all the messages in the persistent store.
        Throws:
        IOException
      • setUsageManager

        void setUsageManager​(SystemUsage usageManager)
        Parameters:
        usageManager - The UsageManager that is controlling the broker's memory usage.
      • setBrokerName

        void setBrokerName​(String brokerName)
        Set the name of the broker using the adapter
        Parameters:
        brokerName -
      • setDirectory

        void setDirectory​(File dir)
        Set the directory where any data files should be created
        Parameters:
        dir -
      • getDirectory

        File getDirectory()
        Returns:
        the directory used by the persistence adaptor
      • checkpoint

        void checkpoint​(boolean cleanup)
                 throws IOException
        checkpoint any
        Parameters:
        cleanup -
        Throws:
        IOException
      • size

        long size()
        A hint to return the size of the store on disk
        Returns:
        disk space used in bytes of 0 if not implemented
      • getLastProducerSequenceId

        long getLastProducerSequenceId​(ProducerId id)
                                throws IOException
        return the last stored producer sequenceId for this producer Id used to suppress duplicate sends on failover reconnect at the transport when a reconnect occurs
        Parameters:
        id - the producerId to find a sequenceId for
        Returns:
        the last stored sequence id or -1 if no suppression needed
        Throws:
        IOException
      • allowIOResumption

        void allowIOResumption()