Iox #27 client port implementation and test part 2

doc/design/diagrams/request_response/client_and_server_service_discovery.puml

@@ -0,0 +1,65 @@
+@startuml
+
+== Client tries to connect (Server not present) ==
+
+PortManager -> ClientPortRouDi ++ : tryGetCaProMessage
+return CaproMessageType::CONNECT
+
+PortManager -> PortManager ++ : sendToAllMatchingServerPorts
+
+PortManager -> ClientPortRouDi ++ : dispatchCaProMessageAndGetPossibleResponse(CaproMessageType::NACK)
+return cxx::nullopt
+
+return
+
+...
+
+== Server offers service (Client not present) ==
+
+PortManager -> ServerPortRouDi ++ : tryGetCaProMessage
+return CaproMessageType::OFFER
+
+PortManager -> PortManager ++ : sendToAllMatchingClientPorts
+
+return
+
+...
+
+== Client tries to connect (Server present) ==
+
+PortManager -> ClientPortRouDi ++ : tryGetCaProMessage
+return CaproMessageType::CONNECT
+
+PortManager -> PortManager ++ : sendToAllMatchingServerPorts
+
+PortManager -> ServerPortRouDi ++ : dispatchCaProMessageAndGetPossibleResponse(CaproMessageType::CONNECT)
+return CaproMessageType::ACK
+
+PortManager -> ClientPortRouDi ++ : dispatchCaProMessageAndGetPossibleResponse(CaproMessageType::ACK)
+return cxx::nullopt
+
+return
+
+...
+
+== Server offers service (Client present) ==
+
+PortManager -> ServerPortRouDi ++ : tryGetCaProMessage
+return CaproMessageType::OFFER
+
+PortManager -> PortManager ++ : sendToAllMatchingClientPorts
+
+PortManager -> ClientPortRouDi ++ : dispatchCaProMessageAndGetPossibleResponse(CaproMessageType::OFFER)
+return CaproMessageType::CONNECT
+
+PortManager -> ServerPortRouDi ++ : dispatchCaProMessageAndGetPossibleResponse(CaproMessageType::CONNECT)
+return CaproMessageType::ACK
+
+PortManager -> ClientPortRouDi ++ : dispatchCaProMessageAndGetPossibleResponse(CaproMessageType::ACK)
+return cxx::nullopt
+
+return
+
+...
+
+@enduml

doc/design/diagrams/request_response/client_port.puml

