Kea: ha_service.h Source File

| Kea 3.2.0-git

ha_service.h
Go to the documentation of this file.
1// Copyright (C) 2018-2026 Internet Systems Consortium, Inc. ("ISC")
2//
3// This Source Code Form is subject to the terms of the Mozilla Public
4// License, v. 2.0. If a copy of the MPL was not distributed with this
5// file, You can obtain one at http://mozilla.org/MPL/2.0/.
6
7#ifndef HA_SERVICE_H
8#define HA_SERVICE_H
9
10#include <communication_state.h>
11#include <ha_config.h>
12#include <ha_server_type.h>
13#include <lease_sync_filter.h>
14#include <lease_update_backlog.h>
15#include <query_filter.h>
16#include <asiolink/asio_wrapper.h>
17#include <asiolink/io_service.h>
18#include <asiolink/tls_socket.h>
19#include <cc/data.h>
20#include <config/cmd_http_listener.h>
21#include <dhcp/pkt4.h>
22#include <http/response.h>
23#include <dhcpsrv/lease.h>
24#include <dhcpsrv/network_state.h>
25#include <hooks/parking_lots.h>
26#include <http/client.h>
27#include <util/state_model.h>
28
29#include <boost/noncopyable.hpp>
30#include <boost/shared_ptr.hpp>
31#include <functional>
32#include <map>
33#include <mutex>
34#include <vector>
35
36namespace isc {
37namespace ha {
38
39class HAService;
40
42 typedef HARelationshipMapper<HAService> HAServiceMapper;
43
45 typedef boost::shared_ptr<HAServiceMapper> HAServiceMapperPtr;
46
52 class HAService : public boost::noncopyable, public util::StateModel {
53public:
54
56 static const int HA_HEARTBEAT_COMPLETE_EVT = SM_DERIVED_EVENT_MIN + 1;
57
59 static const int HA_LEASE_UPDATES_COMPLETE_EVT = SM_DERIVED_EVENT_MIN + 2;
60
62 static const int HA_SYNCING_FAILED_EVT = SM_DERIVED_EVENT_MIN + 3;
63
65 static const int HA_SYNCING_SUCCEEDED_EVT = SM_DERIVED_EVENT_MIN + 4;
66
68 static const int HA_MAINTENANCE_NOTIFY_EVT = SM_DERIVED_EVENT_MIN + 5;
69
71 static const int HA_MAINTENANCE_START_EVT = SM_DERIVED_EVENT_MIN + 6;
72
74 static const int HA_MAINTENANCE_CANCEL_EVT = SM_DERIVED_EVENT_MIN + 7;
75
78 static const int HA_SYNCED_PARTNER_UNAVAILABLE_EVT = SM_DERIVED_EVENT_MIN + 8;
79
81 static const int HA_CONTROL_RESULT_MAINTENANCE_NOT_ALLOWED = 1001;
82
85 static const int HA_WAITING_TO_TERMINATED_ST_DELAY_MINUTES = 10;
86
87protected:
88
95 typedef std::function<void(const bool, const std::string&, const int)> PostRequestCallback;
96
104 typedef std::function<void(const bool, const std::string&, const bool)> PostSyncCallback;
105
106public:
107
120 HAService(const unsigned int id,
121 const asiolink::IOServicePtr& io_service,
122 const dhcp::NetworkStatePtr& network_state,
123 const HAConfigPtr& config,
124 const HAServerType& server_type = HAServerType::DHCPv4);
125
130 virtual ~HAService();
131
133 HAServerType getServerType() const {
134 return (server_type_);
135 }
136
137private:
138
143 unsigned int getLocalOrigin() const {
144 return (dhcp::NetworkState::HA_LOCAL_COMMAND + id_);
145 }
146
151 unsigned int getRemoteOrigin() const {
152 return (dhcp::NetworkState::HA_REMOTE_COMMAND + id_);
153 }
154
162 std::string getCSCallbacksSetName() const;
163
165 virtual void defineEvents();
166
168 virtual void verifyEvents();
169
171 virtual void defineStates();
172
185 void backupStateHandler();
186
214 void communicationRecoveryHandler();
215
245 void normalStateHandler();
246
256 void inMaintenanceStateHandler();
257
282 void partnerDownStateHandler();
283
304 void partnerInMaintenanceStateHandler();
305
313 void passiveBackupStateHandler();
314
330 void readyStateHandler();
331
348 void syncingStateHandler();
349
367 void terminatedStateHandler();
368
392 void waitingStateHandler();
393
396 int getPartnerState() const {
397 return (communication_state_->getPartnerState());
398 }
399
400protected:
401
405 void verboseTransition(const unsigned state);
406
413 int getNormalState() const;
414
415public:
416
424 bool unpause();
425
426protected:
427
432 void conditionalLogPausedState() const;
433
434public:
435
440 void serveDefaultScopes();
441
446 void serveFailoverScopes();
447
461 bool inScope(dhcp::Pkt4Ptr& query4);
462
476 bool inScope(dhcp::Pkt6Ptr& query6);
477
478private:
479
493 template<typename QueryPtrType>
494 bool inScopeInternal(QueryPtrType& query);
495
496public:
497
507 bool shouldReclaim(const dhcp::Lease4Ptr& lease4) const;
508
518 bool shouldReclaim(const dhcp::Lease6Ptr& lease6) const;
519
520private:
521
532 template<typename LeaseTypePtr>
533 bool shouldReclaimInternal(const LeaseTypePtr& lease) const;
534
535public:
536
541 void adjustNetworkState();
542
543protected:
544
558 bool shouldPartnerDown() const;
559
578 bool shouldTerminate() const;
579
584 bool isMaintenanceCanceled() const;
585
601 bool isPartnerStateInvalid() const;
602
603public:
604
638 size_t asyncSendLeaseUpdates(const dhcp::Pkt4Ptr& query,
639 const dhcp::Lease4CollectionPtr& leases,
640 const dhcp::Lease4CollectionPtr& deleted_leases,
641 const hooks::ParkingLotHandlePtr& parking_lot);
642
659 size_t asyncSendSingleLeaseUpdate(const dhcp::Pkt4Ptr& query,
660 const dhcp::Lease4Ptr& lease,
661 const hooks::ParkingLotHandlePtr& parking_lot);
662
681 size_t asyncSendLeaseUpdates(const dhcp::Pkt6Ptr& query,
682 const dhcp::Lease6CollectionPtr& leases,
683 const dhcp::Lease6CollectionPtr& deleted_leases,
684 const hooks::ParkingLotHandlePtr& parking_lot);
685
686protected:
687
700 template<typename QueryPtrType>
701 void asyncSendLeaseUpdate(const QueryPtrType& query,
702 const HAConfig::PeerConfigPtr& config,
703 const data::ConstElementPtr& command,
704 const hooks::ParkingLotHandlePtr& parking_lot);
705
715 void logFailedLeaseUpdates(const dhcp::PktPtr& query,
716 const data::ConstElementPtr& args) const;
717
728 bool shouldSendLeaseUpdates(const HAConfig::PeerConfigPtr& peer_config) const;
729
741 bool shouldQueueLeaseUpdates(const HAConfig::PeerConfigPtr& peer_config) const;
742
743public:
744
769 data::ConstElementPtr processHeartbeat();
770
775 data::ConstElementPtr processStatusGet() const;
776
789 data::ConstElementPtr processHAReset();
790
791protected:
792
794 void asyncSendHeartbeat();
795
801 void scheduleHeartbeat();
802
804 void startHeartbeat();
805
817 void asyncDisableDHCPService(http::HttpClient& http_client,
818 const HAConfig::PeerConfigPtr& remote_config,
819 const unsigned int max_period,
820 PostRequestCallback post_request_action);
821
831 void asyncEnableDHCPService(http::HttpClient& http_client,
832 const HAConfig::PeerConfigPtr& remote_config,
833 PostRequestCallback post_request_action);
834
836 void localDisableDHCPService();
837
839 void localEnableDHCPService();
840
856 void asyncSyncLeases();
857
908 void asyncSyncLeases(http::HttpClient& http_client,
909 const HAConfig::PeerConfigPtr& remote_config,
910 const unsigned int max_period,
911 const dhcp::LeasePtr& last_lease,
912 PostSyncCallback post_sync_action,
913 const bool dhcp_disabled = false);
914
941 void asyncSyncLeasesInternal(http::HttpClient& http_client,
942 const HAConfig::PeerConfigPtr& remote_config,
943 const unsigned int max_period,
944 const dhcp::LeasePtr& last_lease,
945 PostSyncCallback post_sync_action,
946 const bool dhcp_disabled);
947
948public:
949
969 data::ConstElementPtr processSynchronize(const std::string& server_name,
970 const unsigned int max_period);
971
972protected:
973
994 int synchronize(std::string& status_message,
995 const HAConfig::PeerConfigPtr& remote_config,
996 const unsigned int max_period);
997
1016 void asyncSendLeaseUpdatesFromBacklog(http::HttpClient& http_client,
1017 const HAConfig::PeerConfigPtr& remote_config,
1018 PostRequestCallback post_request_action);
1019
1033 bool sendLeaseUpdatesFromBacklog();
1034
1041 void asyncSendHAReset(http::HttpClient& http_client,
1042 const HAConfig::PeerConfigPtr& remote_config,
1043 PostRequestCallback post_request_action);
1044
1057 bool sendHAReset();
1058
1059public:
1060
1066 data::ConstElementPtr processScopes(const std::vector<std::string>& scopes);
1067
1071 data::ConstElementPtr processContinue();
1072
1095 data::ConstElementPtr processMaintenanceNotify(const bool cancel,
1096 const std::string& state);
1097
1114 data::ConstElementPtr processMaintenanceStart();
1115
1131 data::ConstElementPtr processMaintenanceCancel();
1132
1138 void checkPermissionsClientAndListener();
1139
1140protected:
1141
1151 void asyncSyncCompleteNotify(http::HttpClient& http_client,
1152 const HAConfig::PeerConfigPtr& remote_config,
1153 PostRequestCallback post_request_action);
1154
1155public:
1156
1170 data::ConstElementPtr processSyncCompleteNotify(const unsigned int origin_id);
1171
1179 void startClientAndListener();
1180
1187 void pauseClientAndListener();
1188
1195 void resumeClientAndListener();
1196
1202 void stopClientAndListener();
1203
1204protected:
1205
1220 data::ConstElementPtr verifyAsyncResponse(const http::HttpResponsePtr& response,
1221 int& rcode);
1222
1232 bool clientConnectHandler(const boost::system::error_code& ec, int tcp_native_fd);
1233
1239 bool clientHandshakeHandler(const boost::system::error_code&) {
1240 return (true);
1241 }
1242
1259 void socketReadyHandler(int tcp_native_fd);
1260
1268 void clientCloseHandler(int tcp_native_fd);
1269
1271 unsigned int id_;
1272
1275 asiolink::IOServicePtr io_service_;
1276
1278 dhcp::NetworkStatePtr network_state_;
1279
1281 HAConfigPtr config_;
1282
1284 HAServerType server_type_;
1285
1287 http::HttpClientPtr client_;
1288
1291 config::CmdHttpListenerPtr listener_;
1292
1294 CommunicationStatePtr communication_state_;
1295
1297 QueryFilter query_filter_;
1298
1300 LeaseSyncFilter lease_sync_filter_;
1301
1318 template<typename QueryPtrType>
1319 bool leaseUpdateComplete(QueryPtrType& query,
1320 const hooks::ParkingLotHandlePtr& parking_lot);
1321
1327 template<typename QueryPtrType>
1328 void updatePendingRequest(QueryPtrType& query);
1329
1334 size_t pendingRequestSize();
1335
1345 template<typename QueryPtrType>
1346 int getPendingRequest(const QueryPtrType& query);
1347
1348private:
1367 template<typename QueryPtrType>
1368 bool leaseUpdateCompleteInternal(QueryPtrType& query,
1369 const hooks::ParkingLotHandlePtr& parking_lot);
1370
1378 template<typename QueryPtrType>
1379 void updatePendingRequestInternal(QueryPtrType& query);
1380
1391 template<typename QueryPtrType>
1392 int getPendingRequestInternal(const QueryPtrType& query);
1393
1395 std::mutex mutex_;
1396
1405 std::map<boost::shared_ptr<dhcp::Pkt>, int> pending_requests_;
1406
1407protected:
1408
1414 LeaseUpdateBacklog lease_update_backlog_;
1415
1423 bool sync_complete_notified_;
1424};
1425
1427 typedef boost::shared_ptr<HAService> HAServicePtr;
1428
1429} // end of namespace isc::ha
1430} // end of namespace isc
1431
1432#endif
asio_wrapper.h
isc::dhcp::NetworkState::HA_LOCAL_COMMAND
static const unsigned int HA_LOCAL_COMMAND
The network state is being altered by an HA internal command.
Definition network_state.h:88
isc::dhcp::NetworkState::HA_REMOTE_COMMAND
static const unsigned int HA_REMOTE_COMMAND
The network state is being altered by a "dhcp-disable" or "dhcp-enable" command sent by a HA partner.
Definition network_state.h:95
isc::ha::HAConfig::PeerConfigPtr
boost::shared_ptr< PeerConfig > PeerConfigPtr
Pointer to the server's configuration.
Definition ha_config.h:242
isc::ha::HARelationshipMapper
Holds associations between objects and HA relationships.
Definition ha_relationship_mapper.h:33
isc::ha::HAService
High availability service.
Definition ha_service.h:52
isc::ha::HAService::HA_MAINTENANCE_START_EVT
static const int HA_MAINTENANCE_START_EVT
ha-maintenance-start command received.
Definition ha_service.h:71
isc::ha::HAService::inScope
bool inScope(dhcp::Pkt4Ptr &query4)
Checks if the DHCPv4 query should be processed by this server.
Definition ha_service.cc:1059
isc::ha::HAService::adjustNetworkState
void adjustNetworkState()
Enables or disables network state depending on the served scopes.
Definition ha_service.cc:1105
isc::ha::HAService::stopClientAndListener
void stopClientAndListener()
Stop the client and(or) listener instances.
Definition ha_service.cc:3469
isc::ha::HAService::getNormalState
int getNormalState() const
Returns normal operation state for the current configuration.
Definition ha_service.cc:1010
isc::ha::HAService::shouldQueueLeaseUpdates
bool shouldQueueLeaseUpdates(const HAConfig::PeerConfigPtr &peer_config) const
Checks if the lease updates should be queued.
Definition ha_service.cc:1624
isc::ha::HAService::HA_HEARTBEAT_COMPLETE_EVT
static const int HA_HEARTBEAT_COMPLETE_EVT
Finished heartbeat command.
Definition ha_service.h:56
isc::ha::HAService::asyncSendHAReset
void asyncSendHAReset(http::HttpClient &http_client, const HAConfig::PeerConfigPtr &remote_config, PostRequestCallback post_request_action)
Sends ha-reset command to partner asynchronously.
Definition ha_service.cc:2663
isc::ha::HAService::clientConnectHandler
bool clientConnectHandler(const boost::system::error_code &ec, int tcp_native_fd)
HttpClient connect callback handler.
Definition ha_service.cc:3306
isc::ha::HAService::asyncSyncLeases
void asyncSyncLeases()
Asynchronously reads leases from a peer and updates local lease database.
Definition ha_service.cc:2119
isc::ha::HAService::isMaintenanceCanceled
bool isMaintenanceCanceled() const
Convenience method checking if the current state is a result of canceling the maintenance.
Definition ha_service.cc:1180
isc::ha::HAService::processMaintenanceCancel
data::ConstElementPtr processMaintenanceCancel()
Processes ha-maintenance-cancel command and returns a response.
Definition ha_service.cc:2951
isc::ha::HAService::checkPermissionsClientAndListener
void checkPermissionsClientAndListener()
Check client and(or) listener current thread permissions to perform thread pool state transition.
Definition ha_service.cc:3385
isc::ha::HAService::shouldReclaim
bool shouldReclaim(const dhcp::Lease4Ptr &lease4) const
Checks if the lease should be reclaimed by this server.
Definition ha_service.cc:1089
isc::ha::HAService::asyncSendLeaseUpdate
void asyncSendLeaseUpdate(const QueryPtrType &query, const HAConfig::PeerConfigPtr &config, const data::ConstElementPtr &command, const hooks::ParkingLotHandlePtr &parking_lot)
Asynchronously sends lease update to the peer.
Definition ha_service.cc:1434
isc::ha::HAService::verboseTransition
void verboseTransition(const unsigned state)
Transitions to a desired state and logs it.
Definition ha_service.cc:939
isc::ha::HAService::sendLeaseUpdatesFromBacklog
bool sendLeaseUpdatesFromBacklog()
Attempts to send all lease updates from the backlog synchronously.
Definition ha_service.cc:2615
isc::ha::HAService::listener_
config::CmdHttpListenerPtr listener_
HTTP listener instance used to receive and respond to HA commands and lease updates.
Definition ha_service.h:1291
isc::ha::HAService::clientCloseHandler
void clientCloseHandler(int tcp_native_fd)
HttpClient close callback handler.
Definition ha_service.cc:3346
isc::ha::HAService::leaseUpdateComplete
bool leaseUpdateComplete(QueryPtrType &query, const hooks::ParkingLotHandlePtr &parking_lot)
Handle last pending request for this query.
Definition ha_service.cc:1378
isc::ha::HAService::config_
HAConfigPtr config_
Pointer to the HA hooks library configuration.
Definition ha_service.h:1281
isc::ha::HAService::processMaintenanceStart
data::ConstElementPtr processMaintenanceStart()
Processes ha-maintenance-start command and returns a response.
Definition ha_service.cc:2814
isc::ha::HAService::id_
unsigned int id_
Unique service id.
Definition ha_service.h:1271
isc::ha::HAService::server_type_
HAServerType server_type_
DHCP server type.
Definition ha_service.h:1284
isc::ha::HAService::sync_complete_notified_
bool sync_complete_notified_
An indicator that a partner sent ha-sync-complete-notify command.
Definition ha_service.h:1423
isc::ha::HAService::shouldTerminate
bool shouldTerminate() const
Indicates if the server should transition to the terminated state.
Definition ha_service.cc:1164
isc::ha::HAService::processScopes
data::ConstElementPtr processScopes(const std::vector< std::string > &scopes)
Processes ha-scopes command and returns a response.
Definition ha_service.cc:2739
isc::ha::HAService::network_state_
dhcp::NetworkStatePtr network_state_
Pointer to the state of the DHCP service (enabled/disabled).
Definition ha_service.h:1278
isc::ha::HAService::processSynchronize
data::ConstElementPtr processSynchronize(const std::string &server_name, const unsigned int max_period)
Processes ha-sync command and returns a response.
Definition ha_service.cc:2383
isc::ha::HAService::scheduleHeartbeat
void scheduleHeartbeat()
Schedules asynchronous heartbeat to a peer if it is not scheduled.
Definition ha_service.cc:1934
isc::ha::HAService::asyncSyncCompleteNotify
void asyncSyncCompleteNotify(http::HttpClient &http_client, const HAConfig::PeerConfigPtr &remote_config, PostRequestCallback post_request_action)
Schedules asynchronous "ha-sync-complete-notify" command to the specified server.
Definition ha_service.cc:3079
isc::ha::HAService::query_filter_
QueryFilter query_filter_
Selects queries to be processed/dropped.
Definition ha_service.h:1297
isc::ha::HAService::HA_MAINTENANCE_NOTIFY_EVT
static const int HA_MAINTENANCE_NOTIFY_EVT
ha-maintenance-notify command received.
Definition ha_service.h:68
isc::ha::HAService::HA_SYNCED_PARTNER_UNAVAILABLE_EVT
static const int HA_SYNCED_PARTNER_UNAVAILABLE_EVT
The heartbeat command failed after receiving ha-sync-complete-notify command from the partner.
Definition ha_service.h:78
isc::ha::HAService::processMaintenanceNotify
data::ConstElementPtr processMaintenanceNotify(const bool cancel, const std::string &state)
Processes ha-maintenance-notify command and returns a response.
Definition ha_service.cc:2760
isc::ha::HAService::conditionalLogPausedState
void conditionalLogPausedState() const
Logs if the server is paused in the current state.
Definition ha_service.cc:1037
isc::ha::HAService::unpause
bool unpause()
Unpauses the HA state machine with logging.
Definition ha_service.cc:1026
isc::ha::HAService::HA_CONTROL_RESULT_MAINTENANCE_NOT_ALLOWED
static const int HA_CONTROL_RESULT_MAINTENANCE_NOT_ALLOWED
Control result returned in response to ha-maintenance-notify.
Definition ha_service.h:81
isc::ha::HAService::serveDefaultScopes
void serveDefaultScopes()
Instructs the HA service to serve default scopes.
Definition ha_service.cc:1049
isc::ha::HAService::asyncSendLeaseUpdates
size_t asyncSendLeaseUpdates(const dhcp::Pkt4Ptr &query, const dhcp::Lease4CollectionPtr &leases, const dhcp::Lease4CollectionPtr &deleted_leases, const hooks::ParkingLotHandlePtr &parking_lot)
Schedules asynchronous IPv4 leases updates.
Definition ha_service.cc:1218
isc::ha::HAService::pendingRequestSize
size_t pendingRequestSize()
Get the number of entries in the pending request map.
Definition ha_service.cc:3354
isc::ha::HAService::HA_SYNCING_SUCCEEDED_EVT
static const int HA_SYNCING_SUCCEEDED_EVT
Lease database synchronization succeeded.
Definition ha_service.h:65
isc::ha::HAService::sendHAReset
bool sendHAReset()
Sends ha-reset command to partner synchronously.
Definition ha_service.cc:2716
isc::ha::HAService::PostRequestCallback
std::function< void(const bool, const std::string &, const int)> PostRequestCallback
Callback invoked when request was sent and a response received or an error occurred.
Definition ha_service.h:95
isc::ha::HAService::io_service_
asiolink::IOServicePtr io_service_
Pointer to the IO service object shared between this hooks library and the DHCP server.
Definition ha_service.h:1275
isc::ha::HAService::localDisableDHCPService
void localDisableDHCPService()
Disables local DHCP service.
Definition ha_service.cc:2109
isc::ha::HAService::communication_state_
CommunicationStatePtr communication_state_
Holds communication state with a peer.
Definition ha_service.h:1294
isc::ha::HAService::logFailedLeaseUpdates
void logFailedLeaseUpdates(const dhcp::PktPtr &query, const data::ConstElementPtr &args) const
Log failed lease updates.
Definition ha_service.cc:1637
isc::ha::HAService::clientHandshakeHandler
bool clientHandshakeHandler(const boost::system::error_code &)
HttpClient handshake callback handler.
Definition ha_service.h:1239
isc::ha::HAService::lease_update_backlog_
LeaseUpdateBacklog lease_update_backlog_
Backlog of DHCP lease updates.
Definition ha_service.h:1414
isc::ha::HAService::~HAService
virtual ~HAService()
Destructor.
Definition ha_service.cc:147
isc::ha::HAService::HA_SYNCING_FAILED_EVT
static const int HA_SYNCING_FAILED_EVT
Lease database synchronization failed.
Definition ha_service.h:62
isc::ha::HAService::HA_MAINTENANCE_CANCEL_EVT
static const int HA_MAINTENANCE_CANCEL_EVT
ha-maintenance-cancel command received.
Definition ha_service.h:74
isc::ha::HAService::asyncSendLeaseUpdatesFromBacklog
void asyncSendLeaseUpdatesFromBacklog(http::HttpClient &http_client, const HAConfig::PeerConfigPtr &remote_config, PostRequestCallback post_request_action)
Sends lease updates from backlog to partner asynchronously.
Definition ha_service.cc:2537
isc::ha::HAService::processHeartbeat
data::ConstElementPtr processHeartbeat()
Processes ha-heartbeat command and returns a response.
Definition ha_service.cc:1744
isc::ha::HAService::asyncSyncLeasesInternal
void asyncSyncLeasesInternal(http::HttpClient &http_client, const HAConfig::PeerConfigPtr &remote_config, const unsigned int max_period, const dhcp::LeasePtr &last_lease, PostSyncCallback post_sync_action, const bool dhcp_disabled)
Implements fetching one page of leases during synchronization.
Definition ha_service.cc:2167
isc::ha::HAService::processHAReset
data::ConstElementPtr processHAReset()
Processes ha-reset command and returns a response.
Definition ha_service.cc:1767
isc::ha::HAService::asyncSendSingleLeaseUpdate
size_t asyncSendSingleLeaseUpdate(const dhcp::Pkt4Ptr &query, const dhcp::Lease4Ptr &lease, const hooks::ParkingLotHandlePtr &parking_lot)
Schedules an asynchronous IPv4 lease update.
Definition ha_service.cc:1300
isc::ha::HAService::asyncSendHeartbeat
void asyncSendHeartbeat()
Starts asynchronous heartbeat to a peer.
Definition ha_service.cc:1777
isc::ha::HAService::isPartnerStateInvalid
bool isPartnerStateInvalid() const
Indicates if the partner's state is invalid.
Definition ha_service.cc:1185
isc::ha::HAService::startClientAndListener
void startClientAndListener()
Start the client and(or) listener instances.
Definition ha_service.cc:3414
isc::ha::HAService::verifyAsyncResponse
data::ConstElementPtr verifyAsyncResponse(const http::HttpResponsePtr &response, int &rcode)
Checks if the response is valid or contains an error.
Definition ha_service.cc:3183
isc::ha::HAService::resumeClientAndListener
void resumeClientAndListener()
Resumes client and(or) listener thread pool operations.
Definition ha_service.cc:3450
isc::ha::HAService::processStatusGet
data::ConstElementPtr processStatusGet() const
Processes status-get command and returns a response.
Definition ha_service.cc:1687
isc::ha::HAService::getPendingRequest
int getPendingRequest(const QueryPtrType &query)
Get the number of scheduled requests for a given query.
Definition ha_service.cc:3365
isc::ha::HAService::lease_sync_filter_
LeaseSyncFilter lease_sync_filter_
Lease synchronization filter used in hub-and-spoke model.
Definition ha_service.h:1300
isc::ha::HAService::synchronize
int synchronize(std::string &status_message, const HAConfig::PeerConfigPtr &remote_config, const unsigned int max_period)
Synchronizes lease database with a partner.
Definition ha_service.cc:2402
isc::ha::HAService::shouldSendLeaseUpdates
bool shouldSendLeaseUpdates(const HAConfig::PeerConfigPtr &peer_config) const
Checks if the lease updates should be sent as result of leases allocation or release.
Definition ha_service.cc:1592
isc::ha::HAService::serveFailoverScopes
void serveFailoverScopes()
Instructs the HA service to serve failover scopes.
Definition ha_service.cc:1054
isc::ha::HAService::localEnableDHCPService
void localEnableDHCPService()
Enables local DHCP service.
Definition ha_service.cc:2114
isc::ha::HAService::HA_LEASE_UPDATES_COMPLETE_EVT
static const int HA_LEASE_UPDATES_COMPLETE_EVT
Finished lease updates commands.
Definition ha_service.h:59
isc::ha::HAService::HAService
HAService(const unsigned int id, const asiolink::IOServicePtr &io_service, const dhcp::NetworkStatePtr &network_state, const HAConfigPtr &config, const HAServerType &server_type=HAServerType::DHCPv4)
Constructor.
Definition ha_service.cc:76
isc::ha::HAService::getServerType
HAServerType getServerType() const
Returns HA server type used in object construction.
Definition ha_service.h:133
isc::ha::HAService::socketReadyHandler
void socketReadyHandler(int tcp_native_fd)
IfaceMgr external socket ready callback handler.
Definition ha_service.cc:3337
isc::ha::HAService::client_
http::HttpClientPtr client_
HTTP client instance used to send HA commands and lease updates.
Definition ha_service.h:1287
isc::ha::HAService::updatePendingRequest
void updatePendingRequest(QueryPtrType &query)
Update pending request counter for this query.
Definition ha_service.cc:1413
isc::ha::HAService::shouldPartnerDown
bool shouldPartnerDown() const
Indicates if the server should transition to the partner down state.
Definition ha_service.cc:1137
isc::ha::HAService::startHeartbeat
void startHeartbeat()
Unconditionally starts one heartbeat to a peer.
Definition ha_service.cc:1941
isc::ha::HAService::processSyncCompleteNotify
data::ConstElementPtr processSyncCompleteNotify(const unsigned int origin_id)
Process ha-sync-complete-notify command and returns a response.
Definition ha_service.cc:3162
isc::ha::HAService::processContinue
data::ConstElementPtr processContinue()
Processes ha-continue command and returns a response.
Definition ha_service.cc:2752
isc::ha::HAService::asyncDisableDHCPService
void asyncDisableDHCPService(http::HttpClient &http_client, const HAConfig::PeerConfigPtr &remote_config, const unsigned int max_period, PostRequestCallback post_request_action)
Schedules asynchronous "dhcp-disable" command to the specified server.
Definition ha_service.cc:1950
isc::ha::HAService::pauseClientAndListener
void pauseClientAndListener()
Pauses client and(or) listener thread pool operations.
Definition ha_service.cc:3431
isc::ha::HAService::PostSyncCallback
std::function< void(const bool, const std::string &, const bool)> PostSyncCallback
Callback invoked when lease database synchronization is complete.
Definition ha_service.h:104
isc::ha::HAService::HA_WAITING_TO_TERMINATED_ST_DELAY_MINUTES
static const int HA_WAITING_TO_TERMINATED_ST_DELAY_MINUTES
A delay in minutes to transition from the waiting to terminated state when the partner remains in ter...
Definition ha_service.h:85
isc::ha::HAService::asyncEnableDHCPService
void asyncEnableDHCPService(http::HttpClient &http_client, const HAConfig::PeerConfigPtr &remote_config, PostRequestCallback post_request_action)
Schedules asynchronous "dhcp-enable" command to the specified server.
Definition ha_service.cc:2031
isc::ha::LeaseSyncFilter
Checks if a lease fetched from the other server should be synchronized into the local lease database.
Definition lease_sync_filter.h:52
isc::ha::LeaseUpdateBacklog
Queue holding a backlog of unsent lease updates.
Definition lease_update_backlog.h:45
isc::ha::QueryFilter
DHCP query filtering class.
Definition query_filter.h:61
isc::util::StateModel
Implements a finite state machine.
Definition state_model.h:274
isc::util::StateModel::defineEvents
virtual void defineEvents()
Populates the set of events.
Definition state_model.cc:229
isc::util::StateModel::verifyEvents
virtual void verifyEvents()
Validates the contents of the set of events.
Definition state_model.cc:237
isc::util::StateModel::defineStates
virtual void defineStates()
Populates the set of states.
Definition state_model.cc:245
isc::util::StateModel::SM_DERIVED_EVENT_MIN
static const int SM_DERIVED_EVENT_MIN
Value at which custom events in a derived class should begin.
Definition state_model.h:304
cmd_http_listener.h
communication_state.h
data.h
ha_config.h
ha_server_type.h
io_service.h
lease.h
lease_sync_filter.h
lease_update_backlog.h
client.h
isc::asiolink::IOServicePtr
boost::shared_ptr< IOService > IOServicePtr
Defines a smart pointer to an IOService instance.
Definition io_service.h:35
isc::config
Definition command_interpreter.cc:23
isc::config::CmdHttpListenerPtr
boost::shared_ptr< CmdHttpListener > CmdHttpListenerPtr
Defines a shared pointer to CmdHttpListener.
Definition cmd_http_listener.h:155
isc::data::ConstElementPtr
boost::shared_ptr< const Element > ConstElementPtr
Definition data.h:30
isc::dhcp::PktPtr
boost::shared_ptr< isc::dhcp::Pkt > PktPtr
A pointer to either Pkt4 or Pkt6 packet.
Definition pkt.h:999
isc::dhcp::Lease4CollectionPtr
boost::shared_ptr< Lease4Collection > Lease4CollectionPtr
A shared pointer to the collection of IPv4 leases.
Definition lease.h:523
isc::dhcp::Pkt4Ptr
boost::shared_ptr< Pkt4 > Pkt4Ptr
A pointer to Pkt4 object.
Definition pkt4.h:556
isc::dhcp::Lease6Ptr
boost::shared_ptr< Lease6 > Lease6Ptr
Pointer to a Lease6 structure.
Definition lease.h:528
isc::dhcp::LeasePtr
boost::shared_ptr< Lease > LeasePtr
Pointer to the lease object.
Definition lease.h:25
isc::dhcp::NetworkStatePtr
boost::shared_ptr< NetworkState > NetworkStatePtr
Pointer to the NetworkState object.
Definition network_state.h:220
isc::dhcp::Lease6CollectionPtr
boost::shared_ptr< Lease6Collection > Lease6CollectionPtr
A shared pointer to the collection of IPv6 leases.
Definition lease.h:696
isc::dhcp::Pkt6Ptr
boost::shared_ptr< Pkt6 > Pkt6Ptr
A pointer to Pkt6 packet.
Definition pkt6.h:31
isc::dhcp::Lease4Ptr
boost::shared_ptr< Lease4 > Lease4Ptr
Pointer to a Lease4 structure.
Definition lease.h:315
isc::ha
Definition command_creator.cc:20
isc::ha::CommunicationStatePtr
boost::shared_ptr< CommunicationState > CommunicationStatePtr
Type of the pointer to the CommunicationState object.
Definition communication_state.h:780
isc::ha::HAServiceMapper
HARelationshipMapper< HAService > HAServiceMapper
Type of an object mapping HAService to relationships.
Definition ha_service.h:42
isc::ha::HAServiceMapperPtr
boost::shared_ptr< HAServiceMapper > HAServiceMapperPtr
Pointer to an object mapping HAService to relationships.
Definition ha_service.h:45
isc::ha::HAConfigPtr
boost::shared_ptr< HAConfig > HAConfigPtr
Pointer to the High Availability configuration structure.
Definition ha_config.h:37
isc::ha::HAServerType
HAServerType
Lists possible server types for which HA service is created.
Definition ha_server_type.h:14
isc::ha::HAServerType::DHCPv4
@ DHCPv4
Definition ha_server_type.h:15
isc::ha::HAServicePtr
boost::shared_ptr< HAService > HAServicePtr
Pointer to the HAService class.
Definition ha_service.h:1427
isc::hooks::ParkingLotHandlePtr
boost::shared_ptr< ParkingLotHandle > ParkingLotHandlePtr
Pointer to the parking lot handle.
Definition parking_lots.h:381
isc::http::HttpClientPtr
boost::shared_ptr< HttpClient > HttpClientPtr
Defines a pointer to an HttpClient instance.
Definition lib/http/client.h:339
isc::http::HttpResponsePtr
boost::shared_ptr< HttpResponse > HttpResponsePtr
Pointer to the HttpResponse object.
Definition response.h:81
isc
Defines the logger used by the top-level component of kea-lfc.
Definition check_exists_add.cc:18
network_state.h
parking_lots.h
pkt4.h
query_filter.h
response.h
state_model.h
This file defines the class StateModel.
tls_socket.h