diff --git a/iceoryx_binding_c/include/iceoryx_binding_c/enums.h b/iceoryx_binding_c/include/iceoryx_binding_c/enums.h index 8f827d9c30e..044cbf794b9 100644 --- a/iceoryx_binding_c/include/iceoryx_binding_c/enums.h +++ b/iceoryx_binding_c/include/iceoryx_binding_c/enums.h @@ -50,7 +50,8 @@ enum iox_ChunkReceiveResult ChunkReceiveResult_SUCCESS, }; -/// @brief used by subscriber; describes whether a publisher blocks when subscriber queue is full +/// @brief Used by consumers to request a specific behavior from the producer; describes whether a producer blocks when +/// consumer queue is full enum iox_QueueFullPolicy { QueueFullPolicy_BLOCK_PRODUCER, @@ -60,12 +61,18 @@ enum iox_QueueFullPolicy QueueFullPolicy_DISCARD_OLDEST_DATA, }; -/// @brief used by publisher; describes whether a publisher blocks when subscriber queue is full -enum iox_SubscriberTooSlowPolicy +/// @brief Used by producers how to adjust to slow consumer; describes whether a producer blocks when consumer queue is +/// full +enum iox_ConsumerTooSlowPolicy { - SubscriberTooSlowPolicy_WAIT_FOR_SUBSCRIBER, - SubscriberTooSlowPolicy_DISCARD_OLDEST_DATA, + ConsumerTooSlowPolicy_WAIT_FOR_CONSUMER, + ConsumerTooSlowPolicy_DISCARD_OLDEST_DATA, }; +/// @deprecated Compatibility alias for the legacy use with publisher only. Will be remove in a future release. +/// Please use `iox_ConsumerTooSlowPolicy` instead. +typedef enum iox_ConsumerTooSlowPolicy iox_SubscriberTooSlowPolicy; +#define SubscriberTooSlowPolicy_WAIT_FOR_SUBSCRIBER ConsumerTooSlowPolicy_WAIT_FOR_CONSUMER +#define SubscriberTooSlowPolicy_DISCARD_OLDEST_DATA ConsumerTooSlowPolicy_DISCARD_OLDEST_DATA /// @brief state of allocateChunk enum iox_AllocationResult diff --git a/iceoryx_binding_c/include/iceoryx_binding_c/internal/c2cpp_enum_translation.hpp b/iceoryx_binding_c/include/iceoryx_binding_c/internal/c2cpp_enum_translation.hpp index 0a593410b39..13a96bc6be3 100644 --- a/iceoryx_binding_c/include/iceoryx_binding_c/internal/c2cpp_enum_translation.hpp +++ b/iceoryx_binding_c/include/iceoryx_binding_c/internal/c2cpp_enum_translation.hpp @@ -24,7 +24,8 @@ namespace c2cpp { -iox::popo::SubscriberTooSlowPolicy subscriberTooSlowPolicy(const ENUM iox_SubscriberTooSlowPolicy policy) noexcept; +iox::popo::ConsumerTooSlowPolicy consumerTooSlowPolicy(const ENUM iox_ConsumerTooSlowPolicy policy) noexcept; +iox::popo::ConsumerTooSlowPolicy subscriberTooSlowPolicy(const ENUM iox_SubscriberTooSlowPolicy policy) noexcept; iox::popo::QueueFullPolicy queueFullPolicy(const ENUM iox_QueueFullPolicy policy) noexcept; iox::popo::SubscriberEvent subscriberEvent(const iox_SubscriberEvent value) noexcept; iox::popo::SubscriberState subscriberState(const iox_SubscriberState value) noexcept; diff --git a/iceoryx_binding_c/include/iceoryx_binding_c/internal/cpp2c_enum_translation.hpp b/iceoryx_binding_c/include/iceoryx_binding_c/internal/cpp2c_enum_translation.hpp index ba55307d970..3aeb284badd 100644 --- a/iceoryx_binding_c/include/iceoryx_binding_c/internal/cpp2c_enum_translation.hpp +++ b/iceoryx_binding_c/include/iceoryx_binding_c/internal/cpp2c_enum_translation.hpp @@ -33,7 +33,8 @@ iox_ChunkReceiveResult chunkReceiveResult(const iox::popo::ChunkReceiveResult va iox_AllocationResult allocationResult(const iox::popo::AllocationError value) noexcept; iox_WaitSetResult waitSetResult(const iox::popo::WaitSetError value) noexcept; iox_ListenerResult listenerResult(const iox::popo::ListenerError value) noexcept; -iox_SubscriberTooSlowPolicy subscriberTooSlowPolicy(const iox::popo::SubscriberTooSlowPolicy policy) noexcept; +iox_ConsumerTooSlowPolicy consumerTooSlowPolicy(const iox::popo::ConsumerTooSlowPolicy policy) noexcept; +iox_ConsumerTooSlowPolicy subscriberTooSlowPolicy(const iox::popo::ConsumerTooSlowPolicy policy) noexcept; iox_QueueFullPolicy queueFullPolicy(const iox::popo::QueueFullPolicy policy) noexcept; } // namespace cpp2c diff --git a/iceoryx_binding_c/include/iceoryx_binding_c/publisher.h b/iceoryx_binding_c/include/iceoryx_binding_c/publisher.h index a3af7d7b54f..93af309858b 100644 --- a/iceoryx_binding_c/include/iceoryx_binding_c/publisher.h +++ b/iceoryx_binding_c/include/iceoryx_binding_c/publisher.h @@ -40,7 +40,7 @@ typedef struct bool offerOnCreate; /// @brief describes whether a publisher blocks when subscriber queue is full - ENUM iox_SubscriberTooSlowPolicy subscriberTooSlowPolicy; + ENUM iox_ConsumerTooSlowPolicy subscriberTooSlowPolicy; /// @brief this value will be set exclusively by `iox_pub_options_init` and is not supposed to be modified otherwise uint64_t initCheck; diff --git a/iceoryx_binding_c/include/iceoryx_binding_c/runtime.h b/iceoryx_binding_c/include/iceoryx_binding_c/runtime.h index a1450de46ef..d5ddfecd4e5 100644 --- a/iceoryx_binding_c/include/iceoryx_binding_c/runtime.h +++ b/iceoryx_binding_c/include/iceoryx_binding_c/runtime.h @@ -34,7 +34,7 @@ void iox_runtime_init(const char* const name); uint64_t iox_runtime_get_instance_name(char* const name, const uint64_t nameLength); /// @brief initiates the shutdown of the runtime to unblock all potentially blocking publisher -/// with the iox_SubscriberTooSlowPolicy::SubscriberTooSlowPolicy_WAIT_FOR_SUBSCRIBER option set +/// with the iox_ConsumerTooSlowPolicy::ConsumerTooSlowPolicy_WAIT_FOR_CONSUMER option set void iox_runtime_shutdown(); #endif diff --git a/iceoryx_binding_c/source/c2cpp_enum_translation.cpp b/iceoryx_binding_c/source/c2cpp_enum_translation.cpp index ca5e22f31de..6f7981dcc56 100644 --- a/iceoryx_binding_c/source/c2cpp_enum_translation.cpp +++ b/iceoryx_binding_c/source/c2cpp_enum_translation.cpp @@ -20,19 +20,23 @@ namespace c2cpp { -iox::popo::SubscriberTooSlowPolicy subscriberTooSlowPolicy(const ENUM iox_SubscriberTooSlowPolicy policy) noexcept +iox::popo::ConsumerTooSlowPolicy consumerTooSlowPolicy(const ENUM iox_ConsumerTooSlowPolicy policy) noexcept { switch (policy) { - case SubscriberTooSlowPolicy_WAIT_FOR_SUBSCRIBER: - return iox::popo::SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER; - case SubscriberTooSlowPolicy_DISCARD_OLDEST_DATA: - return iox::popo::SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA; + case ConsumerTooSlowPolicy_WAIT_FOR_CONSUMER: + return iox::popo::ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER; + case ConsumerTooSlowPolicy_DISCARD_OLDEST_DATA: + return iox::popo::ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA; } errorHandler( - iox::Error::kBINDING_C__UNDEFINED_STATE_IN_IOX_SUBSCRIBER_TOO_SLOW_POLICY, nullptr, iox::ErrorLevel::MODERATE); - return iox::popo::SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA; + iox::Error::kBINDING_C__UNDEFINED_STATE_IN_IOX_CONSUMER_TOO_SLOW_POLICY, nullptr, iox::ErrorLevel::MODERATE); + return iox::popo::ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA; +} +iox::popo::ConsumerTooSlowPolicy subscriberTooSlowPolicy(const ENUM iox_SubscriberTooSlowPolicy policy) noexcept +{ + return consumerTooSlowPolicy(policy); } iox::popo::QueueFullPolicy queueFullPolicy(const ENUM iox_QueueFullPolicy policy) noexcept diff --git a/iceoryx_binding_c/source/c_publisher.cpp b/iceoryx_binding_c/source/c_publisher.cpp index 5072294ad61..2cf52b8b1ed 100644 --- a/iceoryx_binding_c/source/c_publisher.cpp +++ b/iceoryx_binding_c/source/c_publisher.cpp @@ -47,7 +47,7 @@ void iox_pub_options_init(iox_pub_options_t* options) options->historyCapacity = publisherOptions.historyCapacity; options->nodeName = nullptr; options->offerOnCreate = publisherOptions.offerOnCreate; - options->subscriberTooSlowPolicy = cpp2c::subscriberTooSlowPolicy(publisherOptions.subscriberTooSlowPolicy); + options->subscriberTooSlowPolicy = cpp2c::consumerTooSlowPolicy(publisherOptions.subscriberTooSlowPolicy); options->initCheck = PUBLISHER_OPTIONS_INIT_CHECK_CONSTANT; } @@ -90,7 +90,7 @@ iox_pub_t iox_pub_init(iox_pub_storage_t* self, publisherOptions.nodeName = NodeName_t(TruncateToCapacity, options->nodeName); } publisherOptions.offerOnCreate = options->offerOnCreate; - publisherOptions.subscriberTooSlowPolicy = c2cpp::subscriberTooSlowPolicy(options->subscriberTooSlowPolicy); + publisherOptions.subscriberTooSlowPolicy = c2cpp::consumerTooSlowPolicy(options->subscriberTooSlowPolicy); } me->m_portData = PoshRuntime::getInstance().getMiddlewarePublisher( diff --git a/iceoryx_binding_c/source/cpp2c_enum_translation.cpp b/iceoryx_binding_c/source/cpp2c_enum_translation.cpp index 73b7a485d12..93ed8a21d69 100644 --- a/iceoryx_binding_c/source/cpp2c_enum_translation.cpp +++ b/iceoryx_binding_c/source/cpp2c_enum_translation.cpp @@ -101,16 +101,20 @@ iox_ListenerResult listenerResult(const iox::popo::ListenerError value) noexcept return ListenerResult_UNDEFINED_ERROR; } -iox_SubscriberTooSlowPolicy subscriberTooSlowPolicy(const iox::popo::SubscriberTooSlowPolicy policy) noexcept +iox_ConsumerTooSlowPolicy consumerTooSlowPolicy(const iox::popo::ConsumerTooSlowPolicy policy) noexcept { switch (policy) { - case SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER: - return SubscriberTooSlowPolicy_WAIT_FOR_SUBSCRIBER; - case SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA: - return SubscriberTooSlowPolicy_DISCARD_OLDEST_DATA; + case ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER: + return ConsumerTooSlowPolicy_WAIT_FOR_CONSUMER; + case ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA: + return ConsumerTooSlowPolicy_DISCARD_OLDEST_DATA; } - return SubscriberTooSlowPolicy_DISCARD_OLDEST_DATA; + return ConsumerTooSlowPolicy_DISCARD_OLDEST_DATA; +} +iox_ConsumerTooSlowPolicy subscriberTooSlowPolicy(const iox::popo::ConsumerTooSlowPolicy policy) noexcept +{ + return consumerTooSlowPolicy(policy); } iox_QueueFullPolicy queueFullPolicy(const iox::popo::QueueFullPolicy policy) noexcept { diff --git a/iceoryx_binding_c/test/moduletests/test_c2cpp_enum_translation.cpp b/iceoryx_binding_c/test/moduletests/test_c2cpp_enum_translation.cpp index 0610d39c72c..b4472255d28 100644 --- a/iceoryx_binding_c/test/moduletests/test_c2cpp_enum_translation.cpp +++ b/iceoryx_binding_c/test/moduletests/test_c2cpp_enum_translation.cpp @@ -97,9 +97,9 @@ TEST(c2cpp_enum_translation_test, SubscriberEvent) iox::Error errorValue = iox::Error::kNO_ERROR; auto errorHandlerGuard = iox::ErrorHandler::setTemporaryErrorHandler( [&](const iox::Error e, const std::function, const iox::ErrorLevel) { errorValue = e; }); - EXPECT_EQ(c2cpp::subscriberTooSlowPolicy(static_cast(-1)), - iox::popo::SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA); - EXPECT_THAT(errorValue, Eq(iox::Error::kBINDING_C__UNDEFINED_STATE_IN_IOX_SUBSCRIBER_TOO_SLOW_POLICY)); + EXPECT_EQ(c2cpp::consumerTooSlowPolicy(static_cast(-1)), + iox::popo::ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA); + EXPECT_THAT(errorValue, Eq(iox::Error::kBINDING_C__UNDEFINED_STATE_IN_IOX_CONSUMER_TOO_SLOW_POLICY)); #endif #pragma GCC diagnostic pop } diff --git a/iceoryx_binding_c/test/moduletests/test_cpp2c_enum_translation.cpp b/iceoryx_binding_c/test/moduletests/test_cpp2c_enum_translation.cpp index 2a936ca5fbd..2f258bf606f 100644 --- a/iceoryx_binding_c/test/moduletests/test_cpp2c_enum_translation.cpp +++ b/iceoryx_binding_c/test/moduletests/test_cpp2c_enum_translation.cpp @@ -217,18 +217,18 @@ TEST(cpp2c_enum_translation_test, ListenerResult) #pragma GCC diagnostic pop } -TEST(cpp2c_enum_translation_test, SubscriberTooSlowPolicy) +TEST(cpp2c_enum_translation_test, ConsumerTooSlowPolicy) { ::testing::Test::RecordProperty("TEST_ID", "aad706c2-5216-4835-b29f-8a89829d7238"); - EXPECT_EQ(cpp2c::subscriberTooSlowPolicy(iox::popo::SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER), - SubscriberTooSlowPolicy_WAIT_FOR_SUBSCRIBER); - EXPECT_EQ(cpp2c::subscriberTooSlowPolicy(iox::popo::SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA), - SubscriberTooSlowPolicy_DISCARD_OLDEST_DATA); + EXPECT_EQ(cpp2c::consumerTooSlowPolicy(iox::popo::ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER), + ConsumerTooSlowPolicy_WAIT_FOR_CONSUMER); + EXPECT_EQ(cpp2c::consumerTooSlowPolicy(iox::popo::ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA), + ConsumerTooSlowPolicy_DISCARD_OLDEST_DATA); // ignore the warning since we would like to test the behavior of an invalid enum value #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wconversion" - EXPECT_EQ(cpp2c::subscriberTooSlowPolicy(static_cast(-1)), - SubscriberTooSlowPolicy_DISCARD_OLDEST_DATA); + EXPECT_EQ(cpp2c::consumerTooSlowPolicy(static_cast(-1)), + ConsumerTooSlowPolicy_DISCARD_OLDEST_DATA); #pragma GCC diagnostic pop } diff --git a/iceoryx_binding_c/test/moduletests/test_publisher.cpp b/iceoryx_binding_c/test/moduletests/test_publisher.cpp index 2c885958db3..de6eaacb611 100644 --- a/iceoryx_binding_c/test/moduletests/test_publisher.cpp +++ b/iceoryx_binding_c/test/moduletests/test_publisher.cpp @@ -352,7 +352,7 @@ TEST(iox_pub_options_test, publisherOptionsAreInitializedCorrectly) sut.historyCapacity = 37; sut.nodeName = "Dr.Gonzo"; sut.offerOnCreate = false; - sut.subscriberTooSlowPolicy = SubscriberTooSlowPolicy_WAIT_FOR_SUBSCRIBER; + sut.subscriberTooSlowPolicy = ConsumerTooSlowPolicy_WAIT_FOR_CONSUMER; PublisherOptions options; // set offerOnCreate to the opposite of the expected default to check if it gets overwritten to default @@ -362,7 +362,7 @@ TEST(iox_pub_options_test, publisherOptionsAreInitializedCorrectly) EXPECT_EQ(sut.historyCapacity, options.historyCapacity); EXPECT_EQ(sut.nodeName, nullptr); EXPECT_EQ(sut.offerOnCreate, options.offerOnCreate); - EXPECT_EQ(sut.subscriberTooSlowPolicy, cpp2c::subscriberTooSlowPolicy(options.subscriberTooSlowPolicy)); + EXPECT_EQ(sut.subscriberTooSlowPolicy, cpp2c::consumerTooSlowPolicy(options.subscriberTooSlowPolicy)); EXPECT_TRUE(iox_pub_options_is_initialized(&sut)); } diff --git a/iceoryx_examples/iceoptions/README.md b/iceoryx_examples/iceoptions/README.md index 5f479651bc5..e38c664e2e6 100644 --- a/iceoryx_examples/iceoptions/README.md +++ b/iceoryx_examples/iceoptions/README.md @@ -44,12 +44,12 @@ publisherOptions.nodeName = "Pub_Node_With_Options"; ``` To ensure that samples are never lost, you have the possibility to busy-wait for the subscriber when publishing. -Both publisher and subscriber have to request compatible policies (`SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER` and +Both publisher and subscriber have to request compatible policies (`ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER` and `QueueFullPolicy::BLOCK_PRODUCER`). ```cpp -publisherOptions.subscriberTooSlowPolicy = iox::popo::SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER; +publisherOptions.subscriberTooSlowPolicy = iox::popo::ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER; ``` With this option set, it is possible that a slow subscriber blocks a publisher indefinitely due to the busy waiting loop. diff --git a/iceoryx_examples/iceoptions/iox_publisher_with_options.cpp b/iceoryx_examples/iceoptions/iox_publisher_with_options.cpp index 095cff37e06..ea65b0ac5bf 100644 --- a/iceoryx_examples/iceoptions/iox_publisher_with_options.cpp +++ b/iceoryx_examples/iceoptions/iox_publisher_with_options.cpp @@ -48,7 +48,7 @@ int main() // we allow the subscribers to block the publisher if they want to ensure that no samples are lost //! [too slow policy] - publisherOptions.subscriberTooSlowPolicy = iox::popo::SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER; + publisherOptions.subscriberTooSlowPolicy = iox::popo::ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER; //! [too slow policy] iox::popo::Publisher publisher({"Radar", "FrontLeft", "Object"}, publisherOptions); @@ -71,7 +71,7 @@ int main() std::this_thread::sleep_for(std::chrono::milliseconds(400)); } - // this is optional, but since the iox::popo::SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER option is used, + // this is optional, but since the iox::popo::ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER option is used, // a slow subscriber might block the shutdown and this call unblocks the publisher //! [shutdown] iox::runtime::PoshRuntime::getInstance().shutdown(); diff --git a/iceoryx_hoofs/include/iceoryx_hoofs/error_handling/error_handling.hpp b/iceoryx_hoofs/include/iceoryx_hoofs/error_handling/error_handling.hpp index c83ead6eb3f..cbc37efc5ae 100644 --- a/iceoryx_hoofs/include/iceoryx_hoofs/error_handling/error_handling.hpp +++ b/iceoryx_hoofs/include/iceoryx_hoofs/error_handling/error_handling.hpp @@ -161,7 +161,7 @@ namespace iox error(POSIX_TIMER__INCONSISTENT_STATE) \ error(POSIX_TIMER__CALLBACK_RUNTIME_EXCEEDS_RETRIGGER_TIME) \ error(BINDING_C__UNDEFINED_STATE_IN_IOX_QUEUE_FULL_POLICY) \ - error(BINDING_C__UNDEFINED_STATE_IN_IOX_SUBSCRIBER_TOO_SLOW_POLICY) \ + error(BINDING_C__UNDEFINED_STATE_IN_IOX_CONSUMER_TOO_SLOW_POLICY) \ error(BINDING_C__PUBLISHER_OPTIONS_NOT_INITIALIZED) \ error(BINDING_C__SUBSCRIBER_OPTIONS_NOT_INITIALIZED) \ error(BINDING_C__C2CPP_ENUM_TRANSLATION_INVALID_SUBSCRIBER_EVENT_VALUE) \ diff --git a/iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_distributor.inl b/iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_distributor.inl index 5d786e2f721..24cd1bc9f45 100644 --- a/iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_distributor.inl +++ b/iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_distributor.inl @@ -137,13 +137,11 @@ inline void ChunkDistributor::deliverToAllStoredQueues { typename MemberType_t::LockGuard_t lock(*getMembers()); - bool willWaitForSubscriber = - getMembers()->m_subscriberTooSlowPolicy == SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER; + bool willWaitForConsumer = getMembers()->m_consumerTooSlowPolicy == ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER; // send to all the queues for (auto& queue : getMembers()->m_queues) { - bool isBlockingQueue = - (willWaitForSubscriber && queue->m_queueFullPolicy == QueueFullPolicy::BLOCK_PRODUCER); + bool isBlockingQueue = (willWaitForConsumer && queue->m_queueFullPolicy == QueueFullPolicy::BLOCK_PRODUCER); if (!pushToQueue(queue.get(), chunk)) { @@ -227,10 +225,9 @@ ChunkDistributor::deliverToQueue(const cxx::UniqueId u auto& queue = getMembers()->m_queues[queueIndex.value()]; - bool willWaitForSubscriber = - getMembers()->m_subscriberTooSlowPolicy == SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER; + bool willWaitForConsumer = getMembers()->m_consumerTooSlowPolicy == ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER; - bool isBlockingQueue = (willWaitForSubscriber && queue->m_queueFullPolicy == QueueFullPolicy::BLOCK_PRODUCER); + bool isBlockingQueue = (willWaitForConsumer && queue->m_queueFullPolicy == QueueFullPolicy::BLOCK_PRODUCER); retry = false; if (!pushToQueue(queue.get(), chunk)) diff --git a/iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_distributor_data.hpp b/iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_distributor_data.hpp index 1041f1284c1..52c0440575c 100644 --- a/iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_distributor_data.hpp +++ b/iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_distributor_data.hpp @@ -44,7 +44,7 @@ struct ChunkDistributorData : public LockingPolicy using ChunkQueueData_t = typename ChunkQueuePusherType::MemberType_t; using ChunkDistributorDataProperties_t = ChunkDistributorDataProperties; - ChunkDistributorData(const SubscriberTooSlowPolicy policy, const uint64_t historyCapacity = 0u) noexcept; + ChunkDistributorData(const ConsumerTooSlowPolicy policy, const uint64_t historyCapacity = 0u) noexcept; const uint64_t m_historyCapacity; @@ -59,7 +59,7 @@ struct ChunkDistributorData : public LockingPolicy using HistoryContainer_t = cxx::vector; HistoryContainer_t m_history; - const SubscriberTooSlowPolicy m_subscriberTooSlowPolicy; + const ConsumerTooSlowPolicy m_consumerTooSlowPolicy; }; } // namespace popo diff --git a/iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_distributor_data.inl b/iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_distributor_data.inl index bbf9669529a..0b85eb0c2a7 100644 --- a/iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_distributor_data.inl +++ b/iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_distributor_data.inl @@ -32,10 +32,10 @@ constexpr T min(const T left, const T right) noexcept template inline ChunkDistributorData::ChunkDistributorData( - const SubscriberTooSlowPolicy policy, const uint64_t historyCapacity) noexcept + const ConsumerTooSlowPolicy policy, const uint64_t historyCapacity) noexcept : LockingPolicy() , m_historyCapacity(min(historyCapacity, ChunkDistributorDataProperties_t::MAX_HISTORY_CAPACITY)) - , m_subscriberTooSlowPolicy(policy) + , m_consumerTooSlowPolicy(policy) { if (m_historyCapacity != historyCapacity) { diff --git a/iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_sender_data.hpp b/iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_sender_data.hpp index fedd63c546a..588559d1b6c 100644 --- a/iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_sender_data.hpp +++ b/iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_sender_data.hpp @@ -33,7 +33,7 @@ template memoryManager, - const SubscriberTooSlowPolicy subscriberTooSlowPolicy, + const ConsumerTooSlowPolicy consumerTooSlowPolicy, const uint64_t historyCapacity = 0U, const mepoo::MemoryInfo& memoryInfo = mepoo::MemoryInfo()) noexcept; diff --git a/iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_sender_data.inl b/iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_sender_data.inl index 525fc5204d2..69a05ea3dff 100644 --- a/iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_sender_data.inl +++ b/iceoryx_posh/include/iceoryx_posh/internal/popo/building_blocks/chunk_sender_data.inl @@ -24,10 +24,10 @@ namespace popo template inline ChunkSenderData::ChunkSenderData( cxx::not_null memoryManager, - const SubscriberTooSlowPolicy subscriberTooSlowPolicy, + const ConsumerTooSlowPolicy consumerTooSlowPolicy, const uint64_t historyCapacity, const mepoo::MemoryInfo& memoryInfo) noexcept - : ChunkDistributorDataType(subscriberTooSlowPolicy, historyCapacity) + : ChunkDistributorDataType(consumerTooSlowPolicy, historyCapacity) , m_memoryMgr(memoryManager) , m_memoryInfo(memoryInfo) { diff --git a/iceoryx_posh/include/iceoryx_posh/popo/publisher_options.hpp b/iceoryx_posh/include/iceoryx_posh/popo/publisher_options.hpp index 444b032b6c4..da013abd06d 100644 --- a/iceoryx_posh/include/iceoryx_posh/popo/publisher_options.hpp +++ b/iceoryx_posh/include/iceoryx_posh/popo/publisher_options.hpp @@ -41,7 +41,7 @@ struct PublisherOptions bool offerOnCreate{true}; /// @brief The option whether the publisher should block when the subscriber queue is full - SubscriberTooSlowPolicy subscriberTooSlowPolicy{SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA}; + ConsumerTooSlowPolicy subscriberTooSlowPolicy{ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA}; /// @brief serialization of the PublisherOptions cxx::Serialization serialize() const noexcept; diff --git a/iceoryx_posh/include/iceoryx_posh/runtime/posh_runtime.hpp b/iceoryx_posh/include/iceoryx_posh/runtime/posh_runtime.hpp index 569de2fa67d..dc65942797b 100644 --- a/iceoryx_posh/include/iceoryx_posh/runtime/posh_runtime.hpp +++ b/iceoryx_posh/include/iceoryx_posh/runtime/posh_runtime.hpp @@ -77,7 +77,7 @@ class PoshRuntime RuntimeName_t getInstanceName() const noexcept; /// @brief initiates the shutdown of the runtime to unblock all potentially blocking publisher - /// with the SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER option set + /// with the ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER option set void shutdown() noexcept; /// @brief request the RouDi daemon to create a publisher port diff --git a/iceoryx_posh/source/popo/ports/server_port_roudi.cpp b/iceoryx_posh/source/popo/ports/server_port_roudi.cpp index 7d132c7a9fc..86052bce238 100644 --- a/iceoryx_posh/source/popo/ports/server_port_roudi.cpp +++ b/iceoryx_posh/source/popo/ports/server_port_roudi.cpp @@ -41,7 +41,7 @@ ServerPortRouDi::MemberType_t* ServerPortRouDi::getMembers() noexcept ConsumerTooSlowPolicy ServerPortRouDi::getClientTooSlowPolicy() const noexcept { - return getMembers()->m_chunkSenderData.m_subscriberTooSlowPolicy; + return getMembers()->m_chunkSenderData.m_consumerTooSlowPolicy; } cxx::optional ServerPortRouDi::tryGetCaProMessage() noexcept diff --git a/iceoryx_posh/source/popo/publisher_options.cpp b/iceoryx_posh/source/popo/publisher_options.cpp index a7ed53ac7d3..66562a75bd4 100644 --- a/iceoryx_posh/source/popo/publisher_options.cpp +++ b/iceoryx_posh/source/popo/publisher_options.cpp @@ -27,16 +27,16 @@ cxx::Serialization PublisherOptions::serialize() const noexcept historyCapacity, nodeName, offerOnCreate, - static_cast>(subscriberTooSlowPolicy)); + static_cast>(subscriberTooSlowPolicy)); } cxx::expected PublisherOptions::deserialize(const cxx::Serialization& serialized) noexcept { - using SubscriberTooSlowPolicyUT = std::underlying_type_t; + using ConsumerTooSlowPolicyUT = std::underlying_type_t; PublisherOptions publisherOptions; - SubscriberTooSlowPolicyUT subscriberTooSlowPolicy; + ConsumerTooSlowPolicyUT subscriberTooSlowPolicy; auto deserializationSuccessful = serialized.extract(publisherOptions.historyCapacity, publisherOptions.nodeName, @@ -44,13 +44,12 @@ PublisherOptions::deserialize(const cxx::Serialization& serialized) noexcept subscriberTooSlowPolicy); if (!deserializationSuccessful - || subscriberTooSlowPolicy - > static_cast(SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA)) + || subscriberTooSlowPolicy > static_cast(ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA)) { return cxx::error(cxx::Serialization::Error::DESERIALIZATION_FAILED); } - publisherOptions.subscriberTooSlowPolicy = static_cast(subscriberTooSlowPolicy); + publisherOptions.subscriberTooSlowPolicy = static_cast(subscriberTooSlowPolicy); return cxx::success(publisherOptions); } } // namespace popo diff --git a/iceoryx_posh/source/roudi/port_manager.cpp b/iceoryx_posh/source/roudi/port_manager.cpp index b45e86d8e6d..5af4a2e1a5c 100644 --- a/iceoryx_posh/source/roudi/port_manager.cpp +++ b/iceoryx_posh/source/roudi/port_manager.cpp @@ -318,7 +318,7 @@ bool isCompatible(const PublisherPortRouDiType& publisher, const SubscriberPortT auto& subOpts = subscriber.getOptions(); const bool blockingPoliciesAreCompatible = - !(pubOpts.subscriberTooSlowPolicy == popo::SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA + !(pubOpts.subscriberTooSlowPolicy == popo::ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA && subOpts.queueFullPolicy == popo::QueueFullPolicy::BLOCK_PRODUCER); const bool historyRequestIsCompatible = diff --git a/iceoryx_posh/source/runtime/posh_runtime_impl.cpp b/iceoryx_posh/source/runtime/posh_runtime_impl.cpp index f84e9097a33..cb9b37694bd 100644 --- a/iceoryx_posh/source/runtime/posh_runtime_impl.cpp +++ b/iceoryx_posh/source/runtime/posh_runtime_impl.cpp @@ -427,7 +427,7 @@ void PoshRuntimeImpl::sendKeepAliveAndHandleShutdownPreparation() noexcept // this is not the nicest solution, but we cannot send this in the signal handler where m_shutdownRequested is // usually set; luckily the runtime already has a thread running and therefore this thread is used to unblock the // application shutdown from a potentially blocking publisher with the - // SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER option set + // ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER option set if (m_shutdownRequested.exchange(false, std::memory_order_relaxed)) { // Inform RouDi to prepare for app shutdown diff --git a/iceoryx_posh/test/integrationtests/test_popo_chunk_building_blocks.cpp b/iceoryx_posh/test/integrationtests/test_popo_chunk_building_blocks.cpp index 094636fbe54..7f5a8d8bf01 100644 --- a/iceoryx_posh/test/integrationtests/test_popo_chunk_building_blocks.cpp +++ b/iceoryx_posh/test/integrationtests/test_popo_chunk_building_blocks.cpp @@ -209,11 +209,11 @@ class ChunkBuildingBlocks_IntegrationTest : public Test MemoryManager m_memoryManager; // Objects used by publishing thread - ChunkSenderData_t m_chunkSenderData{&m_memoryManager, SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA}; + ChunkSenderData_t m_chunkSenderData{&m_memoryManager, ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA}; ChunkSender m_chunkSender{&m_chunkSenderData}; // Objects used by forwarding thread - ChunkDistributorData_t m_chunkDistributorData{SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA}; + ChunkDistributorData_t m_chunkDistributorData{ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA}; ChunkDistributor_t m_chunkDistributor{&m_chunkDistributorData}; ChunkQueueData_t m_chunkQueueData{ QueueFullPolicy::DISCARD_OLDEST_DATA, diff --git a/iceoryx_posh/test/integrationtests/test_publisher_subscriber_communication.cpp b/iceoryx_posh/test/integrationtests/test_publisher_subscriber_communication.cpp index 93663840ae7..d6a284b6120 100644 --- a/iceoryx_posh/test/integrationtests/test_publisher_subscriber_communication.cpp +++ b/iceoryx_posh/test/integrationtests/test_publisher_subscriber_communication.cpp @@ -57,7 +57,7 @@ class PublisherSubscriberCommunication_test : public RouDi_GTest template std::unique_ptr> - createPublisher(const SubscriberTooSlowPolicy policy = SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA, + createPublisher(const ConsumerTooSlowPolicy policy = ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA, const capro::Interfaces interface = capro::Interfaces::INTERNAL) { iox::popo::PublisherOptions options; @@ -275,7 +275,7 @@ TEST_F(PublisherSubscriberCommunication_test, SubscriberCanOnlyBeSubscribedWhenI m_watchdog.watchAndActOnFailure(); - auto publisher = createPublisher(SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA, + auto publisher = createPublisher(ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA, static_cast(publisherInterface)); this->InterOpWait(); @@ -540,7 +540,7 @@ TEST_F(PublisherSubscriberCommunication_test, SendingComplexDataType_variant) TEST_F(PublisherSubscriberCommunication_test, PublisherBlocksWhenBlockingActivatedOnBothSidesAndSubscriberQueueIsFull) { ::testing::Test::RecordProperty("TEST_ID", "e97f1665-3488-4288-8fde-f485067bfeb4"); - auto publisher = createPublisher>(SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER); + auto publisher = createPublisher>(ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER); this->InterOpWait(); auto subscriber = createSubscriber>(QueueFullPolicy::BLOCK_PRODUCER, 2U); @@ -584,7 +584,7 @@ TEST_F(PublisherSubscriberCommunication_test, PublisherBlocksWhenBlockingActivat TEST_F(PublisherSubscriberCommunication_test, PublisherDoesNotBlockAndDiscardsSamplesWhenNonBlockingActivated) { ::testing::Test::RecordProperty("TEST_ID", "1d92226d-fb3a-487c-bf52-6eb3c7946dc6"); - auto publisher = createPublisher>(SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA); + auto publisher = createPublisher>(ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA); this->InterOpWait(); auto subscriber = createSubscriber>(QueueFullPolicy::DISCARD_OLDEST_DATA, 2U); @@ -619,7 +619,7 @@ TEST_F(PublisherSubscriberCommunication_test, PublisherDoesNotBlockAndDiscardsSa TEST_F(PublisherSubscriberCommunication_test, NoSubscriptionWhenSubscriberWantsBlockingAndPublisherDoesNotOfferBlocking) { ::testing::Test::RecordProperty("TEST_ID", "c0144704-6dd7-4354-a41d-d4e512633484"); - auto publisher = createPublisher>(SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA); + auto publisher = createPublisher>(ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA); this->InterOpWait(); auto subscriber = createSubscriber>(QueueFullPolicy::BLOCK_PRODUCER, 2U); @@ -635,7 +635,7 @@ TEST_F(PublisherSubscriberCommunication_test, NoSubscriptionWhenSubscriberWantsB TEST_F(PublisherSubscriberCommunication_test, SubscriptionWhenSubscriberDoesNotRequireBlockingButPublisherSupportsIt) { ::testing::Test::RecordProperty("TEST_ID", "228ea848-8926-4779-9e38-4d92eeb87feb"); - auto publisher = createPublisher>(SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER); + auto publisher = createPublisher>(ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER); this->InterOpWait(); auto subscriber = createSubscriber>(QueueFullPolicy::DISCARD_OLDEST_DATA, 2U); @@ -652,8 +652,8 @@ TEST_F(PublisherSubscriberCommunication_test, SubscriptionWhenSubscriberDoesNotR TEST_F(PublisherSubscriberCommunication_test, MixedOptionsSetupWorksWithBlocking) { ::testing::Test::RecordProperty("TEST_ID", "c60ade45-1765-40ca-bc4b-7452c82ba127"); - auto publisherBlocking = createPublisher>(SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER); - auto publisherNonBlocking = createPublisher>(SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA); + auto publisherBlocking = createPublisher>(ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER); + auto publisherNonBlocking = createPublisher>(ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA); this->InterOpWait(); auto subscriberBlocking = createSubscriber>(QueueFullPolicy::BLOCK_PRODUCER, 2U); diff --git a/iceoryx_posh/test/moduletests/test_popo_chunk_distributor.cpp b/iceoryx_posh/test/moduletests/test_popo_chunk_distributor.cpp index e6387e1776f..6128f46b7a2 100644 --- a/iceoryx_posh/test/moduletests/test_popo_chunk_distributor.cpp +++ b/iceoryx_posh/test/moduletests/test_popo_chunk_distributor.cpp @@ -111,7 +111,7 @@ class ChunkDistributor_test : public Test } std::shared_ptr - getChunkDistributorData(const SubscriberTooSlowPolicy policy = SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA) + getChunkDistributorData(const ConsumerTooSlowPolicy policy = ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA) { return std::make_shared(policy, HISTORY_SIZE); } @@ -624,7 +624,7 @@ TYPED_TEST(ChunkDistributor_test, DeliverToQueueWithBlockingOptionBlocksDelivery constexpr uint32_t EXPECTED_QUEUE_INDEX{0U}; using ChunkQueueData_t = typename TestFixture::ChunkQueueData_t; - auto sutData = this->getChunkDistributorData(SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER); + auto sutData = this->getChunkDistributorData(ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER); typename TestFixture::ChunkDistributor_t sut(sutData.get()); auto queueData = @@ -743,7 +743,7 @@ TYPED_TEST(ChunkDistributor_test, DeliverHistoryOnAddWithMoreThanAvailable) TYPED_TEST(ChunkDistributor_test, DeliverToSingleQueueBlocksWhenOptionsAreSetToBlocking) { ::testing::Test::RecordProperty("TEST_ID", "c0500dec-bbd8-4958-9545-a14ef68108a1"); - auto sutData = this->getChunkDistributorData(SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER); + auto sutData = this->getChunkDistributorData(ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER); typename TestFixture::ChunkDistributor_t sut(sutData.get()); auto queueData = @@ -781,7 +781,7 @@ TYPED_TEST(ChunkDistributor_test, DeliverToSingleQueueBlocksWhenOptionsAreSetToB TYPED_TEST(ChunkDistributor_test, MultipleBlockingQueuesWillBeFilledWhenThereBecomesSpaceAvailable) { ::testing::Test::RecordProperty("TEST_ID", "8168749d-8472-4999-83b0-5b36a77b04ed"); - auto sutData = this->getChunkDistributorData(SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER); + auto sutData = this->getChunkDistributorData(ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER); typename TestFixture::ChunkDistributor_t sut(sutData.get()); std::vector> queueDatas; diff --git a/iceoryx_posh/test/moduletests/test_popo_chunk_sender.cpp b/iceoryx_posh/test/moduletests/test_popo_chunk_sender.cpp index 818be13c3ed..1796f307122 100644 --- a/iceoryx_posh/test/moduletests/test_popo_chunk_sender.cpp +++ b/iceoryx_posh/test/moduletests/test_popo_chunk_sender.cpp @@ -107,9 +107,9 @@ class ChunkSender_test : public Test ChunkQueueData_t m_chunkQueueData{iox::popo::QueueFullPolicy::DISCARD_OLDEST_DATA, iox::cxx::VariantQueueTypes::SoFi_SingleProducerSingleConsumer}; ChunkSenderData_t m_chunkSenderData{ - &m_memoryManager, iox::popo::SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA, 0}; // must be 0 for test + &m_memoryManager, iox::popo::ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA, 0}; // must be 0 for test ChunkSenderData_t m_chunkSenderDataWithHistory{ - &m_memoryManager, iox::popo::SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA, HISTORY_CAPACITY}; + &m_memoryManager, iox::popo::ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA, HISTORY_CAPACITY}; iox::popo::ChunkSender m_chunkSender{&m_chunkSenderData}; iox::popo::ChunkSender m_chunkSenderWithHistory{&m_chunkSenderDataWithHistory}; diff --git a/iceoryx_posh/test/moduletests/test_popo_publisher_options.cpp b/iceoryx_posh/test/moduletests/test_popo_publisher_options.cpp index 8492fa2cfa3..e8d3a0ef3f3 100644 --- a/iceoryx_posh/test/moduletests/test_popo_publisher_options.cpp +++ b/iceoryx_posh/test/moduletests/test_popo_publisher_options.cpp @@ -31,7 +31,7 @@ TEST(PublisherOptions_test, SerializationRoundTripIsSuccessful) testOptions.historyCapacity = 42; testOptions.nodeName = "hypnotoad"; testOptions.offerOnCreate = false; - testOptions.subscriberTooSlowPolicy = iox::popo::SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER; + testOptions.subscriberTooSlowPolicy = iox::popo::ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER; iox::popo::PublisherOptions::deserialize(testOptions.serialize()) .and_then([&](auto& roundTripOptions) { @@ -65,7 +65,7 @@ TEST(PublisherOptions_test, DeserializingInvalidSubscriberTooSlowPolicyFails) constexpr uint64_t HISTORY_CAPACITY{42U}; const iox::NodeName_t NODE_NAME{"harr-harr"}; constexpr bool OFFER_ON_CREATE{true}; - constexpr std::underlying_type_t SUBSCRIBER_TOO_SLOW_POLICY{111}; + constexpr std::underlying_type_t SUBSCRIBER_TOO_SLOW_POLICY{111}; const auto serialized = iox::cxx::Serialization::create(HISTORY_CAPACITY, NODE_NAME, OFFER_ON_CREATE, SUBSCRIBER_TOO_SLOW_POLICY); diff --git a/iceoryx_posh/test/moduletests/test_popo_publisher_port.cpp b/iceoryx_posh/test/moduletests/test_popo_publisher_port.cpp index 78492f7f516..7dc00b03632 100644 --- a/iceoryx_posh/test/moduletests/test_popo_publisher_port.cpp +++ b/iceoryx_posh/test/moduletests/test_popo_publisher_port.cpp @@ -81,7 +81,7 @@ class PublisherPort_test : public Test // publisher port w/o offer on create iox::popo::PublisherOptions m_noOfferOnCreatePublisherOptions{ - 0U, iox::NodeName_t{""}, false, iox::popo::SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA}; + 0U, iox::NodeName_t{""}, false, iox::popo::ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA}; iox::popo::PublisherPortData m_publisherPortDataNoOfferOnCreate{ iox::capro::ServiceDescription("a", "b", "c"), "myApp", &m_memoryManager, m_noOfferOnCreatePublisherOptions}; iox::popo::PublisherPortRouDi m_sutNoOfferOnCreateRouDiSide{&m_publisherPortDataNoOfferOnCreate}; @@ -89,7 +89,7 @@ class PublisherPort_test : public Test // publisher port that waits for subscriber when queue is full iox::popo::PublisherOptions m_waitForSubscriberPublisherOptions{ - 0U, iox::NodeName_t{""}, false, iox::popo::SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER}; + 0U, iox::NodeName_t{""}, false, iox::popo::ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER}; iox::popo::PublisherPortData m_publisherPortDataWaitForSubscriber{ iox::capro::ServiceDescription("a", "b", "c"), "myApp", &m_memoryManager, m_waitForSubscriberPublisherOptions}; iox::popo::PublisherPortRouDi m_sutWaitForSubscriberRouDiSide{&m_publisherPortDataWaitForSubscriber}; @@ -97,7 +97,7 @@ class PublisherPort_test : public Test // publisher port w/ history iox::popo::PublisherOptions m_withHistoryPublisherOptions{ - iox::MAX_PUBLISHER_HISTORY, iox::NodeName_t{""}, true, iox::popo::SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA}; + iox::MAX_PUBLISHER_HISTORY, iox::NodeName_t{""}, true, iox::popo::ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA}; iox::popo::PublisherPortData m_publisherPortDataHistory{ iox::capro::ServiceDescription("x", "y", "z"), "myApp", &m_memoryManager, m_withHistoryPublisherOptions}; iox::popo::PublisherPortUser m_sutWithHistoryUserSide{&m_publisherPortDataHistory}; @@ -133,7 +133,7 @@ TEST_F(PublisherPort_test, noWaitingForSubscriberWithDefaultOptions) { ::testing::Test::RecordProperty("TEST_ID", "d1f74874-257a-4e8f-aabf-8eadad5b4367"); EXPECT_THAT(m_sutWithDefaultOptionsRouDiSide.getOptions().subscriberTooSlowPolicy, - Eq(iox::popo::SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA)); + Eq(iox::popo::ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA)); } TEST_F(PublisherPort_test, initialStateReturnsOfferCaProMessageWithDefaultOptions) @@ -158,7 +158,7 @@ TEST_F(PublisherPort_test, waitingForSubscriberWhenDesired) { ::testing::Test::RecordProperty("TEST_ID", "49526d1a-e81a-4e4a-8fb4-1a96dee83ae7"); EXPECT_THAT(m_sutWaitForSubscriberRouDiSide.getOptions().subscriberTooSlowPolicy, - Eq(iox::popo::SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER)); + Eq(iox::popo::ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER)); } TEST_F(PublisherPort_test, offerCallResultsInOfferedState) diff --git a/iceoryx_posh/test/moduletests/test_posh_runtime.cpp b/iceoryx_posh/test/moduletests/test_posh_runtime.cpp index cda2c062798..9d001c69ae5 100644 --- a/iceoryx_posh/test/moduletests/test_posh_runtime.cpp +++ b/iceoryx_posh/test/moduletests/test_posh_runtime.cpp @@ -360,37 +360,37 @@ TEST_F(PoshRuntime_test, GetMiddlewarePublisherWithoutExplicitlySetQueueFullPoli publisherOptions, iox::runtime::PortConfigInfo(11U, 22U, 33U)); - EXPECT_THAT(publisherPortData->m_chunkSenderData.m_subscriberTooSlowPolicy, - Eq(iox::popo::SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA)); + EXPECT_THAT(publisherPortData->m_chunkSenderData.m_consumerTooSlowPolicy, + Eq(iox::popo::ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA)); } TEST_F(PoshRuntime_test, GetMiddlewarePublisherWithQueueFullPolicySetToDiscardOldestDataLeadsToDiscardOldestData) { ::testing::Test::RecordProperty("TEST_ID", "67362686-3165-4a49-a15c-ac9fcaf704d8"); iox::popo::PublisherOptions publisherOptions; - publisherOptions.subscriberTooSlowPolicy = iox::popo::SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA; + publisherOptions.subscriberTooSlowPolicy = iox::popo::ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA; const auto publisherPortData = m_runtime->getMiddlewarePublisher(iox::capro::ServiceDescription("90", "130", "1550"), publisherOptions, iox::runtime::PortConfigInfo(11U, 22U, 33U)); - EXPECT_THAT(publisherPortData->m_chunkSenderData.m_subscriberTooSlowPolicy, - Eq(iox::popo::SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA)); + EXPECT_THAT(publisherPortData->m_chunkSenderData.m_consumerTooSlowPolicy, + Eq(iox::popo::ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA)); } TEST_F(PoshRuntime_test, GetMiddlewarePublisherWithQueueFullPolicySetToWaitForSubscriberLeadsToWaitForSubscriber) { ::testing::Test::RecordProperty("TEST_ID", "f6439a76-69c7-422d-bcc9-7c1d82cd2990"); iox::popo::PublisherOptions publisherOptions; - publisherOptions.subscriberTooSlowPolicy = iox::popo::SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER; + publisherOptions.subscriberTooSlowPolicy = iox::popo::ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER; const auto publisherPortData = m_runtime->getMiddlewarePublisher(iox::capro::ServiceDescription("18", "31", "400"), publisherOptions, iox::runtime::PortConfigInfo(11U, 22U, 33U)); - EXPECT_THAT(publisherPortData->m_chunkSenderData.m_subscriberTooSlowPolicy, - Eq(iox::popo::SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER)); + EXPECT_THAT(publisherPortData->m_chunkSenderData.m_consumerTooSlowPolicy, + Eq(iox::popo::ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER)); } TEST_F(PoshRuntime_test, GetMiddlewareSubscriberIsSuccessful) @@ -620,7 +620,7 @@ TEST_F(PoshRuntime_test, ShutdownUnblocksBlockingPublisher) iox::capro::ServiceDescription serviceDescription{"don't", "stop", "me"}; iox::popo::PublisherOptions publisherOptions{ - 0U, iox::NodeName_t("node"), true, iox::popo::SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER}; + 0U, iox::NodeName_t("node"), true, iox::popo::ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER}; iox::popo::SubscriberOptions subscriberOptions{ 1U, 0U, iox::NodeName_t("node"), true, iox::popo::QueueFullPolicy::BLOCK_PRODUCER}; diff --git a/iceoryx_posh/test/moduletests/test_roudi_portmanager.cpp b/iceoryx_posh/test/moduletests/test_roudi_portmanager.cpp index dd96f516fdc..581a5c3a1f6 100644 --- a/iceoryx_posh/test/moduletests/test_roudi_portmanager.cpp +++ b/iceoryx_posh/test/moduletests/test_roudi_portmanager.cpp @@ -206,7 +206,7 @@ void setDestroyFlagAndClearContainer(vector& container) PublisherOptions createTestPubOptions() { - return PublisherOptions{0U, iox::NodeName_t("node"), true, iox::popo::SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA}; + return PublisherOptions{0U, iox::NodeName_t("node"), true, iox::popo::ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA}; } SubscriberOptions createTestSubOptions() @@ -495,7 +495,7 @@ TEST_F(PortManager_test, DoDiscoveryPublisherCanWaitAndSubscriberRequestsBlockin { ::testing::Test::RecordProperty("TEST_ID", "34380b13-5541-4fdf-b266-beccb90f5215"); PublisherOptions publisherOptions{ - 1U, iox::NodeName_t("node"), true, iox::popo::SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER}; + 1U, iox::NodeName_t("node"), true, iox::popo::ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER}; SubscriberOptions subscriberOptions{1U, 1U, iox::NodeName_t("node"), true, QueueFullPolicy::BLOCK_PRODUCER}; PublisherPortUser publisher( m_portManager @@ -516,7 +516,7 @@ TEST_F(PortManager_test, DoDiscoveryBothDiscardOldestPolicyLeadsToConnect) { ::testing::Test::RecordProperty("TEST_ID", "3cf03140-9ca6-47a1-b45b-8cfa70e3fd5c"); PublisherOptions publisherOptions{ - 1U, iox::NodeName_t("node"), true, iox::popo::SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA}; + 1U, iox::NodeName_t("node"), true, iox::popo::ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA}; SubscriberOptions subscriberOptions{1U, 1U, iox::NodeName_t("node"), true, QueueFullPolicy::DISCARD_OLDEST_DATA}; PublisherPortUser publisher( m_portManager @@ -537,7 +537,7 @@ TEST_F(PortManager_test, DoDiscoveryPublisherDoesNotAllowBlockingAndSubscriberRe { ::testing::Test::RecordProperty("TEST_ID", "31d879bf-ca07-4f29-90cd-a46f09a98f7c"); PublisherOptions publisherOptions{ - 1U, iox::NodeName_t("node"), true, iox::popo::SubscriberTooSlowPolicy::DISCARD_OLDEST_DATA}; + 1U, iox::NodeName_t("node"), true, iox::popo::ConsumerTooSlowPolicy::DISCARD_OLDEST_DATA}; SubscriberOptions subscriberOptions{1U, 1U, iox::NodeName_t("node"), true, QueueFullPolicy::BLOCK_PRODUCER}; PublisherPortUser publisher( m_portManager @@ -557,7 +557,7 @@ TEST_F(PortManager_test, DoDiscoveryPublisherCanWaitAndSubscriberDiscardOldestLe { ::testing::Test::RecordProperty("TEST_ID", "f2ea15a6-0672-4a98-8f80-f2900b247ac0"); PublisherOptions publisherOptions{ - 1U, iox::NodeName_t("node"), true, iox::popo::SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER}; + 1U, iox::NodeName_t("node"), true, iox::popo::ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER}; SubscriberOptions subscriberOptions{1U, 1U, iox::NodeName_t("node"), true, QueueFullPolicy::DISCARD_OLDEST_DATA}; PublisherPortUser publisher( m_portManager @@ -884,7 +884,7 @@ TEST_F(PortManager_test, UnblockProcessShutdownMakesPublisherStopOffer) // get publisher and subscriber PublisherOptions publisherOptions{ - 0U, iox::NodeName_t("node"), true, iox::popo::SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER}; + 0U, iox::NodeName_t("node"), true, iox::popo::ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER}; PublisherPortUser publisher(m_portManager ->acquirePublisherPortData({"1", "1", "1"}, publisherOptions, @@ -905,7 +905,7 @@ void PortManager_test::setupAndTestBlockingPublisher(const iox::RuntimeName_t& p { // get publisher and subscriber PublisherOptions publisherOptions{ - 0U, iox::NodeName_t("node"), true, iox::popo::SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER}; + 0U, iox::NodeName_t("node"), true, iox::popo::ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER}; SubscriberOptions subscriberOptions{ 1U, 0U, iox::NodeName_t("node"), true, iox::popo::QueueFullPolicy::BLOCK_PRODUCER}; PublisherPortUser publisher(m_portManager diff --git a/iceoryx_posh/test/moduletests/test_roudi_process_manager.cpp b/iceoryx_posh/test/moduletests/test_roudi_process_manager.cpp index 80fb5a86be8..e2e9b5d8faf 100644 --- a/iceoryx_posh/test/moduletests/test_roudi_process_manager.cpp +++ b/iceoryx_posh/test/moduletests/test_roudi_process_manager.cpp @@ -139,7 +139,7 @@ TEST_F(ProcessManager_test, HandleProcessShutdownPreparationRequestWorks) // get publisher and subscriber PublisherOptions publisherOptions{ - 0U, iox::NodeName_t("node"), true, iox::popo::SubscriberTooSlowPolicy::WAIT_FOR_SUBSCRIBER}; + 0U, iox::NodeName_t("node"), true, iox::popo::ConsumerTooSlowPolicy::WAIT_FOR_CONSUMER}; PublisherPortUser publisher(m_portManager ->acquirePublisherPortData({"1", "1", "1"}, publisherOptions,