@@ -19,11 +19,12 @@ class ClientPortUser {
   hasNewResponses(): void
   hasLostResponsesSinceLastCall(): bool
   setConditionVariable(conditionVariable: ConditionVariableData&, notificationIndex: uint64_t): void
-  unsetConditionVariable: void
+  unsetConditionVariable(): void
   isConditionVariableSet(): bool
 }
 
 class ClientPortRouDi {
+  getResponseQueueFullPolicy: QueueFullPolicy
   tryGetCaProMessage(): optional<CaProMessage>
   dispatchCaProMessageAndGetPossibleResponse(caProMessage: const CaProMessage): optional<CaProMessage>
   releaseAllChunks(): void

doc/design/diagrams/request_response/client_state_machine.puml

@@ -0,0 +1,23 @@
+@startuml
+
+[*] -down-> NOT_CONNECTED
+
+NOT_CONNECTED -down-> CONNECT_REQUESTED : CONNECT
+NOT_CONNECTED -right-> NOT_CONNECTED : OFFER
+
+CONNECT_REQUESTED -down-> CONNECTED : ACK
+CONNECT_REQUESTED -right-> WAIT_FOR_OFFER : NACK
+CONNECT_REQUESTED : entry / CONNECT with response queue for server
+
+WAIT_FOR_OFFER -left-> CONNECT_REQUESTED : OFFER
+WAIT_FOR_OFFER -up-> NOT_CONNECTED : DISCONNECT
+
+CONNECTED -up-> WAIT_FOR_OFFER : STOP_OFFER
+CONNECTED -up-> DISCONNECT_REQUESTED : DISCONNECT
+CONNECTED : entry / store received request queue
+CONNECTED : exit / remove request queue
+
+DISCONNECT_REQUESTED -up-> NOT_CONNECTED : ACK/NACK
+DISCONNECT_REQUESTED : entry / DISCONNECT with response queue for server
+
+@enduml

doc/design/request_response_communication.md

@@ -110,6 +110,19 @@ A client can ask a server to block if its response queue is full.
 The server will obey if the corresponding `clientTooSlowPolicy` is set to `ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER`.
 If the options don't match, the client will not be connected to the server, similar to the behavior of publisher and subscriber.
 
+#### Client Service Discovery
+
+The client is guided by the following state machine.
+
+![client state machine](diagrams/request_response/client_state_machine.svg)
+
+Similar to the subscriber state machine, the client passes it's response queue with the `CONNECT` CaPro message to the server.
+The server will pass its request queue with the `ACK` CaPro message to the client.
+
+Following is a sequence diagram which shows all this cases
+
+![client and server service discovery](diagrams/request_response/client_and_server_service_discovery.svg)
+
 ### Code example
 
 ## Open issues

iceoryx_dds/include/iceoryx_dds/internal/gateway/iox_to_dds.inl

@@ -61,8 +61,7 @@ inline void Iceoryx2DDSGateway<channel_t, gateway_t>::loadConfiguration(const co
 template <typename channel_t, typename gateway_t>
 inline void Iceoryx2DDSGateway<channel_t, gateway_t>::discover(const capro::CaproMessage& msg) noexcept
 {
-    LogDebug() << "[Iceoryx2DDSGateway] <CaproMessage> "
-               << capro::CaproMessageTypeString[static_cast<uint8_t>(msg.m_type)]
+    LogDebug() << "[Iceoryx2DDSGateway] <CaproMessage> " << msg.m_type
                << " { Service: " << msg.m_serviceDescription.getServiceIDString()
                << ", Instance: " << msg.m_serviceDescription.getInstanceIDString()
                << ", Event: " << msg.m_serviceDescription.getEventIDString() << " }";

iceoryx_hoofs/include/iceoryx_hoofs/error_handling/error_handling.hpp

@@ -85,6 +85,9 @@ namespace iox
     error(POPO__CHUNK_LOCKING_ERROR) \
     error(POPO__CHUNK_UNLOCKING_ERROR) \
     error(POPO__CAPRO_PROTOCOL_ERROR) \
+    error(POPO__CLIENT_PORT_INVALID_REQUEST_TO_FREE_FROM_USER) \
+    error(POPO__CLIENT_PORT_INVALID_REQUEST_TO_SEND_FROM_USER) \
+    error(POPO__CLIENT_PORT_INVALID_RESPONSE_TO_RELEASE_FROM_USER) \
     error(POPO__CONDITION_VARIABLE_DATA_FAILED_TO_CREATE_SEMAPHORE) \
     error(POPO__CONDITION_LISTENER_SEMAPHORE_CORRUPTED_IN_WAS_TRIGGERED) \
     error(POPO__CONDITION_LISTENER_SEMAPHORE_CORRUPTED_IN_WAIT) \
@@ -173,6 +176,12 @@ enum class Error : uint32_t
     ICEORYX_ERRORS(CREATE_ICEORYX_ERROR_ENUM)
 };
 
+/// @brief Convenience stream operator to easily use the Error enum with std::ostream
+/// @param[in] stream sink to write the message to
+/// @param[in] value to convert to a string literal
+/// @return the reference to `stream` which was provided as input parameter
+std::ostream& operator<<(std::ostream& stream, Error value);
+
 /// @brief the available error levels
 /// FATAL
 /// - Log message with FATAL

iceoryx_hoofs/include/iceoryx_hoofs/log/logger.hpp

@@ -17,6 +17,7 @@
 #ifndef IOX_HOOFS_LOG_LOGGER_HPP
 #define IOX_HOOFS_LOG_LOGGER_HPP
 
+#include "iceoryx_hoofs/cxx/generic_raii.hpp"
 #include "iceoryx_hoofs/log/logcommon.hpp"
 #include "iceoryx_hoofs/log/logstream.hpp"
 
@@ -45,7 +46,20 @@ class Logger
     Logger(const Logger& other) = delete;
     Logger& operator=(const Logger& rhs) = delete;
 
+    /// @brief Getter method for the current LogLevel
+    /// @return the current LogLevel
+    LogLevel GetLogLevel() const noexcept;
+
+    /// @brief Sets the LogLevel for the Logger
+    /// @param[in] logLevel to be set
     void SetLogLevel(const LogLevel logLevel) noexcept;
+
+    /// @brief Sets the LogLevel to the given level for the lifetime of the GenericRAII object and then sets it back to
+    /// the previous one
+    /// @param[in] logLevel to be set temporarily
+    /// @return a scope guard which resets the LogLevel to the value at the time when this method was called
+    cxx::GenericRAII SetLogLevelForScope(const LogLevel logLevel) noexcept;
+
     void SetLogMode(const LogMode logMode) noexcept;
     bool IsEnabled(const LogLevel logLevel) const noexcept;
 
@@ -66,6 +80,7 @@ class Logger
     void Print(const LogEntry entry) const;
 
     std::atomic<LogLevel> m_logLevel{LogLevel::kVerbose};
+    std::atomic<LogLevel> m_logLevelPredecessor{LogLevel::kVerbose};
     std::atomic<LogMode> m_logMode{LogMode::kConsole};
 };
 

iceoryx_hoofs/source/error_handling/error_handling.cpp

@@ -32,6 +32,12 @@ HandlerFunction ErrorHandler::handler = {ErrorHandler::DefaultHandler};
 
 std::mutex ErrorHandler::handler_mutex;
 
+std::ostream& operator<<(std::ostream& stream, Error value)
+{
+    stream << ErrorHandler::ToString(value);
+    return stream;
+}
+
 void ErrorHandler::DefaultHandler(const Error error, const std::function<void()> errorCallBack, const ErrorLevel level)
 {
     if (errorCallBack)
@@ -41,7 +47,7 @@ void ErrorHandler::DefaultHandler(const Error error, const std::function<void()>
     else
     {
         std::stringstream ss;
-        ss << "ICEORYX error! " << ErrorHandler::ToString(error);
+        ss << "ICEORYX error! " << error;
 
         ReactOnErrorLevel(level, ss.str().c_str());
     }

iceoryx_hoofs/source/log/logger.cpp

@@ -52,11 +52,23 @@ Logger& Logger::operator=(Logger&& rhs)
     return *this;
 }
 
+LogLevel Logger::GetLogLevel() const noexcept
+{
+    return m_logLevel.load(std::memory_order_relaxed);
+}
+
 void Logger::SetLogLevel(const LogLevel logLevel) noexcept
 {
     m_logLevel.store(logLevel, std::memory_order_relaxed);
 }
 
+cxx::GenericRAII Logger::SetLogLevelForScope(const LogLevel logLevel) noexcept
+{
+    m_logLevelPredecessor.store(m_logLevel.load(std::memory_order_relaxed), std::memory_order_relaxed);
+    SetLogLevel(logLevel);
+    return cxx::GenericRAII([] {}, [&] { this->SetLogLevel(m_logLevelPredecessor.load(std::memory_order_relaxed)); });
+}
+
 void Logger::SetLogMode(const LogMode logMode) noexcept
 {
     m_logMode.store(logMode, std::memory_order_relaxed);

iceoryx_hoofs/test/moduletests/test_logger.cpp

@@ -122,6 +122,28 @@ TEST_F(IoxLogger_test, Output)
     EXPECT_THAT(output, Eq(expected));
 }
 
+TEST_F(IoxLogger_test, SettingTheLogLevelWorks)
+{
+    constexpr auto LOG_LEVEL{iox::log::LogLevel::kInfo};
+    EXPECT_THAT(m_sut.GetLogLevel(), Ne(LOG_LEVEL));
+
+    m_sut.SetLogLevel(LOG_LEVEL);
+    EXPECT_THAT(m_sut.GetLogLevel(), Eq(LOG_LEVEL));
+}
+
+TEST_F(IoxLogger_test, SettingTheLogLevelForScopeResetsLogLevelAtEndOfScope)
+{
+    constexpr auto LOG_LEVEL{iox::log::LogLevel::kInfo};
+    auto initialLogLevel{m_sut.GetLogLevel()};
+    EXPECT_THAT(initialLogLevel, Ne(LOG_LEVEL));
+
+    {
+        auto logLevelScopeGuard = m_sut.SetLogLevelForScope(LOG_LEVEL);
+        EXPECT_THAT(m_sut.GetLogLevel(), Eq(LOG_LEVEL));
+    }
+
+    EXPECT_THAT(m_sut.GetLogLevel(), Eq(initialLogLevel));
+}
 
 class IoxLoggerLogLevel_test : public TestWithParam<iox::log::LogLevel>, public IoxLogger_testBase
 {

iceoryx_posh/include/iceoryx_posh/iceoryx_posh_types.hpp

@@ -163,6 +163,23 @@ enum class ConnectionState : uint32_t
     WAIT_FOR_OFFER
 };
 
+/// @brief Converts the ConnectionState to a string literal
+/// @param[in] value to convert to a string literal
+/// @return pointer to a string literal
+inline constexpr const char* asStringLiteral(ConnectionState value) noexcept;
+
+/// @brief Convenience stream operator to easily use the `asStringLiteral` function with std::ostream
+/// @param[in] stream sink to write the message to
+/// @param[in] value to convert to a string literal
+/// @return the reference to `stream` which was provided as input parameter
+inline std::ostream& operator<<(std::ostream& stream, ConnectionState value);
+
+/// @brief Convenience stream operator to easily use the `asStringLiteral` function with iox::log::LogStream
+/// @param[in] stream sink to write the message to
+/// @param[in] value to convert to a string literal
+/// @return the reference to `stream` which was provided as input parameter
+inline log::LogStream& operator<<(log::LogStream& stream, ConnectionState value);
+
 // Default properties of ChunkDistributorData
 struct DefaultChunkDistributorConfig
 {