23 #include <boost/pointer_cast.hpp> 44 constexpr
long WARN_CLOCK_SKEW = 30;
47 constexpr
long TERM_CLOCK_SKEW = 60;
50 constexpr
long MIN_TIME_SINCE_CLOCK_SKEW_WARN = 60;
57 CommunicationState::CommunicationState(
const IOServicePtr& io_service,
59 : io_service_(io_service), config_(config), timer_(), interval_(0),
60 poke_time_(
boost::posix_time::microsec_clock::universal_time()),
61 heartbeat_impl_(0), partner_state_(-1), partner_scopes_(),
62 clock_skew_(0, 0, 0, 0), last_clock_skew_warn_(),
63 my_time_at_skew_(), partner_time_at_skew_(),
64 analyzed_messages_count_(0), unsent_update_count_(0),
65 partner_unsent_update_count_{0, 0},
mutex_(
new mutex()) {
74 if (MultiThreadingMgr::instance().getMode()) {
75 std::lock_guard<std::mutex> lk(*
mutex_);
76 poke_time_ += boost::posix_time::seconds(secs);
78 poke_time_ += boost::posix_time::seconds(secs);
84 if (MultiThreadingMgr::instance().getMode()) {
85 std::lock_guard<std::mutex> lk(*
mutex_);
94 if (MultiThreadingMgr::instance().getMode()) {
95 std::lock_guard<std::mutex> lk(*
mutex_);
96 setPartnerStateInternal(state);
98 setPartnerStateInternal(state);
103 CommunicationState::setPartnerStateInternal(
const std::string& state) {
112 std::set<std::string>
114 if (MultiThreadingMgr::instance().getMode()) {
115 std::lock_guard<std::mutex> lk(*
mutex_);
124 if (MultiThreadingMgr::instance().getMode()) {
125 std::lock_guard<std::mutex> lk(*
mutex_);
126 setPartnerScopesInternal(new_scopes);
128 setPartnerScopesInternal(new_scopes);
133 CommunicationState::setPartnerScopesInternal(
ConstElementPtr new_scopes) {
134 if (!new_scopes || (new_scopes->getType() != Element::list)) {
136 " the received value is not a valid JSON list");
139 std::set<std::string> partner_scopes;
140 for (
auto i = 0; i < new_scopes->size(); ++i) {
141 auto scope = new_scopes->get(i);
142 if (scope->getType() != Element::string) {
144 " the received scope value is not a valid JSON string");
146 auto scope_str = scope->stringValue();
147 if (!scope_str.empty()) {
148 partner_scopes.insert(scope_str);
156 const std::function<
void()>& heartbeat_impl) {
157 if (MultiThreadingMgr::instance().getMode()) {
158 std::lock_guard<std::mutex> lk(*
mutex_);
159 startHeartbeatInternal(interval, heartbeat_impl);
161 startHeartbeatInternal(interval, heartbeat_impl);
166 CommunicationState::startHeartbeatInternal(
const long interval,
167 const std::function<
void()>& heartbeat_impl) {
168 bool settings_modified =
false;
172 if (heartbeat_impl) {
173 settings_modified =
true;
180 " to the heartbeat implementation is not specified");
186 settings_modified |= (
interval_ != interval);
194 " for the heartbeat timer is not specified");
201 if (settings_modified) {
208 if (MultiThreadingMgr::instance().getMode()) {
209 std::lock_guard<std::mutex> lk(*
mutex_);
210 stopHeartbeatInternal();
212 stopHeartbeatInternal();
217 CommunicationState::stopHeartbeatInternal() {
228 if (MultiThreadingMgr::instance().getMode()) {
229 std::lock_guard<std::mutex> lk(*
mutex_);
230 return (static_cast<bool>(
timer_));
232 return (static_cast<bool>(
timer_));
236 boost::posix_time::time_duration
238 if (MultiThreadingMgr::instance().getMode()) {
239 std::lock_guard<std::mutex> lk(*
mutex_);
240 return (updatePokeTimeInternal());
242 return (updatePokeTimeInternal());
246 boost::posix_time::time_duration
247 CommunicationState::updatePokeTimeInternal() {
249 boost::posix_time::ptime prev_poke_time =
poke_time_;
251 poke_time_ = boost::posix_time::microsec_clock::universal_time();
257 if (MultiThreadingMgr::instance().getMode()) {
258 std::lock_guard<std::mutex> lk(*
mutex_);
266 CommunicationState::pokeInternal() {
268 boost::posix_time::time_duration duration_since_poke = updatePokeTimeInternal();
281 if (duration_since_poke.total_seconds() > 0) {
285 startHeartbeatInternal();
292 if (MultiThreadingMgr::instance().getMode()) {
293 std::lock_guard<std::mutex> lk(*
mutex_);
294 return (getDurationInMillisecsInternal());
296 return (getDurationInMillisecsInternal());
301 CommunicationState::getDurationInMillisecsInternal()
const {
302 ptime now = boost::posix_time::microsec_clock::universal_time();
304 return (duration.total_milliseconds());
314 const uint16_t option_type) {
315 std::vector<uint8_t> client_id;
316 OptionPtr opt_client_id = message->getOption(option_type);
318 client_id = opt_client_id->getData();
330 if (MultiThreadingMgr::instance().getMode()) {
331 std::lock_guard<std::mutex> lk(*
mutex_);
340 const uint32_t lifetime) {
341 if (MultiThreadingMgr::instance().getMode()) {
342 std::lock_guard<std::mutex> lk(*
mutex_);
351 if (MultiThreadingMgr::instance().getMode()) {
352 std::lock_guard<std::mutex> lk(*
mutex_);
361 if (MultiThreadingMgr::instance().getMode()) {
362 std::lock_guard<std::mutex> lk(*
mutex_);
371 if (MultiThreadingMgr::instance().getMode()) {
372 std::lock_guard<std::mutex> lk(*
mutex_);
373 return (clockSkewShouldWarnInternal());
375 return (clockSkewShouldWarnInternal());
380 CommunicationState::clockSkewShouldWarnInternal() {
382 if (isClockSkewGreater(WARN_CLOCK_SKEW)) {
389 ptime now = boost::posix_time::microsec_clock::universal_time();
395 if (last_clock_skew_warn_.is_not_a_date_time() ||
396 (since_warn_duration.total_seconds() > MIN_TIME_SINCE_CLOCK_SKEW_WARN)) {
397 last_clock_skew_warn_ = now;
399 .arg(logFormatClockSkewInternal());
410 if (MultiThreadingMgr::instance().getMode()) {
411 std::lock_guard<std::mutex> lk(*
mutex_);
413 return (clockSkewShouldTerminateInternal());
415 return (clockSkewShouldTerminateInternal());
420 CommunicationState::clockSkewShouldTerminateInternal() {
421 if (isClockSkewGreater(TERM_CLOCK_SKEW)) {
423 .arg(logFormatClockSkewInternal());
431 if (MultiThreadingMgr::instance().getMode()) {
432 std::lock_guard<std::mutex> lk(*
mutex_);
433 return (rejectedLeaseUpdatesShouldTerminateInternal());
435 return (rejectedLeaseUpdatesShouldTerminateInternal());
440 CommunicationState::rejectedLeaseUpdatesShouldTerminateInternal() {
441 if (
config_->getMaxRejectedLeaseUpdates() &&
450 CommunicationState::isClockSkewGreater(
const long seconds)
const {
457 if (MultiThreadingMgr::instance().getMode()) {
458 std::lock_guard<std::mutex> lk(*
mutex_);
459 setPartnerTimeInternal(time_text);
461 setPartnerTimeInternal(time_text);
466 CommunicationState::setPartnerTimeInternal(
const std::string& time_text) {
474 if (MultiThreadingMgr::instance().getMode()) {
475 std::lock_guard<std::mutex> lk(*
mutex_);
476 return (logFormatClockSkewInternal());
478 return (logFormatClockSkewInternal());
483 CommunicationState::logFormatClockSkewInternal()
const {
484 std::ostringstream os;
490 return (
"skew not initialized");
497 <<
", partner's clock is ";
501 os <<
clock_skew_.invert_sign().total_seconds() <<
"s behind";
512 auto report = Element::createMap();
515 report->set(
"in-touch", Element::create(in_touch));
518 report->set(
"age", Element::create(age));
524 report->set(
"last-state", Element::create(std::string()));
527 auto list = Element::createList();
529 list->add(Element::create(scope));
531 report->set(
"last-scopes", list);
532 report->set(
"communication-interrupted",
537 long long unacked_clients_left = 0;
539 unacked_clients_left =
static_cast<long long>(
config_->getMaxUnackedClients() -
542 report->set(
"unacked-clients-left", Element::create(unacked_clients_left));
550 if (MultiThreadingMgr::instance().getMode()) {
551 std::lock_guard<std::mutex> lk(*
mutex_);
560 if (MultiThreadingMgr::instance().getMode()) {
561 std::lock_guard<std::mutex> lk(*
mutex_);
562 increaseUnsentUpdateCountInternal();
564 increaseUnsentUpdateCountInternal();
569 CommunicationState::increaseUnsentUpdateCountInternal() {
581 if (MultiThreadingMgr::instance().getMode()) {
582 std::lock_guard<std::mutex> lk(*
mutex_);
583 return (hasPartnerNewUnsentUpdatesInternal());
585 return (hasPartnerNewUnsentUpdatesInternal());
590 CommunicationState::hasPartnerNewUnsentUpdatesInternal()
const {
597 if (MultiThreadingMgr::instance().getMode()) {
598 std::lock_guard<std::mutex> lk(*
mutex_);
599 setPartnerUnsentUpdateCountInternal(unsent_update_count);
601 setPartnerUnsentUpdateCountInternal(unsent_update_count);
606 CommunicationState::setPartnerUnsentUpdateCountInternal(uint64_t unsent_update_count) {
614 rejected_clients_() {
619 if (MultiThreadingMgr::instance().getMode()) {
620 std::lock_guard<std::mutex> lk(*
mutex_);
630 Pkt4Ptr msg = boost::dynamic_pointer_cast<
Pkt4>(message);
639 uint16_t secs = msg->getSecs();
644 if ((secs > 255) && ((secs & 0xFF) == 0)) {
645 secs = ((secs >> 8) | (secs << 8));
652 auto unacked = (secs * 1000 >
config_->getMaxAckDelay());
657 bool log_unacked =
false;
661 auto existing_request = idx.find(boost::make_tuple(msg->getHWAddr()->hwaddr_, client_id));
662 if (existing_request != idx.end()) {
667 if (!existing_request->unacked_ && unacked) {
669 idx.replace(existing_request, connecting_client);
677 idx.insert(connecting_client);
678 log_unacked = unacked;
685 .arg(message->getLabel());
691 unsigned unacked_left = 0;
693 if (
config_->getMaxUnackedClients() >= unacked_total) {
694 unacked_left =
config_->getMaxUnackedClients() - unacked_total + 1;
697 .arg(message->getLabel())
705 if (MultiThreadingMgr::instance().getMode()) {
706 std::lock_guard<std::mutex> lk(*
mutex_);
715 return ((
config_->getMaxUnackedClients() == 0) ||
717 config_->getMaxUnackedClients()));
722 if (MultiThreadingMgr::instance().getMode()) {
723 std::lock_guard<std::mutex> lk(*
mutex_);
732 if (MultiThreadingMgr::instance().getMode()) {
733 std::lock_guard<std::mutex> lk(*
mutex_);
752 Pkt4Ptr msg = boost::dynamic_pointer_cast<
Pkt4>(message);
754 isc_throw(
BadValue,
"DHCP message for which the lease update was rejected is not a DHCPv4 message");
758 auto existing_client =
rejected_clients_.find(boost::make_tuple(msg->getHWAddr()->hwaddr_, client_id));
773 Pkt4Ptr msg = boost::dynamic_pointer_cast<
Pkt4>(message);
775 isc_throw(
BadValue,
"DHCP message for which the lease update was successful is not a DHCPv4 message");
778 auto existing_client =
rejected_clients_.find(boost::make_tuple(msg->getHWAddr()->hwaddr_, client_id));
799 if (MultiThreadingMgr::instance().getMode()) {
800 std::lock_guard<std::mutex> lk(*
mutex_);
810 Pkt6Ptr msg = boost::dynamic_pointer_cast<
Pkt6>(message);
822 auto unacked = (elapsed_time && elapsed_time->getValue() * 10 >
config_->getMaxAckDelay());
830 bool log_unacked =
false;
834 auto existing_request = idx.find(duid);
835 if (existing_request != idx.end()) {
840 if (!existing_request->unacked_ && unacked) {
842 idx.replace(existing_request, connecting_client);
850 idx.insert(connecting_client);
851 log_unacked = unacked;
858 .arg(message->getLabel());
864 unsigned unacked_left = 0;
866 if (
config_->getMaxUnackedClients() >= unacked_total) {
867 unacked_left =
config_->getMaxUnackedClients() - unacked_total + 1;
870 .arg(message->getLabel())
878 if (MultiThreadingMgr::instance().getMode()) {
879 std::lock_guard<std::mutex> lk(*
mutex_);
888 return ((
config_->getMaxUnackedClients() == 0) ||
890 config_->getMaxUnackedClients()));
895 if (MultiThreadingMgr::instance().getMode()) {
896 std::lock_guard<std::mutex> lk(*
mutex_);
905 if (MultiThreadingMgr::instance().getMode()) {
906 std::lock_guard<std::mutex> lk(*
mutex_);
925 Pkt6Ptr msg = boost::dynamic_pointer_cast<
Pkt6>(message);
927 isc_throw(
BadValue,
"DHCP message for which the lease update was rejected is not a DHCPv6 message");
949 Pkt6Ptr msg = boost::dynamic_pointer_cast<
Pkt6>(message);
951 isc_throw(
BadValue,
"DHCP message for which the lease update was successful is not a DHCPv6 message");
virtual void clearRejectedLeaseUpdatesInternal()
Clears rejected client leases.
std::set< std::string > getPartnerScopes() const
Returns scopes served by the partner server.
data::ElementPtr getReport() const
Returns the report about current communication state.
int stringToState(const std::string &state_name)
Returns state for a given name.
#define LOG_WARN(LOGGER, MESSAGE)
Macro to conveniently test warn output and log it.
CommunicationState6(const asiolink::IOServicePtr &io_service, const HAConfigPtr &config)
Constructor.
virtual bool failureDetected() const
Checks if the partner failure has been detected based on the DHCP traffic analysis.
virtual bool failureDetected() const
Checks if the partner failure has been detected based on the DHCP traffic analysis.
virtual size_t getConnectingClientsCount() const =0
Returns the current number of clients which attempted to get a lease from the partner server...
virtual void clearConnectingClients()=0
Removes information about the clients the partner server should respond to while communication with t...
virtual void clearRejectedLeaseUpdatesInternal()=0
Clears rejected client leases.
int64_t getDurationInMillisecs() const
Returns duration between the poke time and current time.
void setPartnerTime(const std::string &time_text)
Provide partner's notion of time so the new clock skew can be calculated.
Holds communication state between the two HA peers.
#define LOG_INFO(LOGGER, MESSAGE)
Macro to conveniently test info output and log it.
uint64_t getUnsentUpdateCount() const
Returns a total number of unsent lease updates.
virtual bool failureDetectedInternal() const
Checks if the partner failure has been detected based on the DHCP traffic analysis.
const isc::log::MessageID HA_HIGH_CLOCK_SKEW_CAUSED_TERMINATION
void clearRejectedLeaseUpdates()
Clears rejected client leases (MT safe).
RejectedClients6 rejected_clients_
Holds information about the clients for whom lease updates have been rejected by the partner...
ConnectingClients4 connecting_clients_
Holds information about the clients attempting to contact the partner server while the servers are in...
static size_t getRejectedLeaseUpdatesCountFromContainer(RejectedClientsType &rejected_clients)
Extracts the number of lease updates rejected by the partner from the specified container.
size_t getRejectedLeaseUpdatesCount()
Returns the number of lease updates rejected by the partner (MT safe).
boost::shared_ptr< Option > OptionPtr
Represents a DHCPv6 packet.
#define LOG_ERROR(LOGGER, MESSAGE)
Macro to conveniently test error output and log it.
boost::shared_ptr< IOService > IOServicePtr
Defines a smart pointer to an IOService instance.
boost::shared_ptr< Element > ElementPtr
bool isCommunicationInterrupted() const
Checks if communication with the partner is interrupted.
std::function< void()> heartbeat_impl_
Pointer to the function providing heartbeat implementation.
asiolink::IOServicePtr io_service_
Pointer to the common IO service instance.
virtual size_t getRejectedLeaseUpdatesCountInternal()
Returns the number of lease updates rejected by the partner.
bool reportRejectedLeaseUpdate(const dhcp::PktPtr &message, const uint32_t lifetime=86400)
Marks that the lease update failed due to a conflict for the specified DHCP message (MT safe)...
uint64_t unsent_update_count_
Total number of unsent lease updates.
Forward declaration to OptionInt.
int getPartnerState() const
Returns last known state of the partner.
bool hasPartnerNewUnsentUpdates() const
Checks if the partner allocated new leases for which it hasn't sent any lease updates.
virtual void clearRejectedLeaseUpdatesInternal()
Clears rejected client leases.
static std::vector< uint8_t > getClientId(const dhcp::PktPtr &message, const uint16_t option_type)
Convenience function attempting to retrieve client identifier from the DHCP message.
Structure holding information about the client who has a rejected lease update.
Structure holding information about a client which sent a packet being analyzed.
virtual void clearConnectingClients()
Removes information about the clients the partner server should respond to while communication with t...
const isc::log::MessageID HA_HIGH_CLOCK_SKEW
virtual bool reportRejectedLeaseUpdateInternal(const dhcp::PktPtr &message, const uint32_t lifetime=86400)
Marks that the lease update failed due to a conflict for the specified DHCP message.
virtual bool reportSuccessfulLeaseUpdateInternal(const dhcp::PktPtr &message)
Marks the lease update successful.
virtual void analyzeMessageInternal(const boost::shared_ptr< dhcp::Pkt > &message)
Checks if the DHCPv6 message appears to be unanswered.
boost::posix_time::time_duration updatePokeTime()
Update the poke time and compute the duration.
boost::posix_time::ptime partner_time_at_skew_
Partner reported time when skew was calculated.
Structure holding information about the client who has a rejected lease update.
long interval_
Interval specified for the heartbeat.
const isc::log::MessageID HA_COMMUNICATION_INTERRUPTED_CLIENT6_UNACKED
virtual size_t getConnectingClientsCount() const
Returns the current number of clients which attempted to get a lease from the partner server...
std::pair< uint64_t, uint64_t > partner_unsent_update_count_
Previous and current total number of unsent lease updates from the partner.
boost::posix_time::ptime poke_time_
Last poke time.
const isc::log::MessageID HA_COMMUNICATION_INTERRUPTED_CLIENT6
#define isc_throw(type, stream)
A shortcut macro to insert known values into exception arguments.
A generic exception that is thrown if a parameter given to a method is considered invalid in that con...
boost::shared_ptr< Pkt6 > Pkt6Ptr
A pointer to Pkt6 packet.
boost::shared_ptr< OptionUint16 > OptionUint16Ptr
The IntervalTimer class is a wrapper for the ASIO boost::asio::deadline_timer class.
RejectedClients4 rejected_clients_
Holds information about the clients for whom lease updates have been rejected by the partner...
void modifyPokeTime(const long secs)
Modifies poke time by adding seconds to it.
boost::posix_time::ptime getPtime() const
Returns time encapsulated by this class.
int partner_state_
Last known state of the partner server.
std::string ptimeToText(boost::posix_time::ptime t, size_t fsecs_precision=MAX_FSECS_PRECISION)
Converts ptime structure to text.
const boost::scoped_ptr< std::mutex > mutex_
The mutex used to protect internal state.
virtual bool reportRejectedLeaseUpdateInternal(const dhcp::PktPtr &message, const uint32_t lifetime)
Marks that the lease update failed due to a conflict for the specified DHCP message.
bool clockSkewShouldTerminate()
Indicates whether the HA service should enter "terminated" state as a result of the clock skew exceed...
virtual size_t getUnackedClientsCount() const
Returns the current number of clients which haven't gotten a lease from the partner server...
virtual size_t getConnectingClientsCount() const
Returns the current number of clients which attempted to get a lease from the partner server...
std::string stateToString(int state)
Returns state name.
boost::shared_ptr< Pkt4 > Pkt4Ptr
A pointer to Pkt4 object.
boost::shared_ptr< const Element > ConstElementPtr
bool isHeartbeatRunning() const
Checks if recurring heartbeat is running.
virtual void analyzeMessage(const boost::shared_ptr< dhcp::Pkt > &message)
Checks if the DHCPv6 message appears to be unanswered.
static HttpDateTime fromRfc1123(const std::string &time_string)
Creates an instance from a string containing time value formatted as specified in RFC 1123...
virtual bool failureDetectedInternal() const
Checks if the partner failure has been detected based on the DHCP traffic analysis.
virtual size_t getUnackedClientsCount() const
Returns the current number of clients which haven't gotten a lease from the partner server...
const isc::log::MessageID HA_COMMUNICATION_INTERRUPTED_CLIENT4_UNACKED
boost::shared_ptr< isc::dhcp::Pkt > PktPtr
A pointer to either Pkt4 or Pkt6 packet.
void stopHeartbeat()
Stops recurring heartbeat.
This class parses and generates time values used in HTTP.
const isc::log::MessageID HA_LEASE_UPDATE_REJECTS_CAUSED_TERMINATION
Defines the logger used by the top-level component of kea-lfc.
void poke()
Pokes the communication state.
Represents DHCPv4 packet.
bool reportSuccessfulLeaseUpdate(const dhcp::PktPtr &message)
Marks the lease update successful (MT safe).
boost::posix_time::time_duration clock_skew_
Clock skew between the active servers.
void increaseUnsentUpdateCount()
Increases a total number of unsent lease updates by 1.
CommunicationState4(const asiolink::IOServicePtr &io_service, const HAConfigPtr &config)
Constructor.
const isc::log::MessageID HA_COMMUNICATION_INTERRUPTED_CLIENT4
virtual void analyzeMessage(const boost::shared_ptr< dhcp::Pkt > &message)
Checks if the DHCPv4 message appears to be unanswered.
ConnectingClients6 connecting_clients_
Holds information about the clients attempting to contact the partner server while the servers are in...
virtual size_t getRejectedLeaseUpdatesCountInternal()
Returns the number of lease updates rejected by the partner.
std::vector< uint8_t > hwaddr_
boost::posix_time::ptime my_time_at_skew_
My time when skew was calculated.
void setPartnerState(const std::string &state)
Sets partner state.
virtual bool reportRejectedLeaseUpdateInternal(const dhcp::PktPtr &message, const uint32_t lifetime)=0
Marks that the lease update failed due to a conflict for the specified DHCP message.
void startHeartbeat(const long interval, const std::function< void()> &heartbeat_impl)
Starts recurring heartbeat (public interface).
isc::log::Logger ha_logger("ha-hooks")
size_t getAnalyzedMessagesCount() const
Returns the number of analyzed messages while being in the communications interrupted state...
std::string logFormatClockSkew() const
Returns current clock skew value in the logger friendly format.
virtual size_t getRejectedLeaseUpdatesCountInternal()=0
Returns the number of lease updates rejected by the partner.
std::set< std::string > partner_scopes_
Last known set of scopes served by the partner server.
virtual ~CommunicationState()
Destructor.
Structure holding information about the client which has sent the packet being analyzed.
bool rejectedLeaseUpdatesShouldTerminate()
Indicates whether the HA service should enter "terminated" state due to excessive number of rejected ...
bool clockSkewShouldWarn()
Issues a warning about high clock skew between the active servers if one is warranted.
boost::posix_time::ptime last_clock_skew_warn_
Holds a time when last warning about too high clock skew was issued.
asiolink::IntervalTimerPtr timer_
Interval timer triggering heartbeat commands.
void setPartnerScopes(data::ConstElementPtr new_scopes)
Sets partner scopes.
virtual bool reportSuccessfulLeaseUpdateInternal(const dhcp::PktPtr &message)
Marks the lease update successful.
virtual size_t getUnackedClientsCount() const =0
Returns the current number of clients which haven't got the lease from the partner server...
HAConfigPtr config_
High availability configuration.
virtual void clearConnectingClients()
Removes information about the clients the partner server should respond to while communication with t...
std::vector< uint8_t > hwaddr_
virtual void analyzeMessageInternal(const boost::shared_ptr< dhcp::Pkt > &message)
Checks if the DHCPv4 message appears to be unanswered.
virtual bool reportSuccessfulLeaseUpdateInternal(const dhcp::PktPtr &message)=0
Marks the lease update successful.
boost::shared_ptr< HAConfig > HAConfigPtr
Pointer to the High Availability configuration structure.
void setPartnerUnsentUpdateCount(uint64_t unsent_update_count)
Saves new total number of unsent lease updates from the partner.
size_t analyzed_messages_count_
Total number of analyzed messages to be responded by partner.