add hard-coded deadline for reflection stream.

src/libCli/Call.cpp

@@ -190,17 +190,9 @@ namespace cli
             }           
         }
 
-        //before calling the RPC, close the DescDb connection with a timeout.
-        grpc::Status dbDescStatus = ConnectionManager::getInstance().closeDescDbWithDeadline(serverAddress, deadline);
-        if (not dbDescStatus.ok())
-        {
-            std::cerr << "Failed to close reflection stream ;( Status code: " << std::to_string(dbDescStatus.error_code()) << " " << cli::getGrpcStatusCodeAsString(dbDescStatus.error_code()) << ", error message: " << dbDescStatus.error_message() << std::endl;
-            if(dbDescStatus.error_code() == grpc::StatusCode::DEADLINE_EXCEEDED)
-            {
-                std::cerr << "Note: You can increase the deadline by setting the --rpcTimeoutMilliseconds option to a number or 'None'." << std::endl;
-            }
-            return -1;
-        }
+        //before calling the RPC, close the DescDb connection with a default timeout. We still continue with rpc call
+        //but remove the cache file if the stream was not closed gracefully so it fetches the reflection data again next time.
+        ConnectionManager::getInstance().closeDescDbStream(serverAddress);
 
         grpc::testing::CliCall call(channel, methodStr, clientMetadata, deadline);
 

src/libCli/ConnectionManager.cpp

@@ -65,17 +65,16 @@ namespace cli
         return m_connections[f_serverAddress].descPool;
     }
 
-    grpc::Status ConnectionManager::closeDescDbWithDeadline(std::string f_serverAddress,
-                                                    std::optional<std::chrono::time_point<std::chrono::system_clock>> deadline)
+    grpc::Status ConnectionManager::closeDescDbStream(std::string f_serverAddress)
     {
         if (m_connections[f_serverAddress].descDbProxy == nullptr)
         {
             std::cerr << "Error: Unable to close DescDb connection!" << std::endl;
             return grpc::Status( grpc::StatusCode::ABORTED, "descDbProxy has not been initialized.");
         }
 
-        //if proxy exists close the stream with a deadline.
-        grpc::Status status = m_connections[f_serverAddress].descDbProxy->closeDescDbStream(deadline);
+        //if proxy exists close the stream.
+        grpc::Status status = m_connections[f_serverAddress].descDbProxy->closeDescDbStream();
 
         //delete the proxy, findChannelByAddress() protects from accessing uninitialzed DbProxy.
         m_connections[f_serverAddress].descDbProxy.reset();

src/libCli/libCli/ConnectionManager.hpp

@@ -52,13 +52,11 @@ namespace cli
         /// @returns the gRpc DescriptorPool of the corresponding server address.
         std::shared_ptr<grpc::protobuf::DescriptorPool> getDescPool(std::string f_serverAddress, ArgParse::ParsedElement &f_parseTree);
 
-        /// @brief closes the DescDb stream with a given deadline.
+        /// @brief closes the DescDb stream with a default deadline of 20 seconds.
         /// @param f_serverAddress server addresss to lookup the assigned DescDbProxy.
-        /// @param deadline optional dealine for closing the stream.
         /// @return returns grpc::StatusCode::ABORTED status if no DescDb proxy is attached to the server address, 
         /// otherwise grpc status as a result of stream closure.
-        grpc::Status closeDescDbWithDeadline(std::string f_serverAddress,
-                                            std::optional<std::chrono::time_point<std::chrono::system_clock>> deadline);
+        grpc::Status closeDescDbStream(std::string f_serverAddress);
 
     private:
         ConnectionManager() {}

src/libLocalDescriptorCache/DescDbProxy.cpp

@@ -372,21 +372,29 @@ void DescDbProxy::getDescriptors(const std::string &f_hostAddress)
     }
 }
 
