change auth response failure and destroy auth response msg and code style

example/couchbase_c++/client.cpp

@@ -24,8 +24,7 @@
 
 DEFINE_int32(thread_num, 10, "Number of threads to send requests");
 DEFINE_bool(use_bthread, false, "Use bthread to send requests");
-DEFINE_string(connection_type, "",
-              "Connection type. Available values: single, pooled, short");
+DEFINE_string(connection_type, "", "Connection type. Available values: single, pooled, short");
 DEFINE_string(server, "0.0.0.0:11211", "IP Address of server");
 DEFINE_string(bucket_name, "", "Couchbase bucktet name");
 DEFINE_string(bucket_password, "", "Couchbase bucket password");
@@ -33,8 +32,7 @@ DEFINE_string(load_balancer, "", "The algorithm for load balancing");
 DEFINE_int32(timeout_ms, 100, "RPC timeout in milliseconds");
 DEFINE_int32(max_retry, 3, "Max retries(not including the first RPC)"); 
 DEFINE_bool(dont_fail, false, "Print fatal when some call failed");
-DEFINE_int32(exptime, 0,
-             "The to-be-got data will be expired after so many seconds");
+DEFINE_int32(exptime, 0, "The to-be-got data will be expired after so many seconds");
 DEFINE_string(key, "hello", "The key to be get");
 DEFINE_string(value, "world", "The value associated with the key");
 DEFINE_int32(batch, 1, "Pipelined Operations");
