Better Error Handling and Logging

Summary

Better error handling (less exceptions, more error codes) and logging (for more detailed error handling and configuration issues).

Issue: https://gitlab.indiscale.com/caosdb/customers/lfpb/management/-/issues/390

See also the tests in caosdb-cppinttest!2 (merged)

Focus

• The TransactionStatus class represents the current status of a Transaction instance.
• The TransactionCode is a numeric representation of the status and intended for c-compatible error handling.
• Messages and Message classes handle the errors, warnings and info messages that come from the server.
• Logging: The logging can be configured via a json file. Otherwise the default configuration is in place.
• A lot of code was moved in order to comply with -pedantic flag. Don't waste your time

Test Environment

Unit tests should run as described in README_SETUP

Integration tests should run against a linkahead in the f-grpc branch

Check List for the Author

Please, prepare your MR for a review. Be sure to write a summary and a focus and create gitlab comments for the reviewer. They should guide the reviewer through the changes, explain your changes and also point out open questions. For further good practices have a look at our review guidelines

• All automated tests pass
• Reference related Issues
• Up-to-date CHANGELOG.md
• Annotations in code (Gitlab comments)
  • Intent of new code
  • Problems with old code
  • Why this implementation?

Check List for the Reviewer

• I understand the intent of this MR
• All automated tests pass
• Up-to-date CHANGELOG.md
• The test environment setup works and the intended behavior is reproducible in the test environment
• In-code documentation and comments are up-to-date.
• Check: Are there spezifications? Are they satisfied?

For further good practices have a look at our review guidelines.

include/caosdb/connection.h

@@ -27,116 +27,83 @@
  * @date 2021-05-18
  * @brief Configuration and setup of the connection.
  */
-#include <iosfwd>                                // for ostream
 #include <map>                                   // for map
 #include <memory>                                // for shared_ptr, unique_ptr
 #include <string>                                // for string, basic_string
+#include "boost/filesystem/path.hpp"             // for path
 #include "caosdb/authentication.h"               // for Authenticator
+#include "caosdb/configuration.h"                // for ConnectionConfigura...
 #include "caosdb/entity/v1alpha1/main.grpc.pb.h" // for EntityTransactionSe...
 #include "caosdb/info.h"                         // for VersionInfo
 #include "caosdb/info/v1alpha1/main.grpc.pb.h"   // for GeneralInfoService:...
 #include "caosdb/transaction.h"                  // for Transaction
+#include "caosdb/transaction_status.h"           // for TransactionStatus
 #include "grpcpp/channel.h"                      // for Channel
