43 namespace ph = std::placeholders;
48 struct CtrlDhcp4Hooks {
49 int hooks_index_dhcp4_srv_configured_;
53 hooks_index_dhcp4_srv_configured_ = HooksManager::registerHook(
"dhcp4_srv_configured");
73 void signalHandler(
int signo) {
75 if (signo == SIGHUP) {
76 ControlledDhcpv4Srv::processCommand(
"config-reload",
78 }
else if ((signo == SIGTERM) || (signo == SIGINT)) {
79 ControlledDhcpv4Srv::processCommand(
"shutdown",
92 ControlledDhcpv4Srv::init(
const std::string& file_name) {
94 start_ = boost::posix_time::second_clock::universal_time();
102 string reason = comment ? comment->stringValue() :
103 "no details available";
114 signal_set_.reset(
new IOSignalSet(getIOService(), signalHandler));
116 signal_set_->add(SIGINT);
117 signal_set_->add(SIGHUP);
118 signal_set_->add(SIGTERM);
121 void ControlledDhcpv4Srv::cleanup() {
126 ControlledDhcpv4Srv::loadConfigFile(
const std::string& file_name) {
135 if (file_name.empty()) {
138 " Please use -c command line option.");
143 json = parser.
parseFile(file_name, Parser4Context::PARSER_DHCP4);
152 "a map, i.e., start with { and end with } and contain " 153 "at least an entry called 'Dhcp4' that itself is a map. " 155 <<
" is a valid JSON, but its top element is not a map." 156 " Did you forget to add { } around your configuration?");
160 result = ControlledDhcpv4Srv::processCommand(
"config-set", json);
166 "processCommand(\"config-set\", json)");
174 string reason = comment ? comment->stringValue() :
175 "no details available";
178 }
catch (
const std::exception& ex) {
181 CfgMgr::instance().rollback();
184 .arg(file_name).arg(ex.what());
186 << file_name <<
"': " << ex.
what());
190 .arg(MultiThreadingMgr::instance().getMode() ?
"yes" :
"no")
191 .arg(MultiThreadingMgr::instance().getThreadPoolSize())
192 .arg(MultiThreadingMgr::instance().getPacketQueueSize());
198 ControlledDhcpv4Srv::commandShutdownHandler(
const string&,
ConstElementPtr args) {
199 if (!ControlledDhcpv4Srv::getInstance()) {
207 if (args->getType() != Element::map) {
213 if (param->getType() != Element::integer) {
215 "parameter 'exit-value' is not an integer"));
218 exit_value = param->intValue();
222 ControlledDhcpv4Srv::getInstance()->shutdownServer(exit_value);
227 ControlledDhcpv4Srv::commandLibReloadHandler(
const string&,
ConstElementPtr) {
232 MultiThreadingMgr::instance().getThreadPool().reset();
237 HooksManager::prepareUnloadLibraries();
238 static_cast<void>(HooksManager::unloadLibraries());
239 bool status = HooksManager::loadLibraries(loaded);
243 }
catch (
const std::exception& ex) {
249 "Hooks libraries successfully reloaded.");
254 ControlledDhcpv4Srv::commandConfigReloadHandler(
const string&,
257 std::string file = ControlledDhcpv4Srv::getInstance()->getConfigFile();
260 auto result = loadConfigFile(file);
263 }
catch (
const std::exception& ex) {
270 "Config reload failed: " +
string(ex.what())));
275 ControlledDhcpv4Srv::commandConfigGetHandler(
const string&,
277 ConstElementPtr config = CfgMgr::instance().getCurrentCfg()->toElement();
283 ControlledDhcpv4Srv::commandConfigWriteHandler(
const string&,
288 if (args->getType() != Element::map) {
292 if (filename_param) {
293 if (filename_param->getType() != Element::string) {
295 "passed parameter 'filename' is not a string"));
297 filename = filename_param->stringValue();
301 if (filename.empty()) {
304 filename = getConfigFile();
307 if (filename.empty()) {
309 "Please specify filename explicitly."));
316 size = writeConfigFile(filename, cfg);
328 params->set(
"size", Element::create(static_cast<long long>(size)));
329 params->set(
"filename", Element::create(filename));
332 + filename +
" successful", params));
336 ControlledDhcpv4Srv::commandConfigSetHandler(
const string&,
345 message =
"Missing mandatory 'arguments' parameter.";
347 dhcp4 = args->get(
"Dhcp4");
349 message =
"Missing mandatory 'Dhcp4' parameter.";
350 }
else if (dhcp4->getType() != Element::map) {
351 message =
"'Dhcp4' parameter expected to be a map.";
356 if (message.empty()) {
357 for (
auto obj : args->mapValue()) {
358 const string& obj_name = obj.first;
359 if (obj_name !=
"Dhcp4") {
362 if (message.empty()) {
363 message =
"Unsupported '" + obj_name +
"' parameter";
365 message +=
" (and '" + obj_name +
"')";
369 if (!message.empty()) {
374 if (!message.empty()) {
387 MultiThreadingMgr::instance().apply(
false, 0, 0);
392 CfgMgr::instance().rollback();
398 Daemon::configureLogger(dhcp4, CfgMgr::instance().getStagingCfg());
402 CfgMgr::instance().getStagingCfg()->applyLoggingCfg();
413 CfgMgr::instance().getStagingCfg()->applyLoggingCfg();
416 CfgMgr::instance().commit();
421 CfgMgr::instance().getCurrentCfg()->applyLoggingCfg();
423 if (CfgMgr::instance().getCurrentCfg()->getSequence() != 0) {
435 ControlledDhcpv4Srv::commandConfigTestHandler(
const string&,
444 message =
"Missing mandatory 'arguments' parameter.";
446 dhcp4 = args->get(
"Dhcp4");
448 message =
"Missing mandatory 'Dhcp4' parameter.";
449 }
else if (dhcp4->getType() != Element::map) {
450 message =
"'Dhcp4' parameter expected to be a map.";
455 if (message.empty()) {
456 for (
auto obj : args->mapValue()) {
457 const string& obj_name = obj.first;
458 if (obj_name !=
"Dhcp4") {
461 if (message.empty()) {
462 message =
"Unsupported '" + obj_name +
"' parameter";
464 message +=
" (and '" + obj_name +
"')";
468 if (!message.empty()) {
473 if (!message.empty()) {
486 CfgMgr::instance().rollback();
489 return (checkConfig(dhcp4));
493 ControlledDhcpv4Srv::commandDhcpDisableHandler(
const std::string&,
495 std::ostringstream message;
496 int64_t max_period = 0;
507 if (args->getType() != Element::map) {
508 message <<
"arguments for the 'dhcp-disable' command must be a map";
513 if (max_period_element) {
515 if (max_period_element->getType() != Element::integer) {
516 message <<
"'max-period' argument must be a number";
520 max_period = max_period_element->intValue();
521 if (max_period <= 0) {
522 message <<
"'max-period' must be positive integer";
528 if (origin_element) {
530 if (origin_element->getType() != Element::string) {
531 message <<
"'origin' argument must be a string";
534 origin = origin_element->stringValue();
535 if (origin ==
"ha-partner") {
536 type = NetworkState::Origin::HA_COMMAND;
537 }
else if (origin !=
"user") {
538 if (origin.empty()) {
539 origin =
"(empty string)";
541 message <<
"invalid value used for 'origin' parameter: " 550 if (message.tellp() == 0) {
551 message <<
"DHCPv4 service disabled";
552 if (max_period > 0) {
553 message <<
" for " << max_period <<
" seconds";
558 network_state_->delayedEnableAll(static_cast<unsigned>(max_period),
561 network_state_->disableService(type);
572 ControlledDhcpv4Srv::commandDhcpEnableHandler(
const std::string&,
574 std::ostringstream message;
584 if (args->getType() != Element::map) {
585 message <<
"arguments for the 'dhcp-enable' command must be a map";
590 if (origin_element) {
592 if (origin_element->getType() != Element::string) {
593 message <<
"'origin' argument must be a string";
596 origin = origin_element->stringValue();
597 if (origin ==
"ha-partner") {
598 type = NetworkState::Origin::HA_COMMAND;
599 }
else if (origin !=
"user") {
600 if (origin.empty()) {
601 origin =
"(empty string)";
603 message <<
"invalid value used for 'origin' parameter: " 612 if (message.tellp() == 0) {
613 network_state_->enableService(type);
617 "DHCP service successfully enabled"));
625 ControlledDhcpv4Srv::commandVersionGetHandler(
const string&,
ConstElementPtr) {
626 ElementPtr extended = Element::create(Dhcpv4Srv::getVersion(
true));
628 arguments->set(
"extended", extended);
630 Dhcpv4Srv::getVersion(
false),
636 ControlledDhcpv4Srv::commandBuildReportHandler(
const string&,
644 ControlledDhcpv4Srv::commandLeasesReclaimHandler(
const string&,
651 message =
"Missing mandatory 'remove' parameter.";
655 message =
"Missing mandatory 'remove' parameter.";
656 }
else if (remove_name->getType() != Element::boolean) {
657 message =
"'remove' parameter expected to be a boolean.";
659 bool remove_lease = remove_name->boolValue();
660 server_->alloc_engine_->reclaimExpiredLeases4(0, 0, remove_lease);
662 message =
"Reclamation of expired leases is complete.";
670 ControlledDhcpv4Srv::commandServerTagGetHandler(
const std::string&,
672 const std::string& tag =
673 CfgMgr::instance().getCurrentCfg()->getServerTag();
675 response->set(
"server-tag", Element::create(tag));
681 ControlledDhcpv4Srv::commandConfigBackendPullHandler(
const std::string&,
683 auto ctl_info = CfgMgr::instance().getCurrentCfg()->getConfigControlInfo();
692 if (TimerMgr::instance()->isTimerRegistered(
"Dhcp4CBFetchTimer")) {
693 TimerMgr::instance()->cancel(
"Dhcp4CBFetchTimer");
694 TimerMgr::instance()->setup(
"Dhcp4CBFetchTimer");
701 auto srv_cfg = CfgMgr::instance().getCurrentCfg();
702 auto mode = CBControlDHCPv4::FetchMode::FETCH_UPDATE;
703 server_->getCBControl()->databaseConfigFetch(srv_cfg, mode);
704 }
catch (
const std::exception& ex) {
708 "On demand configuration update failed: " +
712 "On demand configuration update successful."));
716 ControlledDhcpv4Srv::commandStatusGetHandler(
const string&,
719 status->set(
"pid", Element::create(static_cast<int>(getpid())));
721 auto now = boost::posix_time::second_clock::universal_time();
723 if (!start_.is_not_a_date_time()) {
724 auto uptime = now - start_;
725 status->set(
"uptime", Element::create(uptime.total_seconds()));
728 auto last_commit = CfgMgr::instance().getCurrentCfg()->getLastCommitTime();
729 if (!last_commit.is_not_a_date_time()) {
730 auto reload = now - last_commit;
731 status->set(
"reload", Element::create(reload.total_seconds()));
734 auto& mt_mgr = MultiThreadingMgr::instance();
735 if (mt_mgr.getMode()) {
736 status->set(
"multi-threading-enabled", Element::create(
true));
737 status->set(
"thread-pool-size", Element::create(static_cast<int32_t>(
738 MultiThreadingMgr::instance().getThreadPoolSize())));
739 status->set(
"packet-queue-size", Element::create(static_cast<int32_t>(
740 MultiThreadingMgr::instance().getPacketQueueSize())));
741 ElementPtr queue_stats = Element::createList();
742 queue_stats->add(Element::create(mt_mgr.getThreadPool().getQueueStat(10)));
743 queue_stats->add(Element::create(mt_mgr.getThreadPool().getQueueStat(100)));
744 queue_stats->add(Element::create(mt_mgr.getThreadPool().getQueueStat(1000)));
745 status->set(
"packet-queue-statistics", queue_stats);
748 status->set(
"multi-threading-enabled", Element::create(
false));
755 ControlledDhcpv4Srv::commandStatisticSetMaxSampleCountAllHandler(
const string&,
757 StatsMgr& stats_mgr = StatsMgr::instance();
761 CfgMgr::instance().getCurrentCfg()->addConfiguredGlobal(
762 "statistic-default-sample-count", Element::create(max_samples));
767 ControlledDhcpv4Srv::commandStatisticSetMaxSampleAgeAllHandler(
const string&,
769 StatsMgr& stats_mgr = StatsMgr::instance();
774 CfgMgr::instance().getCurrentCfg()->addConfiguredGlobal(
775 "statistic-default-sample-age", Element::create(max_age));
780 ControlledDhcpv4Srv::processCommand(
const string& command,
782 string txt = args ? args->str() :
"(none)";
785 .arg(command).arg(txt);
791 "Server object not initialized, so can't process command '" +
792 command +
"', arguments: '" + txt +
"'.");
797 if (command ==
"shutdown") {
798 return (srv->commandShutdownHandler(command, args));
800 }
else if (command ==
"libreload") {
801 return (srv->commandLibReloadHandler(command, args));
803 }
else if (command ==
"config-reload") {
804 return (srv->commandConfigReloadHandler(command, args));
806 }
else if (command ==
"config-set") {
807 return (srv->commandConfigSetHandler(command, args));
809 }
else if (command ==
"config-get") {
810 return (srv->commandConfigGetHandler(command, args));
812 }
else if (command ==
"config-test") {
813 return (srv->commandConfigTestHandler(command, args));
815 }
else if (command ==
"dhcp-disable") {
816 return (srv->commandDhcpDisableHandler(command, args));
818 }
else if (command ==
"dhcp-enable") {
819 return (srv->commandDhcpEnableHandler(command, args));
821 }
else if (command ==
"version-get") {
822 return (srv->commandVersionGetHandler(command, args));
824 }
else if (command ==
"build-report") {
825 return (srv->commandBuildReportHandler(command, args));
827 }
else if (command ==
"leases-reclaim") {
828 return (srv->commandLeasesReclaimHandler(command, args));
830 }
else if (command ==
"config-write") {
831 return (srv->commandConfigWriteHandler(command, args));
833 }
else if (command ==
"server-tag-get") {
834 return (srv->commandServerTagGetHandler(command, args));
836 }
else if (command ==
"config-backend-pull") {
837 return (srv->commandConfigBackendPullHandler(command, args));
839 }
else if (command ==
"status-get") {
840 return (srv->commandStatusGetHandler(command, args));
848 + command +
"':" + ex.
what() +
849 ", params: '" + txt +
"'"));
858 std::ostringstream err;
861 err <<
"Server object not initialized, can't process config.";
878 }
catch (
const std::exception& ex) {
879 err <<
"Failed to process configuration:" << ex.what();
885 DatabaseConnection::db_lost_callback_ =
886 std::bind(&ControlledDhcpv4Srv::dbLostCallback, srv, ph::_1);
888 DatabaseConnection::db_recovered_callback_ =
889 std::bind(&ControlledDhcpv4Srv::dbRecoveredCallback, srv, ph::_1);
891 DatabaseConnection::db_failed_callback_ =
892 std::bind(&ControlledDhcpv4Srv::dbFailedCallback, srv, ph::_1);
894 CfgDbAccessPtr cfg_db = CfgMgr::instance().getStagingCfg()->getCfgDbAccess();
895 cfg_db->setAppendedParameters(
"universe=4");
896 cfg_db->createManagers();
899 }
catch (
const std::exception& ex) {
900 err <<
"Unable to open database: " << ex.what();
907 }
catch (
const std::exception& ex) {
908 err <<
"Error starting DHCP_DDNS client after server reconfiguration: " 915 Dhcp4to6Ipc::instance().open();
916 }
catch (
const std::exception& ex) {
917 std::ostringstream err;
918 err <<
"error starting DHCPv4-over-DHCPv6 IPC " 919 " after server reconfiguration: " << ex.what();
926 qc = CfgMgr::instance().getStagingCfg()->getDHCPQueueControl();
927 if (IfaceMgr::instance().configureDHCPPacketQueue(AF_INET, qc)) {
929 .arg(IfaceMgr::instance().getPacketQueue4()->getInfoStr());
932 }
catch (
const std::exception& ex) {
933 err <<
"Error setting packet queue controls after server reconfiguration: " 940 CfgIface::open_sockets_failed_callback_ =
941 std::bind(&ControlledDhcpv4Srv::openSocketsFailedCallback, srv, ph::_1);
950 CfgMgr::instance().getStagingCfg()->getCfgIface()->
952 getInstance()->useBroadcast());
956 CfgMgr::instance().getStagingCfg()->getCfgExpiration()->
957 setupTimers(&ControlledDhcpv4Srv::reclaimExpiredLeases,
958 &ControlledDhcpv4Srv::deleteExpiredReclaimedLeases,
961 }
catch (
const std::exception& ex) {
962 err <<
"unable to setup timers for periodically running the" 963 " reclamation of the expired leases: " 969 auto ctl_info = CfgMgr::instance().getStagingCfg()->getConfigControlInfo();
971 long fetch_time =
static_cast<long>(ctl_info->getConfigFetchWaitTime());
974 if (fetch_time > 0) {
980 if (!server_->inTestMode()) {
981 fetch_time = 1000 * fetch_time;
984 boost::shared_ptr<unsigned> failure_count(
new unsigned(0));
985 TimerMgr::instance()->
986 registerTimer(
"Dhcp4CBFetchTimer",
987 std::bind(&ControlledDhcpv4Srv::cbFetchUpdates,
988 server_, CfgMgr::instance().getStagingCfg(),
992 TimerMgr::instance()->setup(
"Dhcp4CBFetchTimer");
998 LibDHCP::commitRuntimeOptionDefs();
1005 if (HooksManager::calloutsPresent(Hooks.hooks_index_dhcp4_srv_configured_)) {
1008 callout_handle->setArgument(
"io_context", srv->
getIOService());
1010 callout_handle->setArgument(
"json_config", config);
1011 callout_handle->setArgument(
"server_config", CfgMgr::instance().getStagingCfg());
1013 HooksManager::callCallouts(Hooks.hooks_index_dhcp4_srv_configured_,
1025 CfgMultiThreading::apply(CfgMgr::instance().getStagingCfg()->getDHCPMultiThreading());
1026 }
catch (
const std::exception& ex) {
1027 err <<
"Error applying multi threading settings: " 1044 std::ostringstream err;
1047 err <<
"Server object not initialized, can't process config.";
1054 ControlledDhcpv4Srv::ControlledDhcpv4Srv(uint16_t server_port ,
1055 uint16_t client_port )
1059 "There is another Dhcpv4Srv instance already.");
1077 CommandMgr::instance().registerCommand(
"build-report",
1078 std::bind(&ControlledDhcpv4Srv::commandBuildReportHandler,
this, ph::_1, ph::_2));
1080 CommandMgr::instance().registerCommand(
"config-backend-pull",
1081 std::bind(&ControlledDhcpv4Srv::commandConfigBackendPullHandler,
this, ph::_1, ph::_2));
1083 CommandMgr::instance().registerCommand(
"config-get",
1084 std::bind(&ControlledDhcpv4Srv::commandConfigGetHandler,
this, ph::_1, ph::_2));
1086 CommandMgr::instance().registerCommand(
"config-reload",
1087 std::bind(&ControlledDhcpv4Srv::commandConfigReloadHandler,
this, ph::_1, ph::_2));
1089 CommandMgr::instance().registerCommand(
"config-set",
1090 std::bind(&ControlledDhcpv4Srv::commandConfigSetHandler,
this, ph::_1, ph::_2));
1092 CommandMgr::instance().registerCommand(
"config-test",
1093 std::bind(&ControlledDhcpv4Srv::commandConfigTestHandler,
this, ph::_1, ph::_2));
1095 CommandMgr::instance().registerCommand(
"config-write",
1096 std::bind(&ControlledDhcpv4Srv::commandConfigWriteHandler,
this, ph::_1, ph::_2));
1098 CommandMgr::instance().registerCommand(
"dhcp-enable",
1099 std::bind(&ControlledDhcpv4Srv::commandDhcpEnableHandler,
this, ph::_1, ph::_2));
1101 CommandMgr::instance().registerCommand(
"dhcp-disable",
1102 std::bind(&ControlledDhcpv4Srv::commandDhcpDisableHandler,
this, ph::_1, ph::_2));
1104 CommandMgr::instance().registerCommand(
"libreload",
1105 std::bind(&ControlledDhcpv4Srv::commandLibReloadHandler,
this, ph::_1, ph::_2));
1107 CommandMgr::instance().registerCommand(
"leases-reclaim",
1108 std::bind(&ControlledDhcpv4Srv::commandLeasesReclaimHandler,
this, ph::_1, ph::_2));
1110 CommandMgr::instance().registerCommand(
"server-tag-get",
1111 std::bind(&ControlledDhcpv4Srv::commandServerTagGetHandler,
this, ph::_1, ph::_2));
1113 CommandMgr::instance().registerCommand(
"shutdown",
1114 std::bind(&ControlledDhcpv4Srv::commandShutdownHandler,
this, ph::_1, ph::_2));
1116 CommandMgr::instance().registerCommand(
"status-get",
1117 std::bind(&ControlledDhcpv4Srv::commandStatusGetHandler,
this, ph::_1, ph::_2));
1119 CommandMgr::instance().registerCommand(
"version-get",
1120 std::bind(&ControlledDhcpv4Srv::commandVersionGetHandler,
this, ph::_1, ph::_2));
1123 CommandMgr::instance().registerCommand(
"statistic-get",
1124 std::bind(&StatsMgr::statisticGetHandler, ph::_1, ph::_2));
1126 CommandMgr::instance().registerCommand(
"statistic-reset",
1127 std::bind(&StatsMgr::statisticResetHandler, ph::_1, ph::_2));
1129 CommandMgr::instance().registerCommand(
"statistic-remove",
1130 std::bind(&StatsMgr::statisticRemoveHandler, ph::_1, ph::_2));
1132 CommandMgr::instance().registerCommand(
"statistic-get-all",
1133 std::bind(&StatsMgr::statisticGetAllHandler, ph::_1, ph::_2));
1135 CommandMgr::instance().registerCommand(
"statistic-reset-all",
1136 std::bind(&StatsMgr::statisticResetAllHandler, ph::_1, ph::_2));
1138 CommandMgr::instance().registerCommand(
"statistic-remove-all",
1139 std::bind(&StatsMgr::statisticRemoveAllHandler, ph::_1, ph::_2));
1141 CommandMgr::instance().registerCommand(
"statistic-sample-age-set",
1142 std::bind(&StatsMgr::statisticSetMaxSampleAgeHandler, ph::_1, ph::_2));
1144 CommandMgr::instance().registerCommand(
"statistic-sample-age-set-all",
1145 std::bind(&ControlledDhcpv4Srv::commandStatisticSetMaxSampleAgeAllHandler,
this, ph::_1, ph::_2));
1147 CommandMgr::instance().registerCommand(
"statistic-sample-count-set",
1148 std::bind(&StatsMgr::statisticSetMaxSampleCountHandler, ph::_1, ph::_2));
1150 CommandMgr::instance().registerCommand(
"statistic-sample-count-set-all",
1151 std::bind(&ControlledDhcpv4Srv::commandStatisticSetMaxSampleCountAllHandler,
this, ph::_1, ph::_2));
1172 timer_mgr_->unregisterTimers();
1175 CommandMgr::instance().closeCommandSocket();
1178 CommandMgr::instance().deregisterCommand(
"build-report");
1179 CommandMgr::instance().deregisterCommand(
"config-backend-pull");
1180 CommandMgr::instance().deregisterCommand(
"config-get");
1181 CommandMgr::instance().deregisterCommand(
"config-reload");
1182 CommandMgr::instance().deregisterCommand(
"config-set");
1183 CommandMgr::instance().deregisterCommand(
"config-test");
1184 CommandMgr::instance().deregisterCommand(
"config-write");
1185 CommandMgr::instance().deregisterCommand(
"dhcp-disable");
1186 CommandMgr::instance().deregisterCommand(
"dhcp-enable");
1187 CommandMgr::instance().deregisterCommand(
"leases-reclaim");
1188 CommandMgr::instance().deregisterCommand(
"libreload");
1189 CommandMgr::instance().deregisterCommand(
"server-tag-get");
1190 CommandMgr::instance().deregisterCommand(
"shutdown");
1191 CommandMgr::instance().deregisterCommand(
"statistic-get");
1192 CommandMgr::instance().deregisterCommand(
"statistic-get-all");
1193 CommandMgr::instance().deregisterCommand(
"statistic-remove");
1194 CommandMgr::instance().deregisterCommand(
"statistic-remove-all");
1195 CommandMgr::instance().deregisterCommand(
"statistic-reset");
1196 CommandMgr::instance().deregisterCommand(
"statistic-reset-all");
1197 CommandMgr::instance().deregisterCommand(
"statistic-sample-age-set");
1198 CommandMgr::instance().deregisterCommand(
"statistic-sample-age-set-all");
1199 CommandMgr::instance().deregisterCommand(
"statistic-sample-count-set");
1200 CommandMgr::instance().deregisterCommand(
"statistic-sample-count-set-all");
1201 CommandMgr::instance().deregisterCommand(
"status-get");
1202 CommandMgr::instance().deregisterCommand(
"version-get");
1220 ControlledDhcpv4Srv::reclaimExpiredLeases(
const size_t max_leases,
1221 const uint16_t timeout,
1222 const bool remove_lease,
1223 const uint16_t max_unwarned_cycles) {
1225 server_->
alloc_engine_->reclaimExpiredLeases4(max_leases, timeout,
1227 max_unwarned_cycles);
1228 }
catch (
const std::exception& ex) {
1237 ControlledDhcpv4Srv::deleteExpiredReclaimedLeases(
const uint32_t secs) {
1238 server_->
alloc_engine_->deleteExpiredReclaimedLeases4(secs);
1244 ControlledDhcpv4Srv::dbLostCallback(
ReconnectCtlPtr db_reconnect_ctl) {
1245 if (!db_reconnect_ctl) {
1252 if (db_reconnect_ctl->retriesLeft() == db_reconnect_ctl->maxRetries() &&
1253 db_reconnect_ctl->alterServiceState()) {
1261 if (!db_reconnect_ctl->retriesLeft() ||
1262 !db_reconnect_ctl->retryInterval()) {
1264 .arg(db_reconnect_ctl->retriesLeft())
1265 .arg(db_reconnect_ctl->retryInterval());
1266 if (db_reconnect_ctl->exitOnFailure()) {
1276 ControlledDhcpv4Srv::dbRecoveredCallback(
ReconnectCtlPtr db_reconnect_ctl) {
1277 if (!db_reconnect_ctl) {
1284 if (db_reconnect_ctl->alterServiceState()) {
1290 db_reconnect_ctl->resetRetries();
1296 ControlledDhcpv4Srv::dbFailedCallback(
ReconnectCtlPtr db_reconnect_ctl) {
1297 if (!db_reconnect_ctl) {
1304 .arg(db_reconnect_ctl->maxRetries());
1306 if (db_reconnect_ctl->exitOnFailure()) {
1314 ControlledDhcpv4Srv::openSocketsFailedCallback(
ReconnectCtlPtr reconnect_ctl) {
1315 if (!reconnect_ctl) {
1322 .arg(reconnect_ctl->maxRetries());
1324 if (reconnect_ctl->exitOnFailure()) {
1330 ControlledDhcpv4Srv::cbFetchUpdates(
const SrvConfigPtr& srv_cfg,
1331 boost::shared_ptr<unsigned> failure_count) {
1338 CBControlDHCPv4::FetchMode::FETCH_UPDATE);
1339 (*failure_count) = 0;
1341 }
catch (
const std::exception& ex) {
1348 if (++(*failure_count) > 10) {
RAII class creating a critical section.
const isc::log::MessageID DHCP4_RECLAIM_EXPIRED_LEASES_FAIL
#define LOG_WARN(LOGGER, MESSAGE)
Macro to conveniently test warn output and log it.
const isc::log::MessageID DHCP4_DB_RECONNECT_LOST_CONNECTION
const isc::log::MessageID DHCP4_OPEN_SOCKETS_FAILED
const isc::log::MessageID DHCP4_DYNAMIC_RECONFIGURATION_FAIL
static DbCallback db_lost_callback_
Optional callback function to invoke if an opened connection is lost.
isc::data::ElementPtr parseFile(const std::string &filename, ParserType parser_type)
Run the parser on the file specified.
#define LOG_INFO(LOGGER, MESSAGE)
Macro to conveniently test info output and log it.
ConstElementPtr createAnswer(const int status_code, const std::string &text, const ConstElementPtr &arg)
const int CONTROL_RESULT_SUCCESS
Status code indicating a successful operation.
static void setIOService(const isc::asiolink::IOServicePtr &io_service)
Sets IO service to be used by the Host Manager.
isc::data::ConstElementPtr statisticSetMaxSampleCountAllHandler(const isc::data::ConstElementPtr ¶ms)
Handles statistic-sample-count-set-all command.
Evaluation context, an interface to the expression evaluation.
boost::shared_ptr< ReconnectCtl > ReconnectCtlPtr
Pointer to an instance of ReconnectCtl.
isc::data::ConstElementPtr configureDhcp4Server(Dhcpv4Srv &server, isc::data::ConstElementPtr config_set, bool check_only)
Configure DHCPv4 server (Dhcpv4Srv) with a set of configuration values.
static void destroy()
Destroy lease manager.
const isc::log::MessageID DHCP4_DB_RECONNECT_NO_DB_CTL
const isc::log::MessageID DHCP4_DB_RECONNECT_FAILED
Manages a pool of asynchronous interval timers.
boost::shared_ptr< SrvConfig > SrvConfigPtr
Non-const pointer to the SrvConfig.
The network state is being altered by the DB connection recovery mechanics.
const isc::log::MessageID DHCP4_CB_ON_DEMAND_FETCH_UPDATES_FAIL
#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.
const isc::log::MessageID DHCP4_MULTI_THREADING_INFO
const int CONTROL_RESULT_ERROR
Status code indicating a general failure.
boost::shared_ptr< Element > ElementPtr
const isc::log::MessageID DHCP4_DYNAMIC_RECONFIGURATION_SUCCESS
const isc::log::MessageID DHCP4_CONFIG_PACKET_QUEUE
const isc::log::MessageID DHCP4_CONFIG_UNSUPPORTED_OBJECT
virtual const char * what() const
Returns a C-style character string of the cause of the exception.
static DbCallback db_failed_callback_
Optional callback function to invoke if an opened connection recovery failed.
Statistics Manager class.
std::vector< HookLibInfo > HookLibsCollection
A storage for information about hook libraries.
const int CONTROL_RESULT_EMPTY
Status code indicating that the specified command was completed correctly, but failed to produce any ...
isc::log::Logger dhcp4_logger(DHCP4_APP_LOGGER_NAME)
Base logger for DHCPv4 server.
Origin
Origin of the network state transition.
const isc::log::MessageID DHCP4_DB_RECONNECT_SUCCEEDED
#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...
static const std::string FLUSH_RECLAIMED_TIMER_NAME
Name of the timer for flushing reclaimed leases.
asiolink::IOServicePtr & getIOService()
Returns pointer to the IO service used by the server.
virtual ~ControlledDhcpv4Srv()
Destructor.
Implements an asynchronous "signal" for IOService driven processing.
boost::shared_ptr< CfgDbAccess > CfgDbAccessPtr
A pointer to the CfgDbAccess.
static void create()
Creates new instance of the HostMgr.
const isc::log::MessageID DHCP4_CB_PERIODIC_FETCH_UPDATES_FAIL
A generic exception that is thrown when an unexpected error condition occurs.
static DbCallback db_recovered_callback_
Optional callback function to invoke if an opened connection recovery succeeded.
const isc::log::MessageID DHCP4_DYNAMIC_RECONFIGURATION
boost::shared_ptr< const Element > ConstElementPtr
isc::data::ConstElementPtr redactConfig(isc::data::ConstElementPtr const &config)
Redact a configuration.
uint32_t getMaxSampleCountDefault() const
Get default count limit.
void cleanup()
Performs cleanup, immediately before termination.
uint16_t getServerPort() const
Get UDP port on which server should listen.
const isc::log::MessageID DHCP4_CONFIG_UNRECOVERABLE_ERROR
ConstElementPtr redactConfig(ConstElementPtr const &element, list< string > const &json_path)
Redact a configuration.
boost::shared_ptr< AllocEngine > alloc_engine_
Allocation Engine.
const isc::log::MessageID DHCP4_OPEN_SOCKETS_NO_RECONNECT_CTL
This is a base class for exceptions thrown from the DNS library module.
ConstElementPtr parseAnswer(int &rcode, const ConstElementPtr &msg)
Defines the logger used by the top-level component of kea-lfc.
NetworkStatePtr network_state_
Holds information about disabled DHCP service and/or disabled subnet/network scopes.
void startD2()
Starts DHCP_DDNS client IO if DDNS updates are enabled.
const isc::log::MessageID DHCP4_CB_PERIODIC_FETCH_UPDATES_RETRIES_EXHAUSTED
void setExitValue(int value)
Sets the exit value.
boost::shared_ptr< CalloutHandle > CalloutHandlePtr
A shared pointer to a CalloutHandle object.
static const std::string RECLAIM_EXPIRED_TIMER_NAME
Name of the timer for reclaiming expired leases.
const isc::log::MessageID DHCP4_CONFIG_RECEIVED
This file contains several functions and constants that are used for handling commands and responses ...
const isc::log::MessageID DHCP4_HOOKS_LIBS_RELOAD_FAIL
const isc::log::MessageID DHCP4_CONFIG_LOAD_FAIL
A generic exception that is thrown if a function is called in a prohibited way.
const isc::log::MessageID DHCP4_NOT_RUNNING
#define LOG_DEBUG(LOGGER, LEVEL, MESSAGE)
Macro to conveniently test debug output and log it.
isc::data::ConstElementPtr statisticSetMaxSampleAgeAllHandler(const isc::data::ConstElementPtr ¶ms)
Handles statistic-sample-age-set-all command.
static ControlledDhcpv4Srv * getInstance()
Returns pointer to the sole instance of Dhcpv4Srv.
const isc::log::MessageID DHCP4_DB_RECONNECT_DISABLED
Controlled version of the DHCPv4 server.
std::string getConfigReport()
Defines the Dhcp4o6Ipc class.
static void setIOService(const isc::asiolink::IOServicePtr &io_service)
Sets IO service to be used by the Lease Manager.
const isc::log::MessageID DHCP4_COMMAND_RECEIVED
#define LOG_FATAL(LOGGER, MESSAGE)
Macro to conveniently test fatal output and log it.
void shutdown() override
Instructs the server to shut down.
CBControlDHCPv4Ptr getCBControl() const
Returns an object which controls access to the configuration backends.
static const TimerMgrPtr & instance()
Returns pointer to the sole instance of the TimerMgr.
const int DBG_DHCP4_COMMAND
Debug level used to log receiving commands.
NetworkStatePtr & getNetworkState()
Returns pointer to the network state used by the server.
const StatsDuration & getMaxSampleAgeDefault() const
Get default duration limit.
void shutdownServer(int exit_value)
Initiates shutdown procedure for the whole DHCPv4 server.
Contains declarations for loggers used by the DHCPv4 server component.
long toSeconds(const StatsDuration &dur)
Returns the number of seconds in a duration.