@@ -46,17 +44,14 @@ butil::static_atomic<int> g_sender_count = BUTIL_STATIC_ATOMIC_INIT(0);
 static void* sender(void* arg) {
     google::protobuf::RpcChannel* channel = 
         static_cast<google::protobuf::RpcChannel*>(arg);
-  const int base_index =
-      g_sender_count.fetch_add(1, butil::memory_order_relaxed);
+    const int base_index = g_sender_count.fetch_add(1, butil::memory_order_relaxed);
 
     std::string value;
-  std::vector<std::pair<std::string, std::string>> kvs;
+    std::vector<std::pair<std::string, std::string> > kvs;
     kvs.resize(FLAGS_batch);
     for (int i = 0; i < FLAGS_batch; ++i) {
-    kvs[i].first =
-        butil::string_printf("%s%d", FLAGS_key.c_str(), base_index + i);
-    kvs[i].second =
-        butil::string_printf("%s%d", FLAGS_value.c_str(), base_index + i);
+        kvs[i].first = butil::string_printf("%s%d", FLAGS_key.c_str(), base_index + i);
+        kvs[i].second = butil::string_printf("%s%d", FLAGS_value.c_str(), base_index + i);
     }
     brpc::MemcacheRequest request;
     for (int i = 0; i < FLAGS_batch; ++i) {
@@ -81,9 +76,10 @@ static void* sender(void* arg) {
                     brpc::AskToQuit();
                     return NULL;
                 }
-        CHECK(flags == 0xdeadbeef + base_index + i) << "flags=" << flags;
-        CHECK(kvs[i].second == value) << "base=" << base_index << " i=" << i
-                                      << " value=" << value;
+                CHECK(flags == 0xdeadbeef + base_index + i)
+                    << "flags=" << flags;
+                CHECK(kvs[i].second == value)
+                    << "base=" << base_index << " i=" << i << " value=" << value;
             }
         } else {
             g_error_count << 1; 
@@ -111,16 +107,15 @@ int main(int argc, char* argv[]) {
     brpc::Channel channel;
     brpc::policy::CouchbaseAuthenticator auth(FLAGS_bucket_name,
                                               FLAGS_bucket_password);
+    
     // Initialize the channel, NULL means using default options. 
     brpc::ChannelOptions options;
     options.protocol = brpc::PROTOCOL_MEMCACHE;
     options.connection_type = FLAGS_connection_type;
-  options.timeout_ms = FLAGS_timeout_ms /*milliseconds*/;
+    options.timeout_ms = FLAGS_timeout_ms/*milliseconds*/;
     options.max_retry = FLAGS_max_retry;
     options.auth = &auth;
-
-  if (channel.Init(FLAGS_server.c_str(), FLAGS_load_balancer.c_str(),
-                   &options) != 0) {
+    if (channel.Init(FLAGS_server.c_str(), FLAGS_load_balancer.c_str(), &options) != 0) {
         LOG(ERROR) << "Fail to initialize channel";
         return -1;
     }
@@ -145,9 +140,8 @@ int main(int argc, char* argv[]) {
     }
     for (int i = 0; i < FLAGS_batch * FLAGS_thread_num; ++i) {
         if (!response.PopSet(NULL)) {
-      LOG(ERROR) << "Fail to SET memcache, i=" << i << ", "
-                 << response.LastError();
-      CHECK(response.IsAuthFailure());
+            LOG(ERROR) << "Fail to SET memcache, i=" << i
+                       << ", " << response.LastError();
             return -1;
         }
     }
@@ -170,7 +164,8 @@ int main(int argc, char* argv[]) {
         }
     } else {
         for (int i = 0; i < FLAGS_thread_num; ++i) {
-      if (bthread_start_background(&tids[i], NULL, sender, &channel) != 0) {
+            if (bthread_start_background(
+                    &tids[i], NULL, sender, &channel) != 0) {
                 LOG(ERROR) << "Fail to create bthread";
                 return -1;
             }
@@ -179,8 +174,7 @@ int main(int argc, char* argv[]) {
 
     while (!brpc::IsAskedToQuit()) {
         sleep(1);
-    LOG(INFO) << "Accessing memcache server at qps="
-              << g_latency_recorder.qps(1)
+        LOG(INFO) << "Accessing memcache server at qps=" << g_latency_recorder.qps(1)
                   << " latency=" << g_latency_recorder.latency(1);
     }
 

src/brpc/memcache.h

@@ -230,12 +230,6 @@ public:
 
     static const char* status_str(Status);
 
-    // Although the implementation of this function looks somewhat weird, 
-    // we did not find a better way to provide auth failure check for user codes.
-    bool IsAuthFailure() const { 
-        return (_err == "Auth failure");
-    }
-
 private:
     bool PopCounter(uint8_t command, uint64_t* new_value, uint64_t* cas_value);
     bool PopStore(uint8_t command, uint64_t* cas_value);

src/brpc/policy/couchbase_authenticator.cpp

@@ -41,15 +41,14 @@ int CouchbaseAuthenticator::GenerateCredential(std::string* auth_str) const {
         butil::HostToNet32(sizeof(kPlainAuthCommand) + 1 +
                            bucket_name_.length() * 2 + bucket_password_.length()),
         0, 0};
-  butil::IOBuf in;
-  in.append(&header, sizeof(header));
-  in.append(kPlainAuthCommand, sizeof(kPlainAuthCommand) - 1);
-  in.append(bucket_name_.c_str(), bucket_name_.length());
-  in.append(kPadding, sizeof(kPadding));
-  in.append(bucket_name_.c_str(), bucket_name_.length());
-  in.append(kPadding, sizeof(kPadding));
-  in.append(bucket_password_.c_str(), bucket_password_.length());
-  auth_str->assign(in.to_string().c_str(), in.size());
+    auth_str->clear();
+    auth_str->append(reinterpret_cast<const char*>(&header), sizeof(header));
+    auth_str->append(kPlainAuthCommand, sizeof(kPlainAuthCommand) - 1);
+    auth_str->append(bucket_name_);
+    auth_str->append(kPadding, sizeof(kPadding));
+    auth_str->append(bucket_name_);
+    auth_str->append(kPadding, sizeof(kPadding));
+    auth_str->append(bucket_password_);
     return 0;
 }
 

src/brpc/policy/memcache_binary_protocol.cpp

@@ -130,8 +130,11 @@ ParseResult ParseMemcacheMessage(butil::IOBuf* source,
             if (header->status != 0) {
                 LOG(ERROR) << "Failed to authenticate the couchbase bucket."
                            << "All the following commands will result in auth failure.";
+                return MakeParseError(PARSE_ERROR_NO_RESOURCE, 
+                                      "Fail to authenticate with the couchbase bucket");
             }
-            msg = static_cast<MostCommonMessage*>(socket->release_parsing_context());
+            DestroyingPtr<MostCommonMessage> auth_msg(
+                 static_cast<MostCommonMessage*>(socket->release_parsing_context()));
             socket->GivebackPipelinedInfo(pi);
         } else {
             if (++msg->pi.count >= pi.count) {