refine FlashService

dbms/src/Flash/FlashService.cpp

@@ -44,15 +44,15 @@ extern const int NOT_IMPLEMENTED;
 
 constexpr char tls_err_msg[] = "common name check is failed";
 
-FlashService::FlashService(IServer & server_)
-    : server(server_)
-    , security_config(server_.securityConfig())
+FlashService::FlashService(const TiFlashSecurityConfig & security_config_, Context & context_)
+    : security_config(security_config_)
+    , m_context(context_)
     , log(&Poco::Logger::get("FlashService"))
     , manual_compact_manager(std::make_unique<Management::ManualCompactManager>(
-          server_.context().getGlobalContext(),
-          server_.context().getGlobalContext().getSettingsRef()))
+          m_context.getGlobalContext(),
+          m_context.getGlobalContext().getSettingsRef()))
 {
-    auto settings = server_.context().getSettingsRef();
+    auto settings = m_context.getSettingsRef();
     enable_local_tunnel = settings.enable_local_tunnel;
     enable_async_grpc_client = settings.enable_async_grpc_client;
     const size_t default_size = 2 * getNumberOfPhysicalCPUCores();
@@ -364,8 +364,8 @@ std::tuple<ContextPtr, grpc::Status> FlashService::createDBContext(const grpc::S
     try
     {
         /// Create DB context.
-        auto context = std::make_shared<Context>(server.context());
-        context->setGlobalContext(server.context());
+        auto context = std::make_shared<Context>(m_context);
+        context->setGlobalContext(m_context);
 
         /// Set a bunch of client information.
         std::string user = getClientMetaVarWithDefault(grpc_context, "user", "default");
@@ -411,17 +411,17 @@ std::tuple<ContextPtr, grpc::Status> FlashService::createDBContext(const grpc::S
     catch (Exception & e)
     {
         LOG_FMT_ERROR(log, "DB Exception: {}", e.message());
-        return std::make_tuple(std::make_shared<Context>(server.context()), grpc::Status(tiflashErrorCodeToGrpcStatusCode(e.code()), e.message()));
+        return std::make_tuple(std::make_shared<Context>(m_context), grpc::Status(tiflashErrorCodeToGrpcStatusCode(e.code()), e.message()));
     }
     catch (const std::exception & e)
     {
         LOG_FMT_ERROR(log, "std exception: {}", e.what());
-        return std::make_tuple(std::make_shared<Context>(server.context()), grpc::Status(grpc::StatusCode::INTERNAL, e.what()));
+        return std::make_tuple(std::make_shared<Context>(m_context), grpc::Status(grpc::StatusCode::INTERNAL, e.what()));
     }
     catch (...)
     {
         LOG_FMT_ERROR(log, "other exception");
-        return std::make_tuple(std::make_shared<Context>(server.context()), grpc::Status(grpc::StatusCode::INTERNAL, "other exception"));
+        return std::make_tuple(std::make_shared<Context>(m_context), grpc::Status(grpc::StatusCode::INTERNAL, "other exception"));
     }
 }
 

dbms/src/Flash/FlashService.h

@@ -46,7 +46,7 @@ class FlashService : public tikvpb::Tikv::Service
     , private boost::noncopyable
 {
 public:
-    explicit FlashService(IServer & server_);
+    FlashService(const TiFlashSecurityConfig & security_config_, Context & context_);
 
     ~FlashService() override;
 
@@ -83,8 +83,8 @@ class FlashService : public tikvpb::Tikv::Service
 protected:
     std::tuple<ContextPtr, ::grpc::Status> createDBContext(const grpc::ServerContext * grpc_context) const;
 
-    IServer & server;
     const TiFlashSecurityConfig & security_config;
+    Context & m_context;
     Poco::Logger * log;
     bool is_async = false;
     bool enable_local_tunnel = false;
@@ -103,8 +103,8 @@ class AsyncFlashService final : public FlashService
     // 48 is EstablishMPPConnection API ID of GRPC
     // note: if the kvrpc protocal is updated, please keep consistent with the generated code.
     static constexpr int EstablishMPPConnectionApiID = 48;
-    explicit AsyncFlashService(IServer & server)
-        : FlashService(server)
+    AsyncFlashService(const TiFlashSecurityConfig & security_config_, Context & context_)
+        : FlashService(security_config_, context_)
     {
         is_async = true;
         ::grpc::Service::MarkMethodAsync(EstablishMPPConnectionApiID);

dbms/src/Server/Server.cpp

@@ -598,9 +598,9 @@ class Server::FlashGrpcServerHolder
         /// Init and register flash service.
         bool enable_async_server = server.context().getSettingsRef().enable_async_server;
         if (enable_async_server)
-            flash_service = std::make_unique<AsyncFlashService>(server);
+            flash_service = std::make_unique<AsyncFlashService>(server.securityConfig(), server.context());
         else
-            flash_service = std::make_unique<FlashService>(server);
+            flash_service = std::make_unique<FlashService>(server.securityConfig(), server.context());
         diagnostics_service = std::make_unique<DiagnosticsService>(server);
         builder.SetOption(grpc::MakeChannelArgumentOption(GRPC_ARG_HTTP2_MIN_RECV_PING_INTERVAL_WITHOUT_DATA_MS, 5 * 1000));
         builder.SetOption(grpc::MakeChannelArgumentOption(GRPC_ARG_HTTP2_MIN_SENT_PING_INTERVAL_WITHOUT_DATA_MS, 10 * 1000));