Session resume support in client & broker: Client can resume a session

after voluntary suspend() or network failure. Frames lost in network
failure are automatically re-transmitted for transparent re-connection.

client::Session improvements:
 - Locking to avoid races between network & user threads.
 - Replaced client::StateManager with sys::StateMonitor - avoid heap allocation.

qpid::Exception clean up:
 - use QPID_MSG consistently to format exception messages.
 - throw typed exceptions (in reply_exceptions.h) for AMQP exceptions.
 - re-throw correct typed exception on client for exceptions from broker.
 - Removed QpidError.h

rubygen/templates/constants.rb: 
 - constants.h: Added FOO_CLASS_ID and FOO_BAR_METHOD_ID constants.
 - reply_constants.h: Added throwReplyException(code, text)
 
log::Logger:
 - Fixed shutdown race in Statement::~Initializer()


git-svn-id: https://svn.apache.org/repos/asf/incubator/qpid/trunk/qpid@588761 13f79535-47bb-0310-9956-ffa450edef68

1 files changed, 22 insertions, 19 deletions

diff --git a/cpp/src/qpid/broker/SessionState.h b/cpp/src/qpid/broker/SessionState.h
index d152937692..eed088af31 100644
--- a/cpp/src/qpid/broker/SessionState.h
+++ b/cpp/src/qpid/broker/SessionState.h
@@ -24,11 +24,12 @@
 
 #include "qpid/framing/Uuid.h"
 #include "qpid/framing/FrameHandler.h"
+#include "qpid/framing/SessionState.h"
 #include "qpid/framing/ProtocolVersion.h"
 #include "qpid/sys/Time.h"
 
-#include <boost/ptr_container/ptr_vector.hpp>
 #include <boost/noncopyable.hpp>
+#include <boost/scoped_ptr.hpp>
 
 #include <set>
 #include <vector>
@@ -42,31 +43,26 @@ class AMQP_ClientProxy;
 
 namespace broker {
 
+class SemanticHandler;
 class SessionHandler;
 class SessionManager;
 class Broker;
 class Connection;
 
 /**
- * State of a session.
- *
- * An attached session has a SessionHandler which is attached to a
- * connection. A suspended session has no handler.
- *
- * A SessionState is always associated with an open session (attached or
- * suspended) it is destroyed when the session is closed.
- *
- * The SessionState includes the sessions handler chains, which may
- * themselves have state. The handlers will be preserved as long as
- * the session is alive.
+ * Broker-side session state includes sessions handler chains, which may
+ * themselves have state. 
  */
-class SessionState : public framing::FrameHandler::Chains,
-                     private boost::noncopyable
+class SessionState : public framing::SessionState,
+                     public framing::FrameHandler::InOutHandler
 {
   public:
     ~SessionState();
     bool isAttached() { return handler; }
 
+    void detach();
+    void attach(SessionHandler& handler);
+    
     /** @pre isAttached() */
     SessionHandler& getHandler();
 
@@ -76,23 +72,30 @@ class SessionState : public framing::FrameHandler::Chains,
     /** @pre isAttached() */
     Connection& getConnection();
 
-    const framing::Uuid& getId() const { return id; }
     uint32_t getTimeout() const { return timeout; }
     Broker& getBroker() { return broker; }
     framing::ProtocolVersion getVersion() const { return version; }
+
+  protected:
+    void handleIn(framing::AMQFrame&);
+    void handleOut(framing::AMQFrame&);
     
   private:
-    /** Only SessionManager can open sessions */
-    SessionState(SessionManager& f, SessionHandler& h, uint32_t timeout_);
-
+    // SessionManager creates sessions.
+    SessionState(SessionManager&,
+                 SessionHandler& out,
+                 uint32_t timeout,
+                 uint32_t ackInterval);
+    
     SessionManager& factory;
     SessionHandler* handler;    
     framing::Uuid id;
     uint32_t timeout;
     sys::AbsTime expiry;        // Used by SessionManager.
     Broker& broker;
-    boost::ptr_vector<framing::FrameHandler> chain;
     framing::ProtocolVersion version;
+    
+    boost::scoped_ptr<SemanticHandler> semanticHandler;
 
   friend class SessionManager;
 };