-#include "grpcpp/security/credentials.h"         // for ChannelCredentials
 
 namespace caosdb::connection {
+using boost::filesystem::path;
 using caosdb::authentication::Authenticator;
+using caosdb::configuration::ConnectionConfiguration;
 using caosdb::entity::v1alpha1::EntityTransactionService;
 using caosdb::info::VersionInfo;
 using caosdb::info::v1alpha1::GeneralInfoService;
 using caosdb::transaction::Transaction;
-using grpc::ChannelCredentials;
-
-class CertificateProvider {
-public:
-  [[nodiscard]] auto virtual GetCertificatePem() const -> std::string = 0;
-  virtual ~CertificateProvider() = default;
-};
-
-class PemFileCertificateProvider : public CertificateProvider {
-private:
-  std::string certificate_provider;
-
-public:
-  explicit PemFileCertificateProvider(const std::string &path);
-  [[nodiscard]] auto GetCertificatePem() const -> std::string override;
-};
-
-class PemCertificateProvider : public CertificateProvider {
-private:
-  std::string certificate_provider;
-
-public:
-  explicit PemCertificateProvider(const std::string &certificate_provider);
-  [[nodiscard]] auto GetCertificatePem() const -> std::string override;
-};
+using caosdb::transaction::TransactionStatus;
 
 /**
- * @brief Configuration of the CaosDB connection.
+ * @brief A reusable connection to a CaosDBServer.
  */
-class ConnectionConfiguration {
-private:
-  std::string host;
-  int port;
-
+class Connection {
 public:
-  ConnectionConfiguration(const std::string &host, int port);
-  virtual ~ConnectionConfiguration() = default;
-  friend auto operator<<(std::ostream &out,
-                         const ConnectionConfiguration &configuration)
-    -> std::ostream &;
-
-  [[nodiscard]] auto virtual ToString() const -> std::string = 0;
-  [[nodiscard]] auto GetHost() const -> std::string;
-  [[nodiscard]] auto GetPort() const -> int;
-  [[nodiscard]] auto virtual GetChannelCredentials() const
-    -> std::shared_ptr<ChannelCredentials> = 0;
-};
+  explicit Connection(const ConnectionConfiguration &configuration);
 
-class InsecureConnectionConfiguration : public ConnectionConfiguration {
-private:
-  std::shared_ptr<ChannelCredentials> credentials;
+  /**
+   * Request the server's version and return the status of this request after
+   * termination..
+   *
+   * The version is stored in the connection object and may be retrieved via
+   * GetVersionInfo() if the request was successful.
+   *
+   * This method does not throw any exceptions. Errors are indicated in the
+   * return value instead.
+   */
+  auto RetrieveVersionInfoNoExceptions() const noexcept -> TransactionStatus;
+
+  /**
+   * Request and return the server's version.
+   *
+   * If the request terminated unsuccessfully, a corresponding exception is
+   * being thrown.
+   */
+  auto RetrieveVersionInfo() const -> const VersionInfo &;
+
+  /**
+   * Return the server's version.
+   *
+   * Clients need to call RetrieveVersionInfo() or
+   * RetrieveVersionInfoNoExceptions() before the version info is locally
+   * available. Otherwise a nullptr is being returned.
+   */
+  [[nodiscard]] inline auto GetVersionInfo() const noexcept
+    -> const VersionInfo * {
+    return this->version_info.get();
+  };
 
-public:
-  InsecureConnectionConfiguration(const std::string &host, int port);
-  [[nodiscard]] auto GetChannelCredentials() const
-    -> std::shared_ptr<ChannelCredentials> override;
-  [[nodiscard]] auto ToString() const -> std::string override;
-};
+  [[nodiscard]] auto CreateTransaction() const -> std::unique_ptr<Transaction>;
 
-class TlsConnectionConfiguration : public ConnectionConfiguration {
 private:
-  std::shared_ptr<ChannelCredentials> credentials;
-  std::string certificate_provider;
-
-public:
-  TlsConnectionConfiguration(const std::string &host, int port);
-  TlsConnectionConfiguration(const std::string &host, int port,
-                             const Authenticator &authenticator);
-  TlsConnectionConfiguration(const std::string &host, int port,
-                             const CertificateProvider &certificate_provider);
-  TlsConnectionConfiguration(const std::string &host, int port,
-                             const CertificateProvider &certificate_provider,
-                             const Authenticator &authenticator);
-  [[nodiscard]] auto GetChannelCredentials() const
-    -> std::shared_ptr<ChannelCredentials> override;
-  [[nodiscard]] auto ToString() const -> std::string override;
-};
-
-/**
- * @brief A reusable connection to a CaosDBServer.
- */
-class Connection {
+  /// GRPC-Channel (HTTP/2 Connection plus Authentication). We use a shared
+  /// pointer because Transaction instances also own the channel.
   std::shared_ptr<grpc::Channel> channel;
+  /// Service for retrieving the server's version. We use a unique pointer
+  /// because only this connection owns and uses this service.
   std::unique_ptr<GeneralInfoService::Stub> general_info_service;
+  /// The server's version. It's mutable because it is rather a cache than a
+  /// data member which is subject to change.
+  mutable std::unique_ptr<VersionInfo> version_info;
+  /// Service for entity transactions. We use a shared pointer because
+  /// Transaction instances also own this service stub.
   std::shared_ptr<EntityTransactionService::Stub> entity_transaction_service;
-
-public:
-  explicit Connection(const ConnectionConfiguration &configuration);
-  friend auto operator<<(std::ostream &out, const Connection &connection)
-    -> std::ostream &;
-  [[nodiscard]] auto GetVersionInfo() const -> std::unique_ptr<VersionInfo>;
-  [[nodiscard]] auto CreateTransaction() const -> std::unique_ptr<Transaction>;
 };
 
 /**
@@ -182,6 +149,9 @@ public:
     return ConnectionManager::GetInstance().mGetConnection(name);
   };
 
+  /**
+   * Get the connection marked by the "default" key in the configuration.
+   */
   inline static auto GetDefaultConnection()
     -> const std::shared_ptr<Connection> & {
     return ConnectionManager::GetInstance().mGetDefaultConnection();