-grpc::Status DescDbProxy::closeDescDbStream(std::optional<std::chrono::time_point<std::chrono::system_clock>> deadline)
+grpc::Status DescDbProxy::closeDescDbStream()
 {
+    ::grpc::Status status;
     if ( m_reflectionDescDb == nullptr )
     {
-        return grpc::Status::OK;
+        return status;
     }
-    return m_reflectionDescDb->closeStreamWithDeadline(deadline);
+    status = m_reflectionDescDb->closeDescDbStream();
+    if(not status.ok())
+    {
+        //failure to close stream leads to invalid cache,
+        //removing it here so it will be written again next time.
+        std::string cacheFilePath = prepareCacheFile();
+        std::filesystem::remove(cacheFilePath);
+    }
+    return status;
 }
 
 DescDbProxy::DescDbProxy(bool disableCache, const std::string &hostAddress, std::shared_ptr<grpc::Channel> channel, 
                                                                             ArgParse::ParsedElement &parseTree)
 {
     m_channel = channel;
     m_parseTree = parseTree;
-    m_disableCache = disableCache;
     if(disableCache)
     {
         // Get Desc directly via reflection and without touching localDB
@@ -410,4 +418,13 @@ DescDbProxy::DescDbProxy(bool disableCache, const std::string &hostAddress, std:
     }
 }
 
-DescDbProxy::~DescDbProxy(){}
+DescDbProxy::~DescDbProxy()
+{
+    //This call is a noop if desc db stream is already closed.
+    //There are two scenarios when we close the stream here.
+    //i) Stream failed to close within a timeout. 
+    //   Our rpc may still succeed but this invalidates the cache so we remove the cache file,
+    //   to repopulate desc db on next rpc.
+    //íi) Stream successfully closed, leave the cache as it is.
+    closeDescDbStream(); 
+}

src/libLocalDescriptorCache/DescDbProxy.hpp

@@ -58,10 +58,9 @@ class DescDbProxy : public grpc::protobuf::DescriptorDatabase{
     /// @param hostAdress Address to the current host 
     void getDescriptors(const std::string &hostAddress);
 
-    /// @brief close the DescDb stream with a given deadline. If the dealine is not set it waits for the stream to close indefinitely.
-    /// @param deadline optional deadline to close the DescDb stream.
+    /// @brief close the DescDb stream with a default deadline.
     /// @return return grpc status as a result of call the finish() on the DescDb stream.
-    grpc::Status closeDescDbStream(std::optional<std::chrono::time_point<std::chrono::system_clock>> deadline);
+    grpc::Status closeDescDbStream();
 
     DescDbProxy(bool disableCache, const std::string &hostAddress, std::shared_ptr<grpc::Channel> channel, ArgParse::ParsedElement &parseTree);
 

third_party/gRPC_utils/gRPC_utils/proto_reflection_descriptor_database.h

@@ -82,10 +82,9 @@ class ProtoReflectionDescriptorDatabase : public protobuf::DescriptorDatabase {
   // Provide a list of full names of registered services
   bool GetServices(std::vector<grpc::string>* output);
 
-  /// @brief close the reflection stream with a given deadline. If the dealine is not set it waits for the stream to close indefinitely.
-  /// @param deadline optional deadline to close the reflection stream.
+  /// @brief close the reflection stream with a default deadline.
   /// @return return grpc status as a result of call the finish() on the reflection stream.
-  grpc::Status closeStreamWithDeadline(std::optional<std::chrono::time_point<std::chrono::system_clock>> deadline);
+  grpc::Status closeDescDbStream();
 
  private:
   typedef ClientReaderWriter<

third_party/gRPC_utils/proto_reflection_descriptor_database.cc

@@ -32,6 +32,7 @@ using grpc::reflection::v1alpha::ServerReflection;
 using grpc::reflection::v1alpha::ServerReflectionRequest;
 using grpc::reflection::v1alpha::ServerReflectionResponse;
 
+const uint8_t g_timeoutGrpcMainStreamSeconds = 20; //using default gwhisper timeout of 20 seconds.
 namespace grpc {
 
 ProtoReflectionDescriptorDatabase::ProtoReflectionDescriptorDatabase(
@@ -300,6 +301,9 @@ void ProtoReflectionDescriptorDatabase::AddFileFromResponse(
 const std::shared_ptr<ProtoReflectionDescriptorDatabase::ClientStream>
 ProtoReflectionDescriptorDatabase::GetStream() {
   if (!stream_) {
+    std::chrono::system_clock::time_point deadline =
+    std::chrono::system_clock::now() + std::chrono::seconds(g_timeoutGrpcMainStreamSeconds);
+    ctx_.set_deadline(deadline);
     stream_ = stub_->ServerReflectionInfo(&ctx_);
   }
   return stream_;
@@ -317,16 +321,13 @@ bool ProtoReflectionDescriptorDatabase::DoOneRequest(
   return success;
 }
 
-grpc::Status ProtoReflectionDescriptorDatabase::closeStreamWithDeadline(std::optional<std::chrono::time_point<std::chrono::system_clock>> deadline)
+grpc::Status ProtoReflectionDescriptorDatabase::closeDescDbStream()
 {
     stream_mutex_.lock();
-    if( deadline != std::nullopt )
-    {
-      ctx_.set_deadline(deadline.value());
-    }
 
     auto status = closeStream();
     stream_.reset();
+
     stream_mutex_.unlock();
     return status;
 }
@@ -342,6 +343,9 @@ grpc::Status ProtoReflectionDescriptorDatabase::closeStream()
         fprintf(stderr,
                 "Reflection request not implemented; "
                 "is the ServerReflection service enabled?\n");
+      } else if (status.error_code() == StatusCode::DEADLINE_EXCEEDED) {
+        fprintf(stderr,
+                "ServerReflectionInfo rpc failed. Grpc Server failed to close the stream within %d seconds.\n", g_timeoutGrpcMainStreamSeconds);
       } else {
         fprintf(stderr,
                 "ServerReflectionInfo rpc failed. Error code: %d, message: %s, "