change state and event enum

Signed-off-by: Emelia Lei <wlei29@bloomberg.net>

Author: emelialei88

src/groups/mqb/mqba/mqba_authenticator.cpp

@@ -96,7 +96,7 @@ int Authenticator::onAuthenticationRequest(
             authenticationMsg,  // authenticationMessage
             context
                 ->authenticationEncodingType(),  // authenticationEncodingType
-            State::e_AUTHENTICATING              // state
+            mqbnet::AuthenticationState::e_AUTHENTICATING  // state
         );
 
     context->setAuthenticationContext(authenticationContext);
@@ -106,8 +106,7 @@ int Authenticator::onAuthenticationRequest(
         errorDescription,
         authenticationContext,
         context->channel(),
-        context->state() ==
-            mqbnet::InitialConnectionState::e_ANON_AUTHENTICATING,
+        context->state() == InitialConnectionState::e_ANON_AUTHENTICATING,
         false);
 
     return rc;
@@ -483,6 +482,7 @@ int Authenticator::handleAuthentication(
 }
 
 int Authenticator::authenticationOutbound(
+    BSLA_UNUSED bsl::ostream&                  errorDescription,
     BSLA_UNUSED const AuthenticationContextSp& context)
 {
     BALL_LOG_ERROR << "Not Implemented";

src/groups/mqb/mqba/mqba_authenticator.h

@@ -87,8 +87,6 @@ class Authenticator : public mqbnet::Authenticator {
         bdlcc::ObjectPoolFunctors::RemoveAll<bdlbb::Blob> >
         BlobSpPool;
 
-    typedef mqbnet::AuthenticationContext::State State;
-
   private:
     typedef bsl::shared_ptr<mqbnet::AuthenticationContext>
         AuthenticationContextSp;
@@ -111,6 +109,7 @@ class Authenticator : public mqbnet::Authenticator {
     /// Thread pool to run authentication and reauthentication tasks.
     bdlmt::ThreadPool d_threadPool;
 
+    /// Pool of shared pointers to blobs.  Held, not owned.
     BlobSpPool* d_blobSpPool_p;
 
     /// Used to track the duration of a valid authenticated connection.
@@ -199,7 +198,8 @@ class Authenticator : public mqbnet::Authenticator {
     // CREATORS
 
     /// Create a new `Authenticator` using the specified `authnController` and
-    /// `blobSpPool`. Use the specified `allocator` for all memory allocations.
+    /// `blobSpPool`.  Use the specified `allocator` for all memory
+    /// allocations.
     Authenticator(mqbauthn::AuthenticationController* authnController,
                   BlobSpPool*                         blobSpPool,
                   bdlmt::EventScheduler*              scheduler,
@@ -235,7 +235,8 @@ class Authenticator : public mqbnet::Authenticator {
     /// `context`.  Return 0 on success, or a non-zero error code and populate
     /// the specified `errorDescription` with a description of the error
     /// otherwise.
-    int authenticationOutbound(const AuthenticationContextSp& context)
+    int authenticationOutbound(bsl::ostream&                  errorDescription,
+                               const AuthenticationContextSp& context)
         BSLS_KEYWORD_OVERRIDE;
 
     /// Schedule an authentication job in the thread pool using the

src/groups/mqb/mqbnet/mqbnet_authenticationcontext.cpp

@@ -102,7 +102,7 @@ AuthenticationContext::AuthenticationContext(
     InitialConnectionContext*                  initialConnectionContext,
     const bmqp_ctrlmsg::AuthenticationMessage& authenticationMessage,
     bmqp::EncodingType::Enum                   authenticationEncodingType,
-    State                                      state,
+    AuthenticationState::Enum                  state,
     bslma::Allocator*                          allocator)
 : d_allocator_p(allocator)
 , d_self(this)  // use default allocator
@@ -136,12 +136,12 @@ int AuthenticationContext::setAuthenticatedAndScheduleReauthn(
 
     bslmt::LockGuard<bslmt::Mutex> guard(&d_mutex);  // LOCKED
 
-    if (d_state != State::e_AUTHENTICATING) {
+    if (d_state != AuthenticationState::e_AUTHENTICATING) {
         errorDescription << "State not AUTHENTICATING (was " << d_state << ")";
         return -1;
     }
 
-    d_state = State::e_AUTHENTICATED;
+    d_state = AuthenticationState::e_AUTHENTICATED;
 
     if (d_timeoutHandle) {
         scheduler_p->cancelEventAndWait(&d_timeoutHandle);
@@ -191,7 +191,7 @@ void AuthenticationContext::onReauthenticateErrorOrTimeout(
     {
         bslmt::LockGuard<bslmt::Mutex> guard(&d_mutex);  // LOCKED
 
-        if (d_state == State::e_CLOSED) {
+        if (d_state == AuthenticationState::e_CLOSED) {
             return;
         }
     }  // UNLOCK
@@ -213,10 +213,10 @@ void AuthenticationContext::onClose(bdlmt::EventScheduler* scheduler_p)
 
     bslmt::LockGuard<bslmt::Mutex> guard(&d_mutex);  // LOCKED
 
-    if (d_state == State::e_CLOSED) {
+    if (d_state == AuthenticationState::e_CLOSED) {
         return;  // idempotent
     }
-    d_state = State::e_CLOSED;
+    d_state = AuthenticationState::e_CLOSED;
 
     if (d_timeoutHandle) {
         scheduler_p->cancelEventAndWait(&d_timeoutHandle);
@@ -227,8 +227,8 @@ bool AuthenticationContext::tryStartReauthentication()
 {
     bslmt::LockGuard<bslmt::Mutex> guard(&d_mutex);  // LOCKED
 
-    if (d_state == State::e_AUTHENTICATED) {
-        d_state = State::e_AUTHENTICATING;
+    if (d_state == AuthenticationState::e_AUTHENTICATED) {
+        d_state = AuthenticationState::e_AUTHENTICATING;
         return true;
     }
 

src/groups/mqb/mqbnet/mqbnet_authenticationcontext.h

@@ -120,7 +120,6 @@ class AuthenticationContext {
 
   public:
     // TYPES
-    typedef AuthenticationState::Enum          State;
     typedef bdlmt::EventScheduler::EventHandle EventHandle;
 
   private:
@@ -144,7 +143,7 @@ class AuthenticationContext {
     EventHandle d_timeoutHandle;
 
     /// Authentication State.
-    State d_state;
+    AuthenticationState::Enum d_state;
 
     /// The initial connection context associated with this authentication
     /// context.  It is set during the initial authentication, and is null for
@@ -175,7 +174,7 @@ class AuthenticationContext {
         InitialConnectionContext*                  initialConnectionContext,
         const bmqp_ctrlmsg::AuthenticationMessage& authenticationMessage,
         bmqp::EncodingType::Enum                   authenticationEncodingType,
-        State                                      state,
+        AuthenticationState::Enum                  state,
         bslma::Allocator*                          allocator = 0);
 
     // MANIPULATORS

src/groups/mqb/mqbnet/mqbnet_authenticator.h

@@ -79,6 +79,7 @@ class Authenticator {
     /// the specified `errorDescription` with a description of the error
     /// otherwise.
     virtual int authenticationOutbound(
+        bsl::ostream&                                 errorDescription,
         const bsl::shared_ptr<AuthenticationContext>& context) = 0;
 
     /// Schedule an authentication job in the thread pool using the

src/groups/mqb/mqbnet/mqbnet_initialconnectioncontext.cpp

@@ -291,10 +291,16 @@ int InitialConnectionContext::processBlob(bsl::ostream&      errorDescription,
     }
     else if (bsl::holds_alternative<bmqp_ctrlmsg::AuthenticationMessage>(
                  message)) {
-        handleEvent(rc, bsl::string(), Event::e_AUTHN_REQUEST, message);
+        handleEvent(rc,
+                    bsl::string(),
+                    InitialConnectionEvent::e_AUTHN_REQUEST,
+                    message);
     }
     else {
-        handleEvent(rc, bsl::string(), Event::e_NEGOTIATION_MESSAGE, message);
+        handleEvent(rc,
+                    bsl::string(),
+                    InitialConnectionEvent::e_NEGOTIATION_MESSAGE,
+                    message);
     }
 
     return rc_SUCCESS;
@@ -468,15 +474,17 @@ void InitialConnectionContext::readCallback(const bmqio::Status& status,
 
     if (!status) {
         errStream << "Read error: " << status;
-        handleEvent(rc_READ_BLOB_ERROR, errStream.str(), Event::e_ERROR);
+        handleEvent(rc_READ_BLOB_ERROR,
+                    errStream.str(),
+                    InitialConnectionEvent::e_ERROR);
         return;  // RETURN
     }
 
     rc = readBlob(errStream, &outPacket, &isFullBlob, numNeeded, blob);
     if (rc != rc_SUCCESS) {
         handleEvent((rc * 10) + rc_READ_BLOB_ERROR,
                     errStream.str(),
-                    Event::e_ERROR);
+                    InitialConnectionEvent::e_ERROR);
         return;  // RETURN
     }
 
@@ -488,7 +496,7 @@ void InitialConnectionContext::readCallback(const bmqio::Status& status,
     if (rc != rc_SUCCESS) {
         handleEvent((rc * 10) + rc_PROCESS_BLOB_ERROR,
                     errStream.str(),
-                    Event::e_ERROR);
+                    InitialConnectionEvent::e_ERROR);
         return;  // RETURN
     }
 }
@@ -530,23 +538,21 @@ void InitialConnectionContext::handleInitialConnection()
         // `negotiateOutbound`.
         handleEvent(0,
                     bsl::string(),
-                    mqbnet::InitialConnectionEvent::e_OUTBOUND_NEGOTATION);
+                    InitialConnectionEvent::e_OUTBOUND_NEGOTATION);
     }
     else {
         bmqu::MemOutStream errStream;
         const int          rc = scheduleRead(errStream);
         if (rc != 0) {
-            handleEvent(rc,
-                        errStream.str(),
-                        mqbnet::InitialConnectionEvent::e_ERROR);
+            handleEvent(rc, errStream.str(), InitialConnectionEvent::e_ERROR);
         }
     }
 }
 
 void InitialConnectionContext::handleEvent(
     int                                                   statusCode,
     const bsl::string&                                    errorDescription,
-    Event                                                 input,
+    InitialConnectionEvent::Enum                          input,
     const bsl::variant<bsl::monostate,
                        bmqp_ctrlmsg::AuthenticationMessage,
                        bmqp_ctrlmsg::NegotiationMessage>& message)
@@ -571,12 +577,12 @@ void InitialConnectionContext::handleEvent(
                   << "; peerUri = " << d_channelSp->peerUri()
                   << "; context address = " << this;
 
-    State oldState = d_state;
+    InitialConnectionState::Enum oldState = d_state;
 
     switch (input) {
-    case Event::e_OUTBOUND_NEGOTATION: {
-        if (oldState == State::e_INITIAL) {
-            setState(State::e_NEGOTIATING_OUTBOUND);
+    case InitialConnectionEvent::e_OUTBOUND_NEGOTATION: {
+        if (oldState == InitialConnectionState::e_INITIAL) {
+            setState(InitialConnectionState::e_NEGOTIATING_OUTBOUND);
 
             createNegotiationContext();
 
@@ -591,7 +597,7 @@ void InitialConnectionContext::handleEvent(
         }
         break;
     }
-    case Event::e_AUTHN_REQUEST: {
+    case InitialConnectionEvent::e_AUTHN_REQUEST: {
         if (!bsl::holds_alternative<bmqp_ctrlmsg::AuthenticationMessage>(
                 message)) {
             errStream << "Expecting AuthenticationMessage for event " << input
@@ -601,8 +607,8 @@ void InitialConnectionContext::handleEvent(
         const bmqp_ctrlmsg::AuthenticationMessage& authenticationMsg =
             bsl::get<bmqp_ctrlmsg::AuthenticationMessage>(message);
 
-        if (oldState == State::e_INITIAL) {
-            setState(State::e_AUTHENTICATING);
+        if (oldState == InitialConnectionState::e_INITIAL) {
+            setState(InitialConnectionState::e_AUTHENTICATING);
 
             rc = d_authenticator_p->handleAuthentication(errStream,
                                                          self,
@@ -614,7 +620,7 @@ void InitialConnectionContext::handleEvent(
         }
         break;
     }
-    case Event::e_NEGOTIATION_MESSAGE: {
+    case InitialConnectionEvent::e_NEGOTIATION_MESSAGE: {
         if (!bsl::holds_alternative<bmqp_ctrlmsg::NegotiationMessage>(
                 message)) {
             errStream << "Expecting NegotiationMessage for event " << input
@@ -624,27 +630,27 @@ void InitialConnectionContext::handleEvent(
         const bmqp_ctrlmsg::NegotiationMessage& negotiationMsg =
             bsl::get<bmqp_ctrlmsg::NegotiationMessage>(message);
 
-        if (oldState == State::e_INITIAL &&
+        if (oldState == InitialConnectionState::e_INITIAL &&
             negotiationMsg.isClientIdentityValue()) {
-            setState(State::e_ANON_AUTHENTICATING);
+            setState(InitialConnectionState::e_ANON_AUTHENTICATING);
 
             createNegotiationContext();
             negotiationContext()->setNegotiationMessage(negotiationMsg);
 
             rc = handleAnonAuthentication(errStream);
         }
-        else if (oldState == State::e_AUTHENTICATED &&
+        else if (oldState == InitialConnectionState::e_AUTHENTICATED &&
                  negotiationMsg.isClientIdentityValue()) {
-            setState(State::e_NEGOTIATED);
+            setState(InitialConnectionState::e_NEGOTIATED);
 
             createNegotiationContext();
             negotiationContext()->setNegotiationMessage(negotiationMsg);
 
             rc = rc_SUCCESS;
         }
-        else if (oldState == State::e_NEGOTIATING_OUTBOUND &&
+        else if (oldState == InitialConnectionState::e_NEGOTIATING_OUTBOUND &&
                  negotiationMsg.isBrokerResponseValue()) {
-            setState(State::e_NEGOTIATED);
+            setState(InitialConnectionState::e_NEGOTIATED);
 
             BSLS_ASSERT_SAFE(negotiationContext());
             negotiationContext()->setNegotiationMessage(negotiationMsg);
@@ -658,15 +664,15 @@ void InitialConnectionContext::handleEvent(
         }
         break;
     }
-    case Event::e_AUTHN_SUCCESS: {
-        if (oldState == State::e_AUTHENTICATING) {
-            setState(State::e_AUTHENTICATED);
+    case InitialConnectionEvent::e_AUTHN_SUCCESS: {
+        if (oldState == InitialConnectionState::e_AUTHENTICATING) {
+            setState(InitialConnectionState::e_AUTHENTICATED);
 
             // Now read Negotiation message
             rc = scheduleRead(errStream);
         }
-        else if (oldState == State::e_ANON_AUTHENTICATING) {
-            setState(State::e_NEGOTIATED);
+        else if (oldState == InitialConnectionState::e_ANON_AUTHENTICATING) {
+            setState(InitialConnectionState::e_NEGOTIATED);
 
             BSLS_ASSERT_SAFE(negotiationContext());
             BSLS_ASSERT_SAFE(negotiationContext()
@@ -681,11 +687,11 @@ void InitialConnectionContext::handleEvent(
         }
         break;
     }
-    case Event::e_ERROR: {
+    case InitialConnectionEvent::e_ERROR: {
         rc = statusCode;
         errStream << errorDescription;
     } break;
-    case Event::e_NONE: {
+    case InitialConnectionEvent::e_NONE: {
         // NOT IMPLEMENTED
         BSLS_ASSERT_SAFE(!"Unexpected event received: " + input);
         break;
@@ -700,12 +706,12 @@ void InitialConnectionContext::handleEvent(
 
     bsl::shared_ptr<mqbnet::Session> session;
 
-    if (rc == rc_SUCCESS && d_state == State::e_NEGOTIATED) {
+    if (rc == rc_SUCCESS && d_state == InitialConnectionState::e_NEGOTIATED) {
         rc = d_negotiator_p->createSessionOnMsgType(errStream, &session, this);
         BALL_LOG_INFO << "Created a session with " << channel()->peerUri();
     }
 
-    if (rc != rc_SUCCESS || d_state == State::e_NEGOTIATED) {
+    if (rc != rc_SUCCESS || d_state == InitialConnectionState::e_NEGOTIATED) {
         BALL_LOG_INFO << "Finished initial connection with rc = " << rc
                       << ", error = '" << errStream.str() << "'";
         guard.release()->unlock();