From 7264fc994fb9b5875b3d9c6208dfb512eef522e0 Mon Sep 17 00:00:00 2001 From: Jing Zhang Date: Tue, 22 Mar 2022 16:22:00 -0700 Subject: [PATCH 1/4] fix conflicts --- src/DbInterface.cpp | 8 +-- src/DbInterface.h | 6 +- src/common/MuxConfig.h | 11 ++++ src/common/MuxPortConfig.h | 9 +++ src/link_manager/LinkManagerStateMachine.cpp | 23 +++++++- src/link_manager/LinkManagerStateMachine.h | 33 ++++++++++- src/link_prober/LinkProber.cpp | 60 +++++++++++++++++++- src/link_prober/LinkProber.h | 43 ++++++++++++++ test/FakeLinkProber.cpp | 15 +++++ test/FakeLinkProber.h | 6 ++ test/FakeMuxPort.cpp | 6 ++ test/LinkManagerStateMachineTest.cpp | 6 +- test/MuxManagerTest.cpp | 6 ++ 13 files changed, 217 insertions(+), 15 deletions(-) diff --git a/src/DbInterface.cpp b/src/DbInterface.cpp index 6ea9751f..28d20bd1 100644 --- a/src/DbInterface.cpp +++ b/src/DbInterface.cpp @@ -46,7 +46,7 @@ constexpr auto DEFAULT_TIMEOUT_MSEC = 1000; std::vector DbInterface::mMuxState = {"active", "standby", "unknown", "Error"}; std::vector DbInterface::mMuxLinkmgrState = {"uninitialized", "unhealthy", "healthy"}; std::vector DbInterface::mMuxMetrics = {"start", "end"}; -std::vector DbInterface::mLinkProbeMetrics = {"link_prober_unknown_start", "link_prober_unknown_end"}; +std::vector DbInterface::mLinkProbeMetrics = {"link_prober_unknown_start", "link_prober_unknown_end", "link_prober_wait_start", "link_prober_active_start", "link_prober_standby_start"}; // // ---> DbInterface(mux::MuxManager *muxManager); @@ -168,13 +168,13 @@ void DbInterface::postMetricsEvent( // link_manager::LinkManagerStateMachine::LinkProberMetrics metrics // ); // -// post link probe pck loss event to state db +// post link probe event to state db void DbInterface::postLinkProberMetricsEvent( const std::string &portName, link_manager::LinkManagerStateMachine::LinkProberMetrics metrics ) { - MUXLOGWARNING(boost::format("%s: posting link prober pck loss event %s") % + MUXLOGWARNING(boost::format("%s: posting link prober event %s") % portName % mLinkProbeMetrics[static_cast (metrics)] ); @@ -393,7 +393,7 @@ void DbInterface::handlePostLinkProberMetrics( boost::posix_time::ptime time ) { - MUXLOGWARNING(boost::format("%s: posting link prober pck loss event %s") % + MUXLOGWARNING(boost::format("%s: posting link prober event %s") % portName % mLinkProbeMetrics[static_cast (metrics)] ); diff --git a/src/DbInterface.h b/src/DbInterface.h index 510eb69f..2d925c51 100644 --- a/src/DbInterface.h +++ b/src/DbInterface.h @@ -176,10 +176,10 @@ class DbInterface /** * @method postLinkProberMetricsEvent * - * @brief post link prober pck loss event + * @brief post link prober event * * @param portName (in) port name - * @param metrics (in) pck loss event name + * @param metrics (in) link prober event name * * @return none * @@ -316,7 +316,7 @@ class DbInterface /** * @method handlePostLinkProberMetrics * - * @brief post link prober pck loss event to state db + * @brief post link prober event to state db * * @param portName (in) port name * @param metrics (in) metrics data diff --git a/src/common/MuxConfig.h b/src/common/MuxConfig.h index 4a34f7a2..60f7f1dc 100644 --- a/src/common/MuxConfig.h +++ b/src/common/MuxConfig.h @@ -266,6 +266,15 @@ class MuxConfig *@return IPv4 address */ inline boost::asio::ip::address getLoopbackIpv4Address() {return mLoopbackIpv4Address;}; + + /** + *@method getDecreasedTimeoutIpv4_msec + * + *@brief getter for decreased IPv4 LinkProber timeout in msec + * + *@return timeout in msec + */ + inline uint32_t getDecreasedTimeoutIpv4_msec() const {return mDecreasedTimeoutIpv4_msec;}; private: uint8_t mNumberOfThreads = 5; @@ -277,6 +286,8 @@ class MuxConfig uint32_t mMuxStateChangeRetryCount = 1; uint32_t mLinkStateChangeRetryCount = 1; + uint32_t mDecreasedTimeoutIpv4_msec = 10; + std::array mTorMacAddress; boost::asio::ip::address mLoopbackIpv4Address = boost::asio::ip::make_address("10.212.64.0"); }; diff --git a/src/common/MuxPortConfig.h b/src/common/MuxPortConfig.h index c6ca44c9..b998356f 100644 --- a/src/common/MuxPortConfig.h +++ b/src/common/MuxPortConfig.h @@ -251,6 +251,15 @@ class MuxPortConfig */ inline Mode getMode() const {return mMode;}; + /** + *@method getDecreasedTimeoutIpv4_msec + * + *@brief getter for decreased IPv4 LinkProber timeout in msec + * + *@return timeout in msec + */ + inline uint32_t getDecreasedTimeoutIpv4_msec() const {return mMuxConfig.getDecreasedTimeoutIpv4_msec();}; + private: MuxConfig &mMuxConfig; std::string mPortName; diff --git a/src/link_manager/LinkManagerStateMachine.cpp b/src/link_manager/LinkManagerStateMachine.cpp index 9b8017cf..d2987065 100644 --- a/src/link_manager/LinkManagerStateMachine.cpp +++ b/src/link_manager/LinkManagerStateMachine.cpp @@ -301,6 +301,11 @@ void LinkManagerStateMachine::enterLinkProberState(CompositeState &nextState, li { mLinkProberStateMachine.enterState(label); ps(nextState) = label; + + // link prober entering wait indicating switchover is initiated, but a switchover can be skipped if mode == manual. + if(label == link_prober::LinkProberState::Label::Wait) { + mMuxPortPtr->postLinkProberMetricsEvent(link_manager::ActiveStandbyStateMachine::LinkProberMetrics::LinkProberWaitStart); + } } // @@ -358,6 +363,7 @@ void LinkManagerStateMachine::switchMuxState( mMuxStateMachine.setWaitStateCause(mux_state::WaitState::WaitStateCause::SwssUpdate); mMuxPortPtr->postMetricsEvent(Metrics::SwitchingStart, label); mMuxPortPtr->setMuxState(label); + mDecreaseIntervalFnPtr(mMuxPortConfig.getLinkWaitTimeout_msec()); mDeadlineTimer.cancel(); startMuxWaitTimer(); } else { @@ -406,6 +412,12 @@ void LinkManagerStateMachine::handleSwssBladeIpv4AddressUpdate(boost::asio::ip:: mResetIcmpPacketCountsFnPtr = boost::bind( &link_prober::LinkProber::resetIcmpPacketCounts, mLinkProberPtr.get() ); + mDecreaseIntervalFnPtr = boost::bind( + &link_prober::LinkProber::decreaseProbeIntervalAfterSwitch, mLinkProberPtr.get(), boost::placeholders::_1 + ); + mRevertIntervalFnPtr = boost::bind( + &link_prober::LinkProber::revertProbeIntervalAfterSwitchComplete, mLinkProberPtr.get() + ); mComponentInitState.set(LinkProberComponent); activateStateMachine(); @@ -471,13 +483,17 @@ void LinkManagerStateMachine::handleStateChange(LinkProberEvent &event, link_pro mLinkProberStateName[state] ); - // update state db link prober metrics to collect pck loss data + // update state db link prober metrics to collect link prober state change data if (mContinuousLinkProberUnknownEvent == true && state != link_prober::LinkProberState::Unknown) { mContinuousLinkProberUnknownEvent = false; mMuxPortPtr->postLinkProberMetricsEvent(link_manager::LinkManagerStateMachine::LinkProberMetrics::LinkProberUnknownEnd); } else if (state == link_prober::LinkProberState::Label::Unknown) { mContinuousLinkProberUnknownEvent = true; mMuxPortPtr->postLinkProberMetricsEvent(link_manager::LinkManagerStateMachine::LinkProberMetrics::LinkProberUnknownStart); + } else if (state == link_prober::LinkProberState::Label::Active) { + mMuxPortPtr->postLinkProberMetricsEvent(link_manager::LinkManagerStateMachine::LinkProberMetrics::LinkProberActiveStart); + } else if (state == link_prober::LinkProberState::Label::Standby) { + mMuxPortPtr->postLinkProberMetricsEvent(link_manager::LinkManagerStateMachine::LinkProberMetrics::LinkProberStandbyStart); } CompositeState nextState = mCompositeState; @@ -860,7 +876,7 @@ void LinkManagerStateMachine::handleDefaultRouteStateNotification(const std::str if (mComponentInitState.test(MuxStateComponent)) { if (ms(mCompositeState) != mux_state::MuxState::Label::Standby && routeState == "na") { mSendPeerSwitchCommandFnPtr(); - // In case Mux is in wait state, switchMuxSate(standby) will be skipped. Setting mux state in app db to be standby so tunnel can be established. + // In case Mux is in wait state, switchMuxState(standby) will be skipped. Setting mux state in app db to be standby so tunnel can be established. mMuxPortPtr->setMuxState(mux_state::MuxState::Label::Standby); } else { enterMuxWaitState(mCompositeState); @@ -909,6 +925,7 @@ void LinkManagerStateMachine::updateMuxLinkmgrState() (ps(mCompositeState) == link_prober::LinkProberState::Label::Standby && ms(mCompositeState) == mux_state::MuxState::Label::Standby))) { label = Label::Healthy; + mRevertIntervalFnPtr(); } setLabel(label); @@ -988,7 +1005,7 @@ void LinkManagerStateMachine::handleMuxWaitTimeout(boost::system::error_code err // on the 3rd timeout, send switch active command to peer if (mMuxWaitTimeoutCount == mMuxPortConfig.getNegativeStateChangeRetryCount()) { mSendPeerSwitchCommandFnPtr(); - // Mux is in wait state, switchMuxSate(standby) will be skipped. Setting mux state in app db to be standby so tunnel can be established. + // Mux is in wait state, switchMuxState(standby) will be skipped. Setting mux state in app db to be standby so tunnel can be established. mMuxPortPtr->setMuxState(mux_state::MuxState::Label::Standby); } } else { diff --git a/src/link_manager/LinkManagerStateMachine.h b/src/link_manager/LinkManagerStateMachine.h index c7e2fca0..2106797e 100644 --- a/src/link_manager/LinkManagerStateMachine.h +++ b/src/link_manager/LinkManagerStateMachine.h @@ -124,6 +124,9 @@ class LinkManagerStateMachine: public common::StateMachine, enum class LinkProberMetrics { LinkProberUnknownStart, LinkProberUnknownEnd, + LinkProberWaitStart, + LinkProberActiveStart, + LinkProberStandbyStart, Count }; @@ -927,6 +930,32 @@ class LinkManagerStateMachine: public common::StateMachine, */ void setComponentInitState(uint8_t component) {mComponentInitState.set(component);}; + /** + * @method setDecreaseIntervalFnPtr + * + * @brief set new DecreaseIntervalFnPtr for the state machine. This method is used for testing + * + * @param DecreaseIntervalFnPtr (in) pointer to new DecreaseIntervalFnPtr + * + * @return none + */ + void setDecreaseIntervalFnPtr(boost::function DecreaseIntervalFnPtr) { + mDecreaseIntervalFnPtr = DecreaseIntervalFnPtr; + }; + + /** + * @method setRevertIntervalFnPtr + * + * @brief set new RevertIntervalFnPtr for the state machine. This method is used for testing + * + * @param RevertIntervalFnPtr (in) pointer to new RevertIntervalFnPtr + * + * @return none + */ + void setRevertIntervalFnPtr(boost::function RevertIntervalFnPtr) { + mRevertIntervalFnPtr = RevertIntervalFnPtr; + }; + private: static TransitionFunction mStateTransitionHandler[link_prober::LinkProberState::Label::Count] [mux_state::MuxState::Label::Count] @@ -968,6 +997,8 @@ class LinkManagerStateMachine: public common::StateMachine, boost::function mResumeTxFnPtr; boost::function mSendPeerSwitchCommandFnPtr; boost::function mResetIcmpPacketCountsFnPtr; + boost::function mDecreaseIntervalFnPtr; + boost::function mRevertIntervalFnPtr; uint32_t mWaitActiveUpCount = 0; uint32_t mMuxUnknownBackoffFactor = 1; @@ -976,7 +1007,7 @@ class LinkManagerStateMachine: public common::StateMachine, bool mPendingMuxModeChange = false; common::MuxPortConfig::Mode mTargetMuxMode = common::MuxPortConfig::Mode::Auto; - bool mContinuousLinkProberUnknownEvent = false; + bool mContinuousLinkProberUnknownEvent = false; // When posting unknown_end event, we want to make sure the previous state is unknown. std::bitset mComponentInitState = {0}; Label mLabel = Label::Uninitialized; diff --git a/src/link_prober/LinkProber.cpp b/src/link_prober/LinkProber.cpp index 21080833..bde15ef9 100644 --- a/src/link_prober/LinkProber.cpp +++ b/src/link_prober/LinkProber.cpp @@ -74,6 +74,7 @@ LinkProber::LinkProber( mStrand(mIoService), mDeadlineTimer(mIoService), mSuspendTimer(mIoService), + mSwitchoverTimer(mIoService), mStream(mIoService) { try { @@ -532,7 +533,7 @@ void LinkProber::startTimer() { MUXLOGDEBUG(mMuxPortConfig.getPortName()); // time out these heartbeats - mDeadlineTimer.expires_from_now(boost::posix_time::milliseconds(mMuxPortConfig.getTimeoutIpv4_msec())); + mDeadlineTimer.expires_from_now(boost::posix_time::milliseconds(getProbingInterval())); mDeadlineTimer.async_wait(mStrand.wrap(boost::bind( &LinkProber::handleTimeout, this, @@ -748,4 +749,61 @@ void LinkProber::resetIcmpPacketCounts() ))); } +// +// ---> decreaseProbeIntervalAfterSwitch(uint32_t switchTime_msec); +// +// adjust link prober interval to 10 ms after switchover to better measure the switchover overhead. +// +void LinkProber::decreaseProbeIntervalAfterSwitch(uint32_t switchTime_msec) +{ + MUXLOGDEBUG(mMuxPortConfig.getPortName()); + + mSwitchoverTimer.expires_from_now(boost::posix_time::milliseconds(switchTime_msec)); + mSwitchoverTimer.async_wait(mStrand.wrap(boost::bind( + &LinkProber::handleSwitchoverTimeout, + this, + boost::asio::placeholders::error + ))); + + mDecreaseProbingInterval = true; +} + +// ---> revertProbeIntervalAfterSwitchComplete(); +// +// revert probe interval change after switchover is completed +// +void LinkProber::revertProbeIntervalAfterSwitchComplete() +{ + MUXLOGDEBUG(mMuxPortConfig.getPortName()); + + mSwitchoverTimer.cancel(); + mDecreaseProbingInterval = false; +} + +// +// ---> handleSwitchoverTimeout(boost::system::error_code errorCode) +// +// handle switchover time out +// +void LinkProber::handleSwitchoverTimeout(boost::system::error_code errorCode) +{ + MUXLOGDEBUG(mMuxPortConfig.getPortName()); + + mDecreaseProbingInterval = false; + if (errorCode == boost::system::errc::success) { + MUXLOGWARNING(boost::format("%s: link prober timeout on waiting for expected ICMP event after switchover is triggered ") % mMuxPortConfig.getPortName()); + } +} + +// +// ---> getProbingInterval +// +// get link prober interval +// +inline uint32_t LinkProber::getProbingInterval() +{ + MUXLOGDEBUG(mMuxPortConfig.getPortName()); + return mDecreaseProbingInterval? mMuxPortConfig.getDecreasedTimeoutIpv4_msec():mMuxPortConfig.getTimeoutIpv4_msec(); +} + } /* namespace link_prober */ diff --git a/src/link_prober/LinkProber.h b/src/link_prober/LinkProber.h index a9961575..10e2e7b2 100644 --- a/src/link_prober/LinkProber.h +++ b/src/link_prober/LinkProber.h @@ -169,6 +169,27 @@ class LinkProber */ void resetIcmpPacketCounts(); + /** + * @method decreaseProbeIntervalAfterSwitch + * + * @brief adjust link prober interval to 10 ms after switchover to better measure the switchover overhead. + * + * @param switchTime_msec (in) switchover is expected to complete within this time window + * @param expectingLinkProberEvent (in) depends on which state LinkManager is switching to, link prober expects self or peer events + * + * @return none + */ + void decreaseProbeIntervalAfterSwitch(uint32_t switchTime_msec); + + /** + * @method revertProbeIntervalAfterSwitchComplete + * + * @brief revert probe interval change after switchover is completed + * + * @return none + */ + void revertProbeIntervalAfterSwitchComplete(); + private: /** *@method handleUpdateEthernetFrame @@ -408,6 +429,26 @@ class LinkProber *@return the appended TLV size */ size_t appendTlvDummy(size_t paddingSize, int seqNo); + + /** + * @method getProbingInterval + * + * @brief get link prober interval + * + * @return link prober interval + */ + inline uint32_t getProbingInterval(); + + /** + * @method handleSwitchoverTimeout + * + * @brief handle switchover time out + * + * @param errorCode (in) socket error code + * + * @return none + */ + void handleSwitchoverTimeout(boost::system::error_code errorCode); friend class test::LinkProberTest; @@ -432,6 +473,7 @@ class LinkProber boost::asio::io_service::strand mStrand; boost::asio::deadline_timer mDeadlineTimer; boost::asio::deadline_timer mSuspendTimer; + boost::asio::deadline_timer mSwitchoverTimer; boost::asio::posix::stream_descriptor mStream; std::shared_ptr mSockFilterPtr; @@ -444,6 +486,7 @@ class LinkProber std::array mRxBuffer; bool mSuspendTx = false; + bool mDecreaseProbingInterval = false; uint64_t mIcmpUnknownEventCount = 0; uint64_t mIcmpPacketCount = 0; diff --git a/test/FakeLinkProber.cpp b/test/FakeLinkProber.cpp index 256d3f1e..f6131a3a 100644 --- a/test/FakeLinkProber.cpp +++ b/test/FakeLinkProber.cpp @@ -137,4 +137,19 @@ void FakeLinkProber::resetIcmpPacketCounts() mIcmpPacketCount ))); } + +void FakeLinkProber::decreaseProbeIntervalAfterSwitch(uint32_t switchTime_msec) +{ + MUXLOGINFO(""); + + mDecreaseIntervalCallCount++; +} + +void FakeLinkProber::revertProbeIntervalAfterSwitchComplete() +{ + MUXLOGINFO(""); + + mRevertIntervalCallCount++; +} + } /* namespace test */ diff --git a/test/FakeLinkProber.h b/test/FakeLinkProber.h index fa35ae3a..77913e47 100644 --- a/test/FakeLinkProber.h +++ b/test/FakeLinkProber.h @@ -47,6 +47,9 @@ class FakeLinkProber void resumeTxProbes(); void sendPeerSwitchCommand(); void resetIcmpPacketCounts(); + void decreaseProbeIntervalAfterSwitch(uint32_t switchTime_msec); + void revertProbeIntervalAfterSwitchComplete(); + public: uint32_t mInitializeCallCount = 0; @@ -60,6 +63,9 @@ class FakeLinkProber uint64_t mIcmpUnknownEventCount = 0; uint64_t mIcmpPacketCount = 0; + uint32_t mDecreaseIntervalCallCount = 0; + uint32_t mRevertIntervalCallCount = 0; + private: link_prober::LinkProberStateMachine *mLinkProberStateMachine; }; diff --git a/test/FakeMuxPort.cpp b/test/FakeMuxPort.cpp index 0a71ed23..dc9768cf 100644 --- a/test/FakeMuxPort.cpp +++ b/test/FakeMuxPort.cpp @@ -75,6 +75,12 @@ FakeMuxPort::FakeMuxPort( getLinkManagerStateMachine()->setSendPeerSwitchCommandFnPtr( boost::bind(&FakeLinkProber::sendPeerSwitchCommand, mFakeLinkProber.get()) ); + getActiveStandbyStateMachinePtr()->setDecreaseIntervalFnPtr( + boost::bind(&FakeLinkProber::decreaseProbeIntervalAfterSwitch, mFakeLinkProber.get(), boost::placeholders::_1) + ); + getActiveStandbyStateMachinePtr()->setRevertIntervalFnPtr( + boost::bind(&FakeLinkProber::revertProbeIntervalAfterSwitchComplete, mFakeLinkProber.get()) + ); } void FakeMuxPort::activateStateMachine() diff --git a/test/LinkManagerStateMachineTest.cpp b/test/LinkManagerStateMachineTest.cpp index 4811dae1..fa70482d 100644 --- a/test/LinkManagerStateMachineTest.cpp +++ b/test/LinkManagerStateMachineTest.cpp @@ -1114,13 +1114,13 @@ TEST_F(LinkManagerStateMachineTest, PostPckLossMetricsEvent) { setMuxStandby(); - EXPECT_EQ(mDbInterfacePtr->mPostLinkProberMetricsInvokeCount, 0); + EXPECT_EQ(mDbInterfacePtr->mPostLinkProberMetricsInvokeCount, 1); // post link_prober_standby_start postLinkProberEvent(link_prober::LinkProberState::Unknown, 3); - EXPECT_EQ(mDbInterfacePtr->mPostLinkProberMetricsInvokeCount, 1); + EXPECT_EQ(mDbInterfacePtr->mPostLinkProberMetricsInvokeCount, 3); // post link_prober_unknown_start, link_prober_wait_start postLinkProberEvent(link_prober::LinkProberState::Active, 3); - EXPECT_EQ(mDbInterfacePtr->mPostLinkProberMetricsInvokeCount, 2); + EXPECT_EQ(mDbInterfacePtr->mPostLinkProberMetricsInvokeCount, 4); // post link_prober_active_start } TEST_F(LinkManagerStateMachineTest, PostPckLossUpdateAndResetEvent) diff --git a/test/MuxManagerTest.cpp b/test/MuxManagerTest.cpp index 6294b602..2afe66b6 100644 --- a/test/MuxManagerTest.cpp +++ b/test/MuxManagerTest.cpp @@ -209,6 +209,12 @@ void MuxManagerTest::createPort(std::string port) linkManagerStateMachine->setSuspendTxFnPtr( boost::bind(&FakeLinkProber::suspendTxProbes, mFakeLinkProber.get(), boost::placeholders::_1) ); + linkManagerStateMachine->setDecreaseIntervalFnPtr( + boost::bind(&FakeLinkProber::decreaseProbeIntervalAfterSwitch, mFakeLinkProber.get(), boost::placeholders::_1) + ); + linkManagerStateMachine->setRevertIntervalFnPtr( + boost::bind(&FakeLinkProber::revertProbeIntervalAfterSwitchComplete, mFakeLinkProber.get()) + ); linkManagerStateMachine->mComponentInitState.set(0); From 1de78455d0deb2382f9fe8ebe4dbfc846043a9a1 Mon Sep 17 00:00:00 2001 From: Jing Zhang Date: Tue, 22 Mar 2022 16:22:00 -0700 Subject: [PATCH 2/4] Decrease link probing interval after switchover to better determine the overhead of a toggle (#43) ### Description of PR Summary: Fixes # (issue) This PR is to get more accurate timestamp of when toggle completes on mux. The method is to decrease link probing interval to 10ms after a switchover is triggered, and write the timestamp of link prober state change to state db ```LINK_PROBE_STATS table```. When switchover is over, revert the probing interval change. If switchover does not complete within 400ms, revert the change as well. ### Type of change - [x] New feature ### Approach #### What is the motivation for this PR? To better determine the overhead of a toggle. #### How did you do it? Decrease link probing interval after switchover is triggered. #### How did you verify/test it? Tested cases below on dual testbed: 1. switchover succeeds, icmp_respnder is on. 2. switchover completes but icmp_responder is off. In both cases, link prober events are posted to state db as expected. Link probing interval is decreased and reverted as expected. --- src/common/MuxPortConfig.h | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/common/MuxPortConfig.h b/src/common/MuxPortConfig.h index b998356f..e980f743 100644 --- a/src/common/MuxPortConfig.h +++ b/src/common/MuxPortConfig.h @@ -260,6 +260,15 @@ class MuxPortConfig */ inline uint32_t getDecreasedTimeoutIpv4_msec() const {return mMuxConfig.getDecreasedTimeoutIpv4_msec();}; + /** + *@method getDecreasedTimeoutIpv4_msec + * + *@brief getter for decreased IPv4 LinkProber timeout in msec + * + *@return timeout in msec + */ + inline uint32_t getDecreasedTimeoutIpv4_msec() const {return mMuxConfig.getDecreasedTimeoutIpv4_msec();}; + private: MuxConfig &mMuxConfig; std::string mPortName; From 4989378698712d1504e27986d87c0a11e297d534 Mon Sep 17 00:00:00 2001 From: zjswhhh Date: Wed, 23 Mar 2022 01:43:14 +0000 Subject: [PATCH 3/4] remove duplicates --- src/common/MuxPortConfig.h | 9 --------- 1 file changed, 9 deletions(-) diff --git a/src/common/MuxPortConfig.h b/src/common/MuxPortConfig.h index e980f743..b998356f 100644 --- a/src/common/MuxPortConfig.h +++ b/src/common/MuxPortConfig.h @@ -260,15 +260,6 @@ class MuxPortConfig */ inline uint32_t getDecreasedTimeoutIpv4_msec() const {return mMuxConfig.getDecreasedTimeoutIpv4_msec();}; - /** - *@method getDecreasedTimeoutIpv4_msec - * - *@brief getter for decreased IPv4 LinkProber timeout in msec - * - *@return timeout in msec - */ - inline uint32_t getDecreasedTimeoutIpv4_msec() const {return mMuxConfig.getDecreasedTimeoutIpv4_msec();}; - private: MuxConfig &mMuxConfig; std::string mPortName; From 1bdf8139d9ca5c1cb7dabd1b6a968322fa4b61b2 Mon Sep 17 00:00:00 2001 From: zjswhhh Date: Wed, 23 Mar 2022 01:56:06 +0000 Subject: [PATCH 4/4] remove ActiveStandbyStateMachine reference --- src/link_manager/LinkManagerStateMachine.cpp | 2 +- test/FakeMuxPort.cpp | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/link_manager/LinkManagerStateMachine.cpp b/src/link_manager/LinkManagerStateMachine.cpp index d2987065..d2bc0f2a 100644 --- a/src/link_manager/LinkManagerStateMachine.cpp +++ b/src/link_manager/LinkManagerStateMachine.cpp @@ -304,7 +304,7 @@ void LinkManagerStateMachine::enterLinkProberState(CompositeState &nextState, li // link prober entering wait indicating switchover is initiated, but a switchover can be skipped if mode == manual. if(label == link_prober::LinkProberState::Label::Wait) { - mMuxPortPtr->postLinkProberMetricsEvent(link_manager::ActiveStandbyStateMachine::LinkProberMetrics::LinkProberWaitStart); + mMuxPortPtr->postLinkProberMetricsEvent(link_manager::LinkManagerStateMachine::LinkProberMetrics::LinkProberWaitStart); } } diff --git a/test/FakeMuxPort.cpp b/test/FakeMuxPort.cpp index dc9768cf..cc19a445 100644 --- a/test/FakeMuxPort.cpp +++ b/test/FakeMuxPort.cpp @@ -75,10 +75,10 @@ FakeMuxPort::FakeMuxPort( getLinkManagerStateMachine()->setSendPeerSwitchCommandFnPtr( boost::bind(&FakeLinkProber::sendPeerSwitchCommand, mFakeLinkProber.get()) ); - getActiveStandbyStateMachinePtr()->setDecreaseIntervalFnPtr( + getLinkManagerStateMachine()->setDecreaseIntervalFnPtr( boost::bind(&FakeLinkProber::decreaseProbeIntervalAfterSwitch, mFakeLinkProber.get(), boost::placeholders::_1) ); - getActiveStandbyStateMachinePtr()->setRevertIntervalFnPtr( + getLinkManagerStateMachine()->setRevertIntervalFnPtr( boost::bind(&FakeLinkProber::revertProbeIntervalAfterSwitchComplete, mFakeLinkProber.get()) ); }