call CredentialProvider everytime when authenticating

Signed-off-by: Emelia Lei <[email protected]>

Author: emelialei88

src/groups/bmq/bmqa/bmqa_session.cpp

@@ -252,21 +252,6 @@ int SessionUtil::createApplication(SessionImpl* sessionImpl)
 
     static bsls::AtomicInt s_sessionInstanceCount(0);
 
-    // Authentication Message
-    bmqp_ctrlmsg::AuthenticationMessage authenticaionMessage;
-
-    bmqt::AuthnCredential                             credential;
-    const bsl::shared_ptr<bmqpi::CredentialProvider>& credentialProvider =
-        sessionImpl->d_sessionOptions.credentialProvider();
-    if (credentialProvider) {
-        credentialProvider->loadCredential(&credential);
-
-        bmqp_ctrlmsg::AuthenticateRequest& ar =
-            authenticaionMessage.makeAuthenticateRequest();
-        ar.mechanism() = credential.mechanism();
-        ar.data()      = credential.data();
-    }
-
     // Negotiation Message
     bmqp_ctrlmsg::NegotiationMessage negotiationMessage;
     bmqp_ctrlmsg::ClientIdentity& ci = negotiationMessage.makeClientIdentity();
@@ -332,7 +317,6 @@ int SessionUtil::createApplication(SessionImpl* sessionImpl)
     sessionImpl->d_application_mp.load(
         new (*(sessionImpl->d_allocator_p))
             bmqimp::Application(options,
-                                authenticaionMessage,
                                 negotiationMessage,
                                 eventHandler,
                                 sessionImpl->d_allocator_p),

src/groups/bmq/bmqimp/bmqimp_application.cpp

@@ -555,11 +555,10 @@ Application::stateCb(bmqimp::BrokerSession::State::Enum    oldState,
 }
 
 Application::Application(
-    const bmqt::SessionOptions&                sessionOptions,
-    const bmqp_ctrlmsg::AuthenticationMessage& authenticationMessage,
-    const bmqp_ctrlmsg::NegotiationMessage&    negotiationMessage,
-    const EventQueue::EventHandlerCallback&    eventHandlerCB,
-    bslma::Allocator*                          allocator)
+    const bmqt::SessionOptions&             sessionOptions,
+    const bmqp_ctrlmsg::NegotiationMessage& negotiationMessage,
+    const EventQueue::EventHandlerCallback& eventHandlerCB,
+    bslma::Allocator*                       allocator)
 : d_allocatorStatContext(bmqst::StatContextConfiguration("Allocators",
                                                          allocator),
                          allocator)
