Merge branch 'f-insert' into f-doc-setup

.gitlab-ci.yml

@@ -24,7 +24,6 @@ variables:
   CPPLIB_REGISTRY_IMAGE: $CI_REGISTRY/caosdb/src/caosdb-cpplib/testenv:$CI_COMMIT_REF_NAME
 
   CPPINTTEST_PIPELINE: https://gitlab.indiscale.com/api/v4/projects/111/trigger/pipeline
-  CPPINTTEST_BRANCHES: https://gitlab.indiscale.com/api/v4/projects/111/repository/branches
   GIT_SUBMODULE_STRATEGY: normal
 
   ## FOR DEBUGGING
@@ -50,7 +49,6 @@ info:
     - echo "Pipeline triggered by $TRIGGERED_BY_REPO@$TRIGGERED_BY_REF ($TRIGGERED_BY_HASH)"
     - echo "$CPPLIB_REGISTRY_IMAGE"
     - echo "$CPPINTTEST_PIPELINE"
-    - echo "$CPPINTTEST_BRANCHES"
     - echo "$GIT_SUBMODULE_STRATEGY"
 
 # Build a docker image in which tests for this repository can run
@@ -85,6 +83,9 @@ test:
     - mkdir build
     - cd build
     - conan install .. -s "compiler.libcxx=libstdc++11"
+    - FILE_TO_BE_PATCHED="$(grep "std::unique_ptr<ContextAllocator> context_allocator) {}" -l -r $(conan config home))"
+    - echo "FILE_TO_BE_PATCHED=$FILE_TO_BE_PATCHED"
+    - sed -e "s|std::unique_ptr<ContextAllocator> context_allocator) {}|std::unique_ptr<ContextAllocator> /*context_allocator*/) {}|" -i $FILE_TO_BE_PATCHED
     - cmake -DCMAKE_BUILD_TYPE=Debug ..
     - cmake --build .
     - cmake --build . --target unit_test_coverage

CMakeLists.txt

@@ -20,7 +20,7 @@
 
 cmake_minimum_required(VERSION 3.13)
 
-set(libcaosdb_VERSION 0.0.5)
+set(libcaosdb_VERSION 0.0.7)
 set(libcaosdb_COMPATIBLE_SERVER_VERSION_MAJOR 0)
 set(libcaosdb_COMPATIBLE_SERVER_VERSION_MINOR 5)
 set(libcaosdb_COMPATIBLE_SERVER_VERSION_PATCH 0)
@@ -31,7 +31,12 @@ project(libcaosdb
     DESCRIPTION "C and C++ client libraries for CaosDB"
     LANGUAGES CXX C)
 
+set(CMAKE_C_STANDARD 11)
 set(CMAKE_CXX_STANDARD 17)
