feat: add health_check_option.h

Author: zhoukangsheng

src/brpc/channel.h

@@ -36,7 +36,7 @@
 #include "brpc/retry_policy.h"
 #include "brpc/backup_request_policy.h"
 #include "brpc/naming_service_filter.h"
-#include "brpc/socket.h"
+#include "brpc/health_check_option.h"
 
 namespace brpc {
 

src/brpc/details/health_check.cpp

@@ -57,8 +57,7 @@ class OnAppHealthCheckDone : public google::protobuf::Closure {
     SocketId id;
     int64_t interval_s;
     int64_t last_check_time_ms;
-    int32_t health_check_timeout_ms;
-    std::string health_check_path;
+    HealthCheckOption hc_option;
 };
 
 class HealthCheckManager {
@@ -79,13 +78,12 @@ void HealthCheckManager::StartCheck(SocketId id, int64_t check_interval_s) {
     OnAppHealthCheckDone* done = new OnAppHealthCheckDone;
     done->id = id;
     done->interval_s = check_interval_s;
-    done->health_check_timeout_ms = ptr->health_check_timeout_ms();
-    done->health_check_path = ptr->health_check_path();
+    done->hc_option = ptr->_hc_option;
     brpc::ChannelOptions options;
     options.protocol = PROTOCOL_HTTP;
     options.max_retry = 0;
     options.timeout_ms =
-        std::min((int64_t)(done->health_check_timeout_ms), check_interval_s * 1000);
+        std::min((int64_t)(done->hc_option.health_check_timeout_ms), check_interval_s * 1000);
     if (done->channel.Init(id, &options) != 0) {
         LOG(WARNING) << "Fail to init health check channel to SocketId=" << id;
         ptr->_ninflight_app_health_check.fetch_sub(
@@ -99,7 +97,7 @@ void HealthCheckManager::StartCheck(SocketId id, int64_t check_interval_s) {
 void* HealthCheckManager::AppCheck(void* arg) {
     OnAppHealthCheckDone* done = static_cast<OnAppHealthCheckDone*>(arg);
     done->cntl.Reset();
-    done->cntl.http_request().uri() = done->health_check_path;
+    done->cntl.http_request().uri() = done->hc_option.health_check_path;
     ControllerPrivateAccessor(&done->cntl).set_health_check_call();
     done->last_check_time_ms = butil::gettimeofday_ms();
     done->channel.CallMethod(NULL, &done->cntl, NULL, NULL, done);
@@ -117,14 +115,14 @@ void OnAppHealthCheckDone::Run() {
     }
     if (!cntl.Failed() || ptr->Failed()) {
         LOG_IF(INFO, !cntl.Failed()) << "Succeeded to call "
-            << ptr->remote_side() << health_check_path;
+            << ptr->remote_side() << hc_option.health_check_path;
         // if ptr->Failed(), previous SetFailed would trigger next round
         // of hc, just return here.
         ptr->_ninflight_app_health_check.fetch_sub(
                     1, butil::memory_order_relaxed);
         return;
     }
-    RPC_VLOG << "Fail to check path=" << health_check_path
+    RPC_VLOG << "Fail to check path=" << hc_option.health_check_path
         << ", " << cntl.ErrorText();
 
     int64_t sleep_time_ms =

src/brpc/health_check_option.h

@@ -0,0 +1,34 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#ifndef  BRPC_HEALTH_CHECK_OPTION_H
+#define  BRPC_HEALTH_CHECK_OPTION_H
+
+#include <string>
+
+namespace brpc {
+
+struct HealthCheckOption {
+    // Http path of health check call
+    std::string health_check_path;
+    // The timeout for both establishing the connection and the http call to health_check_path over the connection
+    int32_t health_check_timeout_ms{500};
+};
+
+}  // namespace brpc
+
+#endif  // BRPC_HEALTH_CHECK_OPTION_H

src/brpc/socket.cpp

@@ -742,8 +742,7 @@ int Socket::OnCreated(const SocketOptions& options) {
     reset_parsing_context(options.initial_parsing_context);
     _correlation_id = 0;
     _health_check_interval_s = options.health_check_interval_s;
-    _health_check_path =  options.hc_option.health_check_path;
-    _health_check_timeout_ms = options.hc_option.health_check_timeout_ms;
+    _hc_option = options.hc_option;
     _is_hc_related_ref_held = false;
     _hc_started.store(false, butil::memory_order_relaxed);
     _ninprocess.store(1, butil::memory_order_relaxed);
@@ -2594,7 +2593,7 @@ int Socket::CheckHealth() {
         LOG(INFO) << "Checking " << *this;
     }
     const timespec duetime =
-        butil::milliseconds_from_now(_health_check_timeout_ms);
+        butil::milliseconds_from_now(_hc_option.health_check_timeout_ms);
     const int connected_fd = Connect(&duetime, NULL, NULL);
     if (connected_fd >= 0) {
         ::close(connected_fd);

src/brpc/socket.h

@@ -41,6 +41,7 @@
 #include "brpc/http_method.h"
 #include "brpc/event_dispatcher.h"
 #include "brpc/versioned_ref_with_id.h"
+#include "brpc/health_check_option.h"
 
 namespace brpc {
 namespace policy {
@@ -242,13 +243,6 @@ struct SocketKeepaliveOptions {
     int keepalive_count{-1};
 };
 
-struct HealthCheckOption {
-    // Http path of health check call
-    std::string health_check_path;
-    // The timeout for both establishing the connection and the http call to health_check_path over the connection
-    int32_t health_check_timeout_ms{500};
-};
-
 // TODO: Comment fields
 struct SocketOptions {
     // If `fd' is non-negative, set `fd' to be non-blocking and take the
@@ -420,9 +414,9 @@ friend void DereferenceSocket(Socket*);
     // Initialized by SocketOptions.health_check_interval_s.
     int health_check_interval() const { return _health_check_interval_s; }
 
-    const std::string& health_check_path() const { return _health_check_path; }
+    const std::string& health_check_path() const { return _hc_option.health_check_path; }
 
-    int32_t health_check_timeout_ms() const {return _health_check_timeout_ms; }
+    int32_t health_check_timeout_ms() const {return _hc_option.health_check_timeout_ms; }
 
     // True if health checking is enabled.
     bool HCEnabled() const {
@@ -992,8 +986,7 @@ friend void DereferenceSocket(Socket*);
     int _tcp_user_timeout_ms;
 
     HttpMethod _http_request_method;
-    std::string _health_check_path;
-    int32_t _health_check_timeout_ms{500};
+    HealthCheckOption _hc_option;
 };
 
 } // namespace brpc