@@ -605,12 +604,13 @@ Application::Application(
           allocator),
       allocator)
 , d_initialConnectionChannelFactory(
-      InitialConnectionChannelFactoryConfig(&d_statChannelFactory,
-                                            authenticationMessage,
-                                            negotiationMessage,
-                                            sessionOptions.connectTimeout(),
-                                            d_blobSpPool_sp.get(),
-                                            allocator),
+      InitialConnectionChannelFactoryConfig(
+          &d_statChannelFactory,
+          negotiationMessage,
+          sessionOptions.connectTimeout(),
+          sessionOptions.credentialProvider().get(),
+          d_blobSpPool_sp.get(),
+          allocator),
       allocator)
 , d_connectHandle_mp()
 , d_brokerSession(&d_scheduler,

src/groups/bmq/bmqimp/bmqimp_application.h

@@ -253,12 +253,10 @@ class Application {
     /// negotiation.  The application will use the specified
     /// `eventHandlerCB`.  Use the specified `allocator` for all memory
     /// allocations.
-    Application(
-        const bmqt::SessionOptions&                sessionOptions,
-        const bmqp_ctrlmsg::AuthenticationMessage& authenticationMessage,
-        const bmqp_ctrlmsg::NegotiationMessage&    negotiationMessage,
-        const EventQueue::EventHandlerCallback&    eventHandlerCB,
-        bslma::Allocator*                          allocator);
+    Application(const bmqt::SessionOptions&             sessionOptions,
+                const bmqp_ctrlmsg::NegotiationMessage& negotiationMessage,
+                const EventQueue::EventHandlerCallback& eventHandlerCB,
+                bslma::Allocator*                       allocator);
 
     /// Destructor
     ~Application();

src/groups/bmq/bmqimp/bmqimp_application.t.cpp

@@ -52,7 +52,6 @@ static void test1_breathingTest()
     bmqimp::EventQueue::EventHandlerCallback emptyEventHandler;
 
     bmqimp::Application obj(options,
-                            authenticaionMessage,
                             negotiationMessage,
                             emptyEventHandler,
                             bmqtst::TestHelperUtil::allocator());
@@ -88,7 +87,6 @@ static void test2_startStopTest()
     bmqimp::EventQueue::EventHandlerCallback emptyEventHandler;
 
     bmqimp::Application obj(options,
-                            authenticaionMessage,
                             negotiationMessage,
                             emptyEventHandler,
                             bmqtst::TestHelperUtil::allocator());
@@ -143,7 +141,6 @@ static void test3_startStopAsyncTest()
     bmqimp::EventQueue::EventHandlerCallback emptyEventHandler;
 
     bmqimp::Application obj(options,
-                            authenticaionMessage,
                             negotiationMessage,
                             emptyEventHandler,
                             bmqtst::TestHelperUtil::allocator());

src/groups/bmq/bmqimp/bmqimp_initialconnectionchannelfactory.cpp

@@ -24,6 +24,8 @@
 #include <bmqsys_time.h>
 
 #include <bmqio_channelutil.h>
+#include <bmqpi_credentialprovider.h>
+#include <bmqt_authncredential.h>
 #include <bmqu_blob.h>
 #include <bmqu_memoutstream.h>
 #include <bmqu_weakmemfn.h>
@@ -69,16 +71,17 @@ enum RcEnum {
 // ------------------------------------
 
 InitialConnectionChannelFactoryConfig::InitialConnectionChannelFactoryConfig(
-    bmqio::ChannelFactory*                     base,
-    const bmqp_ctrlmsg::AuthenticationMessage& authenticationMessage,
-    const bmqp_ctrlmsg::NegotiationMessage&    negotiationMessage,
-    const bsls::TimeInterval&                  connectTimeout,
-    BlobSpPool*                                blobSpPool_p,
-    bslma::Allocator*                          basicAllocator)
+    bmqio::ChannelFactory*                  base,
+    const bmqp_ctrlmsg::NegotiationMessage& negotiationMessage,
+    const bsls::TimeInterval&               connectTimeout,
+    bmqpi::CredentialProvider*              credentialProvider,
+    BlobSpPool*                             blobSpPool_p,
+    bslma::Allocator*                       basicAllocator)
 : d_baseFactory_p(base)
-, d_authenticationMessage(authenticationMessage, basicAllocator)
 , d_negotiationMessage(negotiationMessage, basicAllocator)
+, d_authenticationMessage()
 , d_connectTimeout(connectTimeout)
+, d_credentialProvider_p(credentialProvider)
 , d_blobSpPool_p(blobSpPool_p)
 , d_allocator_p(bslma::Default::allocator(basicAllocator))
 {
@@ -90,9 +93,10 @@ InitialConnectionChannelFactoryConfig::InitialConnectionChannelFactoryConfig(
     const InitialConnectionChannelFactoryConfig& original,
     bslma::Allocator*                            basicAllocator)
 : d_baseFactory_p(original.d_baseFactory_p)
-, d_authenticationMessage(original.d_authenticationMessage, basicAllocator)
 , d_negotiationMessage(original.d_negotiationMessage, basicAllocator)
+, d_authenticationMessage(original.d_authenticationMessage, basicAllocator)
 , d_connectTimeout(original.d_connectTimeout)
+, d_credentialProvider_p(original.d_credentialProvider_p)
 , d_blobSpPool_p(original.d_blobSpPool_p)
 , d_allocator_p(bslma::Default::allocator(basicAllocator))
 {
@@ -125,14 +129,14 @@ void InitialConnectionChannelFactory::baseResultCallback(
     const ResultCallback&                  userCb,
     bmqio::ChannelFactoryEvent::Enum       event,
     const bmqio::Status&                   status,
-    const bsl::shared_ptr<bmqio::Channel>& channel) const
+    const bsl::shared_ptr<bmqio::Channel>& channel)
 {
     if (event != bmqio::ChannelFactoryEvent::e_CHANNEL_UP) {
         userCb(event, status, channel);
         return;  // RETURN
     }
 
-    authenticate(channel, userCb);
+    initialConnect(channel, userCb);
 }
 
 void InitialConnectionChannelFactory::sendRequest(
@@ -248,22 +252,37 @@ void InitialConnectionChannelFactory::readResponse(
     }
 }
 
+void InitialConnectionChannelFactory::initialConnect(
+    const bsl::shared_ptr<bmqio::Channel>& channel,
+    const ResultCallback&                  cb)
+{
+    authenticate(channel, cb);
+    negotiate(channel, cb);
+}
+
 void InitialConnectionChannelFactory::authenticate(
     const bsl::shared_ptr<bmqio::Channel>& channel,
-    const ResultCallback&                  cb) const
+    const ResultCallback&                  cb)
 {
     BALL_LOG_INFO << "Client authenticate";
 
-    // If the authentication message is not an AuthenticateRequest, it means no
-    // credential is provided. In this case, we will skip the authentication
-    // step and proceed directly to the negotiation step.
-    if (!d_config.d_authenticationMessage.isAuthenticateRequestValue()) {
-        negotiate(channel, cb);
-        return;  // RETURN
-    }
+    // If there's no CredentialProvider, it means no credential is provided. In
+    // this case, we will skip authentication.
+    if (d_config.d_credentialProvider_p) {
+        bmqt::AuthnCredential credential;
+        d_config.d_credentialProvider_p->loadCredential(&credential);
 
-    sendRequest(channel, AUTHENTICATION, cb);
-    readResponse(channel, AUTHENTICATION, cb);
+        bmqp_ctrlmsg::AuthenticationMessage authenticaionMessage;
+        bmqp_ctrlmsg::AuthenticateRequest&  ar =
+            authenticaionMessage.makeAuthenticateRequest();
+        ar.mechanism() = credential.mechanism();
+        ar.data()      = credential.data();
+
+        d_config.d_authenticationMessage = authenticaionMessage;
+
+        sendRequest(channel, AUTHENTICATION, cb);
+        readResponse(channel, AUTHENTICATION, cb);
+    }
 }
 
 void InitialConnectionChannelFactory::negotiate(

src/groups/bmq/bmqimp/bmqimp_initialconnectionchannelfactory.h

@@ -37,6 +37,7 @@
 #include <bmqio_status.h>
 #include <bmqp_blobpoolutil.h>
 #include <bmqp_ctrlmsg_messages.h>
+#include <bmqpi_credentialprovider.h>
 #include <bmqu_sharedresource.h>
 
 // BDE
@@ -66,9 +67,10 @@ class InitialConnectionChannelFactoryConfig {
   private:
     // PRIVATE DATA
     bmqio::ChannelFactory*              d_baseFactory_p;
-    bmqp_ctrlmsg::AuthenticationMessage d_authenticationMessage;
     bmqp_ctrlmsg::NegotiationMessage    d_negotiationMessage;
+    bmqp_ctrlmsg::AuthenticationMessage d_authenticationMessage;
     bsls::TimeInterval                  d_connectTimeout;
+    bmqpi::CredentialProvider*          d_credentialProvider_p;
     BlobSpPool*                         d_blobSpPool_p;
     bslma::Allocator*                   d_allocator_p;
 
@@ -82,12 +84,12 @@ class InitialConnectionChannelFactoryConfig {
 
     // CREATORS
     InitialConnectionChannelFactoryConfig(
-        bmqio::ChannelFactory*                     base,
-        const bmqp_ctrlmsg::AuthenticationMessage& authenticationMessage,
-        const bmqp_ctrlmsg::NegotiationMessage&    negotiationMessage,
-        const bsls::TimeInterval&                  d_connectTimeout,
-        BlobSpPool*                                blobSpPool_p,
-        bslma::Allocator*                          basicAllocator = 0);
+        bmqio::ChannelFactory*                  base,
+        const bmqp_ctrlmsg::NegotiationMessage& negotiationMessage,
+        const bsls::TimeInterval&               connectTimeout,
+        bmqpi::CredentialProvider*              credentialProvider_p,
+        BlobSpPool*                             blobSpPool_p,
+        bslma::Allocator*                       basicAllocator = 0);
 
     InitialConnectionChannelFactoryConfig(
         const InitialConnectionChannelFactoryConfig& original,
@@ -158,11 +160,10 @@ class InitialConnectionChannelFactory : public bmqio::ChannelFactory {
     // PRIVATE ACCESSORS
 
     /// Handle an event from our base ChannelFactory.
-    void
-    baseResultCallback(const ResultCallback&                  userCb,
-                       bmqio::ChannelFactoryEvent::Enum       event,
-                       const bmqio::Status&                   status,
-                       const bsl::shared_ptr<bmqio::Channel>& channel) const;
+    void baseResultCallback(const ResultCallback&                  userCb,
+                            bmqio::ChannelFactoryEvent::Enum       event,
+                            const bmqio::Status&                   status,
+                            const bsl::shared_ptr<bmqio::Channel>& channel);
 
     void sendRequest(const bsl::shared_ptr<bmqio::Channel>& channel,
                      const ACTION                           action,
@@ -172,8 +173,11 @@ class InitialConnectionChannelFactory : public bmqio::ChannelFactory {
                       const ACTION                           action,
                       const ResultCallback&                  cb) const;
 
+    void initialConnect(const bsl::shared_ptr<bmqio::Channel>& channel,
+                        const ResultCallback&                  cb);
+
     void authenticate(const bsl::shared_ptr<bmqio::Channel>& channel,
-                      const ResultCallback&                  cb) const;
+                      const ResultCallback&                  cb);
 
     void negotiate(const bsl::shared_ptr<bmqio::Channel>& channel,
                    const ResultCallback&                  cb) const;