+
+set(CMAKE_C_EXTENSIONS OFF)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
@@ -193,6 +198,39 @@ target_link_libraries(cxxcaosdbcli
 ### LINTING with CLANG-TIDY and INCLUDE-WHAT-YOU-USE
 #######################################################
 
+###########################################
+### PARANOID COMPILER SETTINGS
+###########################################
+option(PARANOID_COMPILER_SETTINGS "Enable extra-paranoid compiler settings
+(which may even flag errors for code in the dependencies. These only apply in
+Debug BUILD_TYPE with SKIP_LINTING=Off or when LINTING=On." OFF)
+include(CheckCXXCompilerFlag)
+include(CheckCCompilerFlag)
+
+function(add_compiler_flag flag)
+    string(FIND "${CMAKE_CXX_FLAGS}" "${flag}" cxx_present)
+    if(cxx_present EQUAL -1)
+        check_cxx_compiler_flag("${flag}" flag_supported)
+        if(flag_supported)
+            set(PEDANTIC_CMAKE_CXX_FLAGS "${PEDANTIC_CMAKE_CXX_FLAGS} ${flag}" PARENT_SCOPE)
+        endif()
+        unset(flag_supported CACHE)
+    endif()
+    unset(cxx_present CACHE)
+
+    string(FIND "${CMAKE_C_FLAGS}" "${flag}" c_present)
+    if(c_present EQUAL -1)
+        check_cxx_compiler_flag("${flag}" flag_supported)
+        if(flag_supported)
+            set(PEDANTIC_CMAKE_C_FLAGS "${PEDANTIC_CMAKE_C_FLAGS} ${flag}" PARENT_SCOPE)
+        endif()
+        unset(flag_supported CACHE)
+    endif()
+    unset(c_present CACHE)
+endfunction()
+
+
+
 option(LINTING "Enable linting with clang-tidy and iwyu when in non-Debug build-type" OFF)
 if("${CMAKE_BUILD_TYPE}" MATCHES "Debug" OR LINTING)
     set(_LINTING ON)
@@ -203,6 +241,27 @@ if("${CMAKE_BUILD_TYPE}" MATCHES "Debug" AND SKIP_LINTING)
     set(_LINTING OFF)
 endif()
 if(_LINTING)
+
+    ### set paranoid compiler flags
+    add_compiler_flag("-Wall")
+    add_compiler_flag("-Wextra")
+    add_compiler_flag("-pedantic")
+    add_compiler_flag("-Werror")
+
+    set(TARGET_CAOSDB_COMPILE_FLAGS "${TARGET_CAOSDB_COMPILE_FLAGS} ${PEDANTIC_CMAKE_CXX_FLAGS}")
+    set(TARGET_CCAOSDB_COMPILE_FLAGS "${TARGET_CCAOSDB_COMPILE_FLAGS} ${PEDANTIC_CMAKE_C_FLAGS}")
+    set(TARGET_CXXCAOSDBCLI_COMPILE_FLAGS "${TARGET_CXXCAOSDBCLI_COMPILE_FLAGS} ${PEDANTIC_CMAKE_CXX_FLAGS}")
+    set(TARGET_CCAOSDBCLI_COMPILE_FLAGS "${TARGET_CCAOSDBCLI_COMPILE_FLAGS} ${PEDANTIC_CMAKE_C_FLAGS}")
+
+    set_target_properties(caosdb PROPERTIES
+        COMPILE_FLAGS "${TARGET_CAOSDB_COMPILE_FLAGS}")
+    set_target_properties(ccaosdb PROPERTIES
+        COMPILE_FLAGS "${TARGET_CCAOSDB_COMPILE_FLAGS}")
+    set_target_properties(cxxcaosdbcli PROPERTIES
+        COMPILE_FLAGS "${TARGET_CXXCAOSDBCLI_COMPILE_FLAGS}")
+    set_target_properties(ccaosdbcli PROPERTIES
+        COMPILE_FLAGS "${TARGET_CCAOSDBCLI_COMPILE_FLAGS}")
+
     find_program(iwyu
         NAMES include-what-you-use iwyu
         PATHS ${CMAKE_SOURCE_DIR}/tools/include-what-you-use/${iwyu_os}/bin)
@@ -230,10 +289,12 @@ if(_LINTING)
     else()
         message(STATUS "clang-tidy: ${clang_tidy}")
         set(_CMAKE_CXX_CLANG_TIDY_CHECKS
-            "--checks=*,-fuchsia-*,-llvm-include-order,-llvmlibc-*,-readability-convert-member-functions-to-static,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-hicpp-no-array-decay,-llvm-else-after-return,-readability-else-after-return")
+            "--checks=*,-fuchsia-*,-llvmlibc-*,-readability-convert-member-functions-to-static,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-hicpp-no-array-decay,-llvm-else-after-return,-readability-else-after-return,-modernize-use-trailing-return-type")
+        set(_CMAKE_C_CLANG_TIDY_CHECKS "${_CMAKE_CXX_CLANG_TIDY_CHECKS}")
         set(_CMAKE_CXX_CLANG_TIDY "${clang_tidy}"
             "--header-filter=caosdb/.*[^\(\.pb\.h\)]$"
             "--warnings-as-errors=*")
+        set(_CMAKE_C_CLANG_TIDY "${_CMAKE_CXX_CLANG_TIDY}")
         option(AUTO_FIX_LINTING "Append --fix option to clang-tidy" OFF)
         if(AUTO_FIX_LINTING)
             set(_CMAKE_CXX_CLANG_TIDY "${_CMAKE_CXX_CLANG_TIDY};--fix")
@@ -246,8 +307,11 @@ if(_LINTING)
         set_target_properties(cxxcaosdbcli PROPERTIES
             CXX_CLANG_TIDY "${_CMAKE_CXX_CLANG_TIDY};${_CMAKE_CXX_CLANG_TIDY_CHECKS}"
             )
+        set_target_properties(ccaosdb PROPERTIES
+            C_CLANG_TIDY "${_CMAKE_C_CLANG_TIDY};${_CMAKE_C_CLANG_TIDY_CHECKS}"
+            )
         set_target_properties(ccaosdbcli PROPERTIES
-            C_CLANG_TIDY "${_CMAKE_CXX_CLANG_TIDY};${_CMAKE_CXX_CLANG_TIDY_CHECKS}"
+            C_CLANG_TIDY "${_CMAKE_C_CLANG_TIDY};${_CMAKE_C_CLANG_TIDY_CHECKS}"
             )
     endif()
 endif()

DEPENDENCIES.md

 # GENERAL
 
+* >=conan-1.37.2 (e.g. with `pip install conan`)
 * >=cmake-3.14
 * >=gcc-10.2.0 | >=clang-11
 
+# OPTIONAL
+
+* For checking the schema of a json configuration file: >=jsonschema-3.2.0
+
 # BUILD DOCS
 
 * doxygen

README_SETUP.md

 # How to Develop and Use Libcaosdb
 
-## Requirements ##
+## Dependencies
 
-- conan: `pip install conan`
-- cmake >= 3.13
-- (Only necessary when building from the git sources) `git submodule update --init proto`
+* See [DEPENDENCIES.md](Dependencies.md)
 
-## Semi-manual build
+## Build
 
 We use [cmake](https://cmake.org) as build tool.
 
+0. clone/update the subrepo `git submodule update --init proto`
 1. `mkdir build && cd build`
 2. `conan install .. -s "compiler.libcxx=libstdc++11"`
 3. `cmake -B . ..`
@@ -35,7 +34,7 @@ have to add `build/lib/` (or, alternatively after installation,
 `CMAKE_INSTALL_PREFIX/lib`) to your `DYLD_LIBRARY_PATH` environmental
 variable.
 
-## Building with Conan ##
+## Creating a Local Conan Build ##
 
 Building and installing libcaosdb with Conan is just a single command:  
 `conan create . -s "compiler.libcxx=libstdc++11"`

caosdb-client-configuration-schema.json

@@ -24,6 +24,30 @@
         "$ref": "#/definitions/connection_configuration"
       }
     },
+    "logging": {
+      "type": "object",
+      "description": "Configuration of logging",
+      "properties": {
+        "level": {
+          "allOf": [
+            {
+              "$ref": "#/definitions/log_level_configuration"
+            },
+            "default": "warn",
+            {
+            "description": "Global severity filter. Only log messages with at least the given severity are processed by the logging framework. 'off' means that the logging frame work is turned off entirely. Defaults to "
+            }
+          ]
+        },
+        "sinks": {
+          "type": "object",
+          "description": "Configuration of sinks, i.e. the log files, console or other logging frame works where the log messages are supposed to end up eventually.",
+          "additionalProperties": {
+            "$ref": "#/definitions/sink_configuration"
+          }
+        }
+      }
+    },
     "extension": {
       "type": "object",
       "description": "A reserved configuration object which may be used to store additional options for particular clients and special extensions.",
@@ -31,6 +55,58 @@
     }
   },
   "definitions": {
+    "log_level_configuration": {
+      "type": "string",
+      "enum": ["all", "trace", "debug", "info", "warn", "error", "fatal", "off"]
+    },
+    "sink_configuration": {
+      "type": "object",
+      "description": "A single sink configuration.",
+      "additionalProperties": false,
+      "properties": {
+        "level": {
+          "allOf": [
+            {
+              "$ref": "#/definitions/log_level_configuration"
+            },
+            {
+            "description": "Sink severity filter. Only log messages with at least the given severity are passed to this sink. 'off' means that this sink is turned off entirely. Defaults to the global log level."
+            }
+          ]
+        },
+        "destination": {
+          "type": "string",
+          "enum": [ "console", "file", "syslog"],
+          "description": "The type of sink-backend. 'console' writes to the STDERR, 'file' to a text file and 'syslog' uses the syslog API."
+        },
+        "directory": {
+          "type": "string",
+          "description": "Path to local directory. All log files are being stored to this directory. If not specified, the current working directory will be used."
+        },
+        "local_address": {
+          "type": "string",
+          "description": "Local IP address to initiate connection to the syslog server. If not specified, the default local address will be used."
+        },
+        "target_address": {
+          "type": "string",
+          "description": "Remote IP address of the syslog server. If not specified, the local address will be used. "
+        }
+      },
+      "required": [ "destination" ],
+      "allOf": [ {
+          "if": {"properties": {"destination": { "const": "console" } } },
+          "then": {"propertyNames" : { "enum": ["level", "destination"] } }
+        },
+        {
+          "if": {"properties": {"destination": { "const": "file" } } },
+          "then": {"propertyNames" : { "enum": ["level", "destination", "directory"] } }
+        },
+        {
+          "if": {"properties": {"destination": { "const": "syslog" } } },
+          "then": {"propertyNames" : { "enum": ["level", "destination", "target_address", "local_address"] } }
+        }
+      ]
+    },
     "connection_configuration": {
       "type": "object",
       "description": "A single connection configuration.",

conanfile.py

@@ -3,7 +3,7 @@ from conans import ConanFile, CMake, tools
 
 class CaosdbConan(ConanFile):
     name = "caosdb"
-    version = "0.0.5"
+    version = "0.0.7"
     license = "AGPL-3.0-or-later"
     author = "Timm C. Fitschen <t.fitschen@indiscale.com>"
     url = "https://gitlab.indiscale.com/caosdb/src/caosdb-cpplib.git"

include/CMakeLists.txt

@@ -21,13 +21,20 @@
 # add all header files to this list
 set(libcaosdb_INCL
     ${CMAKE_CURRENT_SOURCE_DIR}/caosdb/authentication.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/caosdb/certificate_provider.h
     ${CMAKE_CURRENT_SOURCE_DIR}/caosdb/configuration.h
     ${CMAKE_CURRENT_SOURCE_DIR}/caosdb/connection.h
     ${CMAKE_CURRENT_BINARY_DIR}/caosdb/constants.h
     ${CMAKE_CURRENT_SOURCE_DIR}/caosdb/entity.h
     ${CMAKE_CURRENT_SOURCE_DIR}/caosdb/exceptions.h
     ${CMAKE_CURRENT_SOURCE_DIR}/caosdb/info.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/caosdb/log_level.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/caosdb/logging.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/caosdb/message_code.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/caosdb/protobuf_helper.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/caosdb/status_code.h
     ${CMAKE_CURRENT_SOURCE_DIR}/caosdb/transaction.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/caosdb/transaction_status.h
     ${CMAKE_CURRENT_SOURCE_DIR}/caosdb/utility.h
     )
 

include/caosdb/authentication.h

@@ -27,16 +27,15 @@
  * @date 2021-06-28
  * @brief Configuration and setup of the client authentication.
  */
-
-#include <grpcpp/security/credentials.h>               // for CallCredentials
-#include <map>                                         // for multimap
-#include <memory>                                      // for shared_ptr
-#include <string>                                      // for string
 #include "caosdb/utility.h"                            // for base64_encode
 #include "grpcpp/impl/codegen/interceptor.h"           // for Status
 #include "grpcpp/impl/codegen/security/auth_context.h" // for AuthContext
 #include "grpcpp/impl/codegen/status.h"                // for Status
 #include "grpcpp/impl/codegen/string_ref.h"            // for string_ref
+#include <grpcpp/security/credentials.h>               // for CallCredentials
+#include <map>                                         // for multimap
+#include <memory>                                      // for shared_ptr
+#include <string>                                      // for string
 
 namespace caosdb {
 namespace authentication {

include/caosdb/certificate_provider.h

+/*
+ * This file is a part of the CaosDB Project.
+ *
+ * Copyright (C) 2021 Timm Fitschen <t.fitschen@indiscale.com>
+ * Copyright (C) 2021 IndiScale GmbH <info@indiscale.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef CAOSDB_CERTIFICATE_PROVIDER_H
+#define CAOSDB_CERTIFICATE_PROVIDER_H
+
+#include "boost/filesystem/path.hpp" // for path
+namespace caosdb::configuration {
+using boost::filesystem::path;
+
+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 path &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;
+};
+} // namespace caosdb::configuration
+#endif

include/caosdb/configuration.h

@@ -21,17 +21,20 @@
 
 #ifndef CAOSDB_CONFIGURATION_H
 #define CAOSDB_CONFIGURATION_H
-#include <memory>                          // for unique_ptr
-#include <string>                          // for string
 #include "boost/filesystem/operations.hpp" // for exists
 #include "boost/filesystem/path.hpp"       // for path
 #include "boost/json/object.hpp"           // for object
 #include "boost/json/value.hpp"            // for value
-#include "boost/json/value_ref.hpp"        // for array, object
+#include "boost/json/value_ref.hpp"        // IWYU pragma: keep
 #include "caosdb/authentication.h"         // for Authenticator, PlainPassw...
-#include "caosdb/connection.h" // for ConnectionConfiguration, Certifi...
-#include "caosdb/exceptions.h" // for ConfigurationError
-#include "caosdb/utility.h"    // for load_json_file
+#include "caosdb/certificate_provider.h"   // for CertificateProvider, path
+#include "caosdb/exceptions.h"             // for ConfigurationError
+#include "caosdb/logging.h"
+#include "caosdb/utility.h"              // for load_json_file
+#include "grpcpp/security/credentials.h" // for ChannelCredentials
+#include <iosfwd>                        // for ostream
+#include <memory>                        // for unique_ptr, shared_ptr
+#include <string>                        // for string
 
 namespace caosdb::configuration {
 using boost::filesystem::exists;
@@ -41,14 +44,89 @@ using boost::json::object;
 using boost::json::value;
 using caosdb::authentication::Authenticator;
 using caosdb::authentication::PlainPasswordAuthenticator;
-using caosdb::connection::CertificateProvider;
-using caosdb::connection::ConnectionConfiguration;
-using caosdb::connection::ConnectionManager;
-using caosdb::connection::InsecureConnectionConfiguration;
-using caosdb::connection::PemFileCertificateProvider;
-using caosdb::connection::TlsConnectionConfiguration;
 using caosdb::exceptions::ConfigurationError;
 using caosdb::utility::load_json_file;
+using grpc::ChannelCredentials;
+
+const std::string logger_name = "caosdb::configuration";
+
+/**
+ * @brief Configuration of the CaosDB connection.
+ */
+class ConnectionConfiguration {
+private:
+  std::string host;
+  int port;
+
+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;
+};
+
+class InsecureConnectionConfiguration : public ConnectionConfiguration {
+private:
+  std::shared_ptr<ChannelCredentials> credentials;
+
+public:
+  InsecureConnectionConfiguration(const std::string &host, int port);
+  [[nodiscard]] auto GetChannelCredentials() const
+    -> std::shared_ptr<ChannelCredentials> override;
+  [[nodiscard]] auto ToString() const -> std::string override;
+};
+
+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;
+};
+
+/**
+ * Helper class (no state, just member functions) which should only be used by
+ * the ConfigurationManager to initialize the logging framework from the stored
+ * configuration.
+ */
+class LoggingConfigurationHelper {
+public:
+  friend class ConfigurationManager;
+
+private:
+  auto CreateConsoleSinkConfiguration(const object &from,
+                                      const std::string &name, int level) const
+    -> std::shared_ptr<caosdb::logging::SinkConfiguration>;
+  auto CreateSyslogSinkConfiguration(const object &from,
+                                     const std::string &name, int level) const
+    -> std::shared_ptr<caosdb::logging::SinkConfiguration>;
+  auto CreateFileSinkConfiguration(const object &from, const std::string &name,
+                                   int level) const
+    -> std::shared_ptr<caosdb::logging::SinkConfiguration>;
+  auto CreateSinkConfiguration(const object &from, const std::string &name,
+                               int default_level) const
+    -> std::shared_ptr<caosdb::logging::SinkConfiguration>;
+  auto CreateLoggingConfiguration(const object &from) const
+    -> caosdb::logging::LoggingConfiguration;
+};
 
 /**
  * Helper class (no state, just member functions) which should only be used by
@@ -63,7 +141,7 @@ private:
   /**
    * @param from - a single connection configuration.
    */
-  inline auto CreateCertificateProvider(const object &from) const
+  auto CreateCertificateProvider(const object &from) const
     -> std::unique_ptr<CertificateProvider>;
 
   /**
@@ -110,12 +188,12 @@ public:
   /**
    * See mReset.
    */
-  inline static auto Reset() -> void { GetInstance().mReset(); }
+  inline static auto Reset() noexcept -> int { return GetInstance().mReset(); }
 
   /**
    * See mClear.
    */
-  inline static auto Clear() -> void { GetInstance().mClear(); }
+  inline static auto Clear() noexcept -> int { return GetInstance().mClear(); }
 
   /**
    * See mLoadSingleJSONConfiguration.
@@ -155,6 +233,8 @@ public:
 private:
   value json_configuration;
   ConnectionConfigurationHelper connection_configuration_helper;
+  LoggingConfigurationHelper logging_configuration_helper;
+
   inline ConfigurationManager() { InitializeDefaults(); };
 
   /**
@@ -164,7 +244,7 @@ private:
    * first existing file from the LIBCAOSDB_CONFIGURATION_FILES_PRECEDENCE list
    * of file locations.
    */
-  auto InitializeDefaults() -> void;
+  auto InitializeDefaults() -> int;
 
   /**
    * Return a json object representing the current configuration.
@@ -188,7 +268,7 @@ private:
    * The current configuration is deleted and a new configuration is being
    * loaded via InitializeDefaults.
    */
-  auto mReset() -> void;
+  auto mReset() noexcept -> int;
 
   /**
    * Clear this ConfigurationManager.
@@ -198,7 +278,7 @@ private:
    * In contrast to mReset, this method only deletes the current configuration
    * but does not load a new one via InitializeDefaults.
    */
-  auto mClear() -> void;
+  auto mClear() noexcept -> int;
 
   /**
    * Load a configuration from a json file.

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>;
 };
 
 /**

include/caosdb/entity.h

@@ -28,11 +28,15 @@
 #ifndef CAOSDB_ENTITY_H
 #define CAOSDB_ENTITY_H
 
-#include <memory>                           // for unique_ptr
 #include <string>                           // for string
-#include "caosdb/entity/v1alpha1/main.pb.h" // for Entity, RepeatedField
+#include "caosdb/entity/v1alpha1/main.pb.h" // for RepeatedPtrField, Message
+#include "caosdb/message_code.h"            // for get_message_code, Messag...
+#include "google/protobuf/util/json_util.h" // for MessageToJsonString, Jso...
 
 namespace caosdb::entity {
+using caosdb::entity::v1alpha1::IdResponse;
+using ProtoParent = caosdb::entity::v1alpha1::Parent;
+using ProtoEntity = caosdb::entity::v1alpha1::Entity;
 
 /**
  * Parent of an Entity.
@@ -41,12 +45,26 @@ class Parent {
 public:
   explicit inline Parent(caosdb::entity::v1alpha1::Parent *wrapped)
     : wrapped(wrapped){};
+  Parent();
   [[nodiscard]] auto GetId() const -> const std::string &;
   [[nodiscard]] auto GetName() const -> const std::string &;
   [[nodiscard]] auto GetDescription() const -> const std::string &;
+  auto SetId(const std::string &id) -> void;
+  auto SetName(const std::string &name) -> void;
+
+  inline auto ToString() const -> const std::string {
+    google::protobuf::util::JsonOptions options;
+    std::string out;
+    google::protobuf::util::MessageToJsonString(*(this->wrapped), &out,
+                                                options);
+    return out;
+  }
+
+  friend class Parents;
 
 private:
-  caosdb::entity::v1alpha1::Parent *wrapped;
+  static auto CreateProtoParent() -> ProtoParent *;
+  mutable caosdb::entity::v1alpha1::Parent *wrapped;
 };
 
 /**
@@ -56,21 +74,26 @@ class Parents {
 public:
   inline Parents(){};
   explicit inline Parents(
-    ::google::protobuf::RepeatedField<caosdb::entity::v1alpha1::Parent>
+    ::google::protobuf::RepeatedPtrField<caosdb::entity::v1alpha1::Parent>
       *wrapped)
     : wrapped(wrapped){};
-  [[nodiscard]] auto At(int index) const -> const Parent &;
+  auto Append(const Parent &parent) -> void;
+  [[nodiscard]] inline auto Size() const -> int { return wrapped->size(); }
+  [[nodiscard]] inline auto At(int index) const -> const Parent {
+    return Parent(&(wrapped->at(index)));
+  }
 
 private:
-  ::google::protobuf::RepeatedField<caosdb::entity::v1alpha1::Parent> *wrapped;
+  ::google::protobuf::RepeatedPtrField<caosdb::entity::v1alpha1::Parent>
+    *wrapped;
   friend class Entity;
 };
 
 /**
  * Property of an Entity.
  *
- * This is a property which belongs to another entity. Don't confuse it with an
- * Entity with the "Property" role.
+ * This is a property which belongs to another entity. Don't confuse it with
+ * an Entity with the "Property" role.
  *
  * @brief Property of an Entity.
  */
@@ -85,6 +108,12 @@ public:
   [[nodiscard]] auto GetValue() const -> const std::string &;
   [[nodiscard]] auto GetUnit() const -> const std::string &;
   [[nodiscard]] auto GetDatatype() const -> const std::string &;
+  auto SetId(const std::string &id) -> void;
+  auto SetName(const std::string &name) -> void;
+  auto SetImportance(const std::string &importance) -> void;
+  auto SetValue(const std::string &value) -> void;
+  auto SetUnit(const std::string &unit) -> void;
+  auto SetDatatype(const std::string &datatype) -> void;
 
 private:
   caosdb::entity::v1alpha1::Property *wrapped;
@@ -97,13 +126,50 @@ class Properties {
 public:
   inline Properties(){};
   explicit inline Properties(
-    ::google::protobuf::RepeatedField<caosdb::entity::v1alpha1::Property>
+    ::google::protobuf::RepeatedPtrField<caosdb::entity::v1alpha1::Property>
       *wrapped)
     : wrapped(wrapped){};
   [[nodiscard]] auto At(int index) const -> const Property &;
+  auto Append(const Property &property) -> void;
 
 private:
-  ::google::protobuf::RepeatedField<caosdb::entity::v1alpha1::Property>
+  ::google::protobuf::RepeatedPtrField<caosdb::entity::v1alpha1::Property>
+    *wrapped;
+  friend class Entity;
+};
+
+class Message {
+public:
+  explicit inline Message(caosdb::entity::v1alpha1::Message *wrapped)
+    : wrapped(wrapped){};
+  [[nodiscard]] inline auto GetCode() const -> MessageCode {
+    return get_message_code(wrapped->code());
+  }
+  [[nodiscard]] inline auto GetDescription() const -> std::string {
+    return wrapped->description();
+  }
+
+private:
+  caosdb::entity::v1alpha1::Message *wrapped;
+};
+
+/**
+ * Container for Messages.
+ */
+class Messages {
+public:
+  inline Messages() : wrapped(nullptr){};
+  explicit inline Messages(
+    ::google::protobuf::RepeatedPtrField<caosdb::entity::v1alpha1::Message>
+      *wrapped)
+    : wrapped(wrapped){};
+  [[nodiscard]] inline auto Size() const -> int { return wrapped->size(); }
+  [[nodiscard]] inline auto At(int index) const -> const Message {
+    return Message(&(wrapped->at(index)));
+  }
+
+private:
+  ::google::protobuf::RepeatedPtrField<caosdb::entity::v1alpha1::Message>
     *wrapped;
   friend class Entity;
 };
@@ -113,18 +179,18 @@ private:
  */
 class Entity {
 public:
-  explicit inline Entity(caosdb::entity::v1alpha1::Entity *wrapped)
-    : wrapped(wrapped),
-      properties(
-        (::google::protobuf::RepeatedField<caosdb::entity::v1alpha1::Property>
-           *)wrapped->mutable_properties()),
-      parents(
-        (::google::protobuf::RepeatedField<caosdb::entity::v1alpha1::Parent> *)
-          wrapped->mutable_parents()){};
+  Entity();
+  explicit Entity(IdResponse *idResponse);
+  explicit inline Entity(ProtoEntity *wrapped) : wrapped(wrapped) {
+    errors.wrapped = this->wrapped->mutable_errors();
+    properties.wrapped = this->wrapped->mutable_properties();
+    parents.wrapped = this->wrapped->mutable_parents();
+  };
+
   [[nodiscard]] inline auto GetId() const -> const std::string & {
     return wrapped->id();
   };
-  [[nodiscard]] inline auto GetVersion() const -> const std::string & {
+  [[nodiscard]] inline auto GetVersionId() const -> const std::string & {
     return wrapped->version().id();
   };
 
@@ -138,20 +204,46 @@ public:
     return wrapped->description();
   };
 
-  [[nodiscard]] auto GetDatatype() const -> const std::string & {
+  [[nodiscard]] inline auto GetDatatype() const -> const std::string & {
     return wrapped->datatype();
   };
-  [[nodiscard]] auto GetUnit() const -> const std::string & {
+  [[nodiscard]] inline auto GetUnit() const -> const std::string & {
     return wrapped->unit();
   };
 
   [[nodiscard]] auto GetParents() const -> const Parents &;
   [[nodiscard]] auto GetProperties() const -> const Properties &;
+  [[nodiscard]] inline auto GetErrors() const -> const Messages & {
+    return errors;
+  }
+  [[nodiscard]] inline auto HasErrors() const -> bool {
+    return this->errors.wrapped->size() > 0;
+  }
+
+  inline auto ToString() const -> const std::string {
+    google::protobuf::util::JsonOptions options;
+    std::string out;
+    google::protobuf::util::MessageToJsonString(*(this->wrapped), &out,
+                                                options);
+    return out;
+  }
+
+  auto SetId(const std::string &id) -> void;
+  auto SetName(const std::string &name) -> void;
+  auto SetVersionId(const std::string &id) -> void;
+  auto SetValue(const std::string &value) -> void;
+  auto SetUnit(const std::string &unit) -> void;
+  auto SetDatatype(const std::string &datatype) -> void;
+  auto AppendProperty(const Property &property) -> void;
+  auto AppendParent(const Parent &parent) -> void;
+  auto Switch(ProtoEntity *entity) -> void;
 
 private:
-  std::unique_ptr<caosdb::entity::v1alpha1::Entity> wrapped;
+  static auto CreateProtoEntity() -> ProtoEntity *;
+  ProtoEntity *wrapped;
   Properties properties;
   Parents parents;
+  Messages errors;
 };
 
 } // namespace caosdb::entity

include/caosdb/exceptions.h

@@ -21,46 +21,81 @@
 
 #ifndef CAOSDB_EXCEPTIONS_H
 #define CAOSDB_EXCEPTIONS_H
+#include "caosdb/status_code.h"
 #include <stdexcept>
 #include <string>
 
 namespace caosdb::exceptions {
+using caosdb::StatusCode;
 using std::runtime_error;
 
+/**
+ * @brief Generic exception class of the caosdb client library.
+ */
+class GenericException : public runtime_error {
+public:
+  explicit GenericException(StatusCode code, const std::string &what_arg)
+    : runtime_error(what_arg), code(code) {}
+  [[nodiscard]] inline auto GetCode() const -> StatusCode { return this->code; }
+
+private:
+  StatusCode code;
+};
+
 /**
  * @brief Exception for authentication errors.
  */
-class AuthenticationError : public runtime_error {
+class AuthenticationError : public GenericException {
 public:
   explicit AuthenticationError(const std::string &what_arg)
-    : runtime_error(what_arg) {}
+    : GenericException(StatusCode::AUTHENTICATION_ERROR, what_arg) {}
 };
 
 /**
  * @brief The connection to the CaosDB server is down.
  */
-class ConnectionError : public runtime_error {
+class ConnectionError : public GenericException {
 public:
   explicit ConnectionError(const std::string &what_arg)
-    : runtime_error(what_arg) {}
+    : GenericException(StatusCode::CONNECTION_ERROR, what_arg) {}
 };
 
 /**
- * @brief The connection is known to the ConnectionManager under this name.
+ * @brief The transaction terminated unsuccessfully.
  */
-class UnknownConnectionError : public runtime_error {
+class TransactionError : public GenericException {
+protected:
+  TransactionError(StatusCode code, const std::string &what_arg)
+    : GenericException(code, what_arg) {}
+
 public:
-  explicit UnknownConnectionError(const std::string &what_arg)
-    : runtime_error(what_arg) {}
+  explicit TransactionError(const std::string &what_arg)
+    : GenericException(StatusCode::GENERIC_TRANSACTION_ERROR, what_arg) {}
+};
+
+class TransactionStatusError : public TransactionError {
+public:
+  explicit TransactionStatusError(const std::string &what_arg)
+    : TransactionError(StatusCode::TRANSACTION_STATUS_ERROR, what_arg) {}
 };
 
 /**
- * @brief Exception for errors of the ConnectionManager.
+ * @brief Exception for errors of the ConfigurationManager or other components
+ * of the configuration.
  */
-class ConfigurationError : public runtime_error {
+class ConfigurationError : public GenericException {
 public:
   explicit ConfigurationError(const std::string &what_arg)
-    : runtime_error(what_arg) {}
+    : GenericException(StatusCode::CONFIGURATION_ERROR, what_arg) {}
+};
+
+/**
+ * @brief The connection isn't known to the ConnectionManager under this name.
+ */
+class UnknownConnectionError : public GenericException {
+public:
+  explicit UnknownConnectionError(const std::string &what_arg)
+    : GenericException(StatusCode::UNKNOWN_CONNECTION_ERROR, what_arg) {}
 };
 
 } // namespace caosdb::exceptions

include/caosdb/info.h

@@ -27,9 +27,9 @@
  * @date 2021-07-02
  * @brief General information about the CaosDBServer.
  */
+#include "caosdb/info/v1alpha1/main.pb.h" // for VersionInfo
 #include <cstdint>                        // for uint32_t
 #include <string>                         // for string
-#include "caosdb/info/v1alpha1/main.pb.h" // for VersionInfo
 
 namespace caosdb::info {
 
@@ -54,13 +54,13 @@ public:
    * server behind the given connection.
    */
   explicit inline VersionInfo(ProtoVersionInfo *info) : info(info){};
-  [[nodiscard]] inline auto GetMajor() const -> uint32_t {
+  [[nodiscard]] inline auto GetMajor() const -> int32_t {
     return this->info->major();
   }
-  [[nodiscard]] inline auto GetMinor() const -> uint32_t {
+  [[nodiscard]] inline auto GetMinor() const -> int32_t {
     return this->info->minor();
   }
-  [[nodiscard]] inline auto GetPatch() const -> uint32_t {
+  [[nodiscard]] inline auto GetPatch() const -> int32_t {
     return this->info->patch();
   }
   [[nodiscard]] inline auto GetPreRelease() const -> const std::string & {

include/caosdb/log_level.h

+/*
+ * This file is a part of the CaosDB Project.
+ *
+ * Copyright (C) 2021 Timm Fitschen <t.fitschen@indiscale.com>
+ * Copyright (C) 2021 IndiScale GmbH <info@indiscale.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef CAOSDB_LOG_LEVELS_H
+#define CAOSDB_LOG_LEVELS_H
+
+#define CAOSDB_LOG_LEVEL_OFF 1000000
+#define CAOSDB_LOG_LEVEL_FATAL 700
+#define CAOSDB_LOG_LEVEL_ERROR 600
+#define CAOSDB_LOG_LEVEL_WARN 500
+#define CAOSDB_LOG_LEVEL_INFO 400
+#define CAOSDB_LOG_LEVEL_DEBUG 300
+#define CAOSDB_LOG_LEVEL_TRACE 200
+#define CAOSDB_LOG_LEVEL_ALL 0
+#define CAOSDB_DEFAULT_LOG_LEVEL 500
+
+#endif

include/caosdb/logging.h

+
+/*
+ * This file is a part of the CaosDB Project.
+ *
+ * Copyright (C) 2021 Timm Fitschen <t.fitschen@indiscale.com>
+ * Copyright (C) 2021 IndiScale GmbH <info@indiscale.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef CAOSDB_LOGGING_H
+#define CAOSDB_LOGGING_H
+
+#include "caosdb/log_level.h"                            // for CAOSDB_LOG_...
+#include "boost/log/sources/global_logger_storage.hpp"   // for BOOST_LOG_I...
+#include "boost/log/sources/record_ostream.hpp"          // IWYU pragma: keep
+#include "boost/log/sources/severity_channel_logger.hpp" // for BOOST_LOG_C...
+#include "boost/log/utility/setup/settings.hpp"          // for settings
+#include "boost/smart_ptr/intrusive_ptr.hpp"             // for intrusive_ptr
+#include "boost/smart_ptr/intrusive_ref_counter.hpp"     // for intrusive_p...
+#include <memory>                                        // for shared_ptr
+#include <string>                                        // for string
+#include <vector>                                        // for vector
+
+namespace caosdb::logging {
+
+const std::string logger_name = "caosdb::logging";
+
+typedef boost::log::sources::severity_channel_logger<int, std::string>
+  boost_logger_class;
+
+BOOST_LOG_INLINE_GLOBAL_LOGGER_DEFAULT(logger, boost_logger_class)
+
+class LevelConfiguration {
+public:
+  LevelConfiguration(int level) : level(level){};
+  [[nodiscard]] inline auto GetLevel() const -> int { return this->level; }
+
+private:
+  int level;
+};
+
+class SinkConfiguration;
+
+class LoggingConfiguration : public LevelConfiguration {
+public:
+  virtual ~LoggingConfiguration() = default;
+  LoggingConfiguration(int level);
+  auto AddSink(const std::shared_ptr<SinkConfiguration> &sink) -> void;
+  auto GetSinks() const
+    -> const std::vector<std::shared_ptr<SinkConfiguration>> &;
+
+private:
+  std::vector<std::shared_ptr<SinkConfiguration>> sinks;
+};
+
+auto initialize_logging_defaults() -> int;
+auto initialize_logging(const LoggingConfiguration &configuration) -> void;
+
+class SinkConfiguration : public LevelConfiguration {
+public:
+  virtual ~SinkConfiguration() = default;
+  SinkConfiguration(std::string name, int level);
+  [[nodiscard]] auto GetName() const -> const std::string &;
+  [[nodiscard]] virtual auto GetDestination() const -> const std::string & = 0;
+
+  friend auto initialize_logging_defaults() -> int;
+  friend auto
+  initialize_logging(const LoggingConfiguration &logging_configuration) -> void;
+
+protected:
+  virtual auto Configure(boost::log::settings &settings) const -> void;
+
+private:
+  std::string name;
+};
+
+class ConsoleSinkConfiguration : public SinkConfiguration {
+public:
+  virtual ~ConsoleSinkConfiguration() = default;
+  ConsoleSinkConfiguration(const std::string &name, int level);
+  [[nodiscard]] auto GetDestination() const -> const std::string & override;
+  friend auto initialize_logging_defaults() -> int;
+  friend auto
+  initialize_logging(const LoggingConfiguration &logging_configuration) -> void;
+
+protected:
+  typedef SinkConfiguration sink_configuration;
+  virtual auto Configure(boost::log::settings &settings) const -> void override;
+
+private:
+  const std::string destination = "Console";
+};
+
+class FileSinkConfiguration : public SinkConfiguration {
+public:
+  virtual ~FileSinkConfiguration() = default;
+  FileSinkConfiguration(const std::string &name, int level);
+  [[nodiscard]] virtual auto GetDestination() const
+    -> const std::string & override;
+  auto SetDirectory(const std::string &directory) -> void;
+  friend auto initialize_logging_defaults() -> int;
+  friend auto
+  initialize_logging(const LoggingConfiguration &logging_configuration) -> void;
+
+protected:
+  typedef SinkConfiguration sink_configuration;
+  virtual auto Configure(boost::log::settings &settings) const -> void override;
+
+private:
+  const std::string destination = "TextFile";
+  std::string directory = "./";
+};
+
+class SyslogSinkConfiguration : public SinkConfiguration {
+public:
+  virtual ~SyslogSinkConfiguration() = default;
+  SyslogSinkConfiguration(const std::string &name, int level);
+  [[nodiscard]] virtual auto GetDestination() const
+    -> const std::string & override;
+
+private:
+  const std::string destination = "Syslog";
+};
+
+/**
+ * Convenience function for the c-interface.
+ */
+void caosdb_log_fatal(const char *channel, const char *msg);
+/**
+ * Convenience function for the c-interface.
+ */
+void caosdb_log_error(const char *channel, const char *msg);
+/**
+ * Convenience function for the c-interface.
+ */
+void caosdb_log_warn(const char *channel, const char *msg);
+/**
+ * Convenience function for the c-interface.
+ */
+void caosdb_log_info(const char *channel, const char *msg);
+/**
+ * Convenience function for the c-interface.
+ */
+void caosdb_log_debug(const char *channel, const char *msg);
+/**
+ * Convenience function for the c-interface.
+ */
+void caosdb_log_trace(const char *channel, const char *msg);
+
+} // namespace caosdb::logging
+
+#define CAOSDB_LOG_FATAL(Channel)                                              \
+  BOOST_LOG_CHANNEL_SEV(caosdb::logging::logger::get(), Channel,               \
+                        CAOSDB_LOG_LEVEL_FATAL)
+#define CAOSDB_LOG_ERROR(Channel)                                              \
+  BOOST_LOG_CHANNEL_SEV(caosdb::logging::logger::get(), Channel,               \
+                        CAOSDB_LOG_LEVEL_ERROR)
+#define CAOSDB_LOG_WARN(Channel)                                               \
+  BOOST_LOG_CHANNEL_SEV(caosdb::logging::logger::get(), Channel,               \
+                        CAOSDB_LOG_LEVEL_WARN)
+#define CAOSDB_LOG_INFO(Channel)                                               \
+  BOOST_LOG_CHANNEL_SEV(caosdb::logging::logger::get(), Channel,               \
+                        CAOSDB_LOG_LEVEL_INFO)
+#define CAOSDB_LOG_DEBUG(Channel)                                              \
+  BOOST_LOG_CHANNEL_SEV(caosdb::logging::logger::get(), Channel,               \
+                        CAOSDB_LOG_LEVEL_DEBUG)
+#define CAOSDB_LOG_TRACE(Channel)                                              \
+  BOOST_LOG_CHANNEL_SEV(caosdb::logging::logger::get(), Channel,               \
+                        CAOSDB_LOG_LEVEL_TRACE)
+
+#endif

include/caosdb/message_code.h

+/*
+ * This file is a part of the CaosDB Project.
+ *
+ * Copyright (C) 2021 Timm Fitschen <t.fitschen@indiscale.com>
+ * Copyright (C) 2021 IndiScale GmbH <info@indiscale.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef CAOSDB_MESSAGE_CODE_H
+#define CAOSDB_MESSAGE_CODE_H
+
+#include "caosdb/entity/v1alpha1/main.pb.h" // for Entity, RepeatedField
+
+/**
+ * MessageCodes for entity messages.
+ *
+ * In contrast to the status codes, the message codes are part of the CaosDB
+ * API. Messages (and their codes) represent the state of the entities in a
+ * transaction or the server.
+ */
+
+namespace caosdb::entity {
+
+enum MessageCode {
+  UNSPECIFIED = caosdb::entity::v1alpha1::MessageCode::MESSAGE_CODE_UNSPECIFIED,
+  UNKNOWN = caosdb::entity::v1alpha1::MessageCode::MESSAGE_CODE_UNKNOWN,
+  ENTITY_DOES_NOT_EXIST =
+    caosdb::entity::v1alpha1::MessageCode::MESSAGE_CODE_ENTITY_DOES_NOT_EXIST,
+};
+
+[[nodiscard]] inline auto get_message_code(int code) noexcept -> MessageCode {
+  // TODO(tf) smarter, less forgot-it-prone implementation
+  static MessageCode all_codes[] = {
+    MessageCode::UNSPECIFIED,
+    MessageCode::UNKNOWN,
+    MessageCode::ENTITY_DOES_NOT_EXIST,
+  };
+
+  for (MessageCode known_code : all_codes) {
+    if (known_code == code) {
+      return known_code;
+    }
+  }
+  return MessageCode::UNKNOWN;
+}
+
+} // namespace caosdb::entity
+#endif

include/caosdb/protobuf_helper.h

+/*
+ * This file is a part of the CaosDB Project.
+ *
+ * Copyright (C) 2021 Timm Fitschen <t.fitschen@indiscale.com>
+ * Copyright (C) 2021 IndiScale GmbH <info@indiscale.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef CAOSDB_PROTOBUF_HELPER_H
+#define CAOSDB_PROTOBUF_HELPER_H
+
+#include <google/protobuf/arena.h>
+
+namespace caosdb::utility {
+
+using google::protobuf::Arena;
+
+auto get_arena() -> Arena *;
+
+} // namespace caosdb::utility
+#endif

include/caosdb/status_code.h

+/*
+ * This file is a part of the CaosDB Project.
+ *
+ * Copyright (C) 2021 Timm Fitschen <t.fitschen@indiscale.com>
+ * Copyright (C) 2021 IndiScale GmbH <info@indiscale.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef CAOSDB_STATUS_CODE_H
+#define CAOSDB_STATUS_CODE_H
+
+/**
+ * StatusCodes represent the status of this client, it's connections,
+ * configuration and so on.
+ *
+ * In contrast to MessageCodes, these status codes do not represent the status
+ * of the entities of a transaction or of the server (or only inasmuch the
+ * GENERIC_TRANSACTION_ERROR indicates that *there are* errors in a
+ * transaction).
+ */
+
+namespace caosdb {
+
+enum StatusCode {
+  INITIAL = -2,
+  EXECUTING = -1,
+  SUCCESS = 0,
+  AUTHENTICATION_ERROR = 16,
+  CONNECTION_ERROR = 14,
+  GENERIC_RPC_ERROR = 20,
+  GENERIC_ERROR = 21,
+  GENERIC_TRANSACTION_ERROR = 22,
+  CONFIGURATION_ERROR = 23,
+  UNKNOWN_CONNECTION_ERROR = 24,
+  TRANSACTION_STATUS_ERROR = 25,
+};
+
+auto get_status_description(int code) -> const std::string &;
+
+} // namespace caosdb
+#endif

include/caosdb/transaction.h

@@ -19,28 +19,31 @@
  *
  */
 
+#ifndef CAOSDB_TRANSACTION_H
+#define CAOSDB_TRANSACTION_H
 /**
  * @brief Creation and execution of transactions.
  */
-
-#ifndef CAOSDB_TRANSACTION_H
-#define CAOSDB_TRANSACTION_H
-
-#include <memory>                                // for shared_ptr, unique_ptr
-#include <string>                                // for string
 #include "caosdb/entity.h"                       // for Entity
 #include "caosdb/entity/v1alpha1/main.grpc.pb.h" // for EntityTransactionSe...
 #include "caosdb/entity/v1alpha1/main.pb.h"      // for Entity, RetrieveReq...
+#include "caosdb/transaction_status.h"           // for TransactionStatus
+#include "google/protobuf/util/json_util.h" // for MessageToJsonString, Jso...
+#include <memory>                           // for shared_ptr, unique_ptr
+#include <string>                           // for string
 
 namespace caosdb::transaction {
 using caosdb::entity::Entity;
 using ProtoEntity = caosdb::entity::v1alpha1::Entity;
 using caosdb::entity::v1alpha1::EntityTransactionService;
-using caosdb::entity::v1alpha1::RetrieveRequest;
+using caosdb::entity::v1alpha1::IdResponse;
+using caosdb::entity::v1alpha1::MultiTransactionRequest;
+using caosdb::entity::v1alpha1::MultiTransactionResponse;
+using caosdb::transaction::TransactionStatus;
 
 class ResultSet {
 public:
-  virtual ~ResultSet(){};
+  virtual ~ResultSet() = default;
 };
 
 class UniqueResult : public ResultSet {
@@ -48,32 +51,99 @@ public:
   ~UniqueResult(){};
   explicit inline UniqueResult(ProtoEntity *protoEntity)
     : entity(new Entity(protoEntity)){};
+  explicit inline UniqueResult(IdResponse *idResponse)
+    : entity(new Entity(idResponse)){};
   [[nodiscard]] auto GetEntity() const -> const Entity &;
 
 private:
   std::unique_ptr<Entity> entity;
 };
 
-enum TransactionState { INIT = 10, EXECUTING = 20, SUCCESS = 30, ERROR = 40 };
-
 /**
  * @brief Create a transaction via `CaosDBConnection.createTransaction()`
  */
 class Transaction {
 private:
-  std::unique_ptr<ResultSet> result_set;
-  TransactionState state = TransactionState::INIT;
+  mutable std::unique_ptr<ResultSet> result_set;
+  TransactionStatus status = TransactionStatus::INITIAL();
   std::shared_ptr<EntityTransactionService::Stub> service_stub;
-  RetrieveRequest request; // TODO(tf)
+  MultiTransactionRequest *request;
+  mutable MultiTransactionResponse *response;
+  std::string error_message;
 
 public:
   Transaction(std::shared_ptr<EntityTransactionService::Stub> service_stub);
+
+  /**
+   * Add an entity id to this transaction for retrieval.
+   *
+   * The retrieval is being processed when the Execute() or
+   * ExecuteAsynchronously() methods of this transaction are called.
+   */
   auto RetrieveById(const std::string &id) -> void;
-  auto Execute() -> void;
+
+  /**
+   * Add the entity to this transaction for an insertion.
+   *
+   * The insertion is being processed when the Execute() or
+   * ExecuteAsynchronously() methods of this transaction are called.
+   *
+   * Changing the entity afterwards results in undefined behavior.
+   */
+  auto InsertEntity(Entity *entity) -> void;
+
+  /**
+   * Add an entity id to this transaction for deletion.
+   *
+   * The deletion is being processed when the Execute() or
+   * ExecuteAsynchronously() methods of this transaction are called.
+   */
+  auto DeleteById(const std::string &id) -> void;
+
+  inline auto IsStatus(const TransactionStatus &status) const noexcept -> bool {
+    return this->status.GetCode() == status.GetCode();
+  };
+
+  /**
+   * Execute this transaction in blocking mode and return the status.
+   */
+  auto Execute() -> TransactionStatus;
+
+  /**
+   * Execute this transaction in non-blocking mode and return immediately.
+   *
+   * A client may request the current status at any time via GetStatus().
+   *
+   * Use WaitForIt() to join the back-ground execution of this transaction.
+   */
+  auto ExecuteAsynchronously() noexcept -> void;
+
+  /**
+   * Join the background execution and return the status when the execution
+   * terminates.
+   *
+   * Use this after ExecuteAsynchronously().
+   */
+  [[nodiscard]] auto WaitForIt() const noexcept -> TransactionStatus;
+
+  /**
+   * Return the current status of the transaction.
+   */
+  [[nodiscard]] inline auto GetStatus() const -> TransactionStatus {
+    return this->status;
+  }
+
   [[nodiscard]] inline auto GetResultSet() const -> const ResultSet & {
     const ResultSet *result_set = this->result_set.get();
     return *result_set;
   }
+
+  inline auto RequestToString() const -> const std::string {
+    google::protobuf::util::JsonOptions options;
+    std::string out;
+    google::protobuf::util::MessageToJsonString(*this->request, &out, options);
+    return out;
+  }
 };
 
 } // namespace caosdb::transaction