6576469821

Committed 19 Oct 2023 02:58PM UTC coverage: 57.406% (-0.09%) from 57.491%

Build # 6576469821

Build Type

Pull #13322

github

Committed by

web-flow

Commit Message

Merge 364632409 into 3574e2c8e

Pull Request Pull Request #13322: ixfrdist: add NOTIFY receive support

Run Details

31201 of 84940 branches covered (0.0%)

Branch coverage included in aggregate %.

101 of 146 new or added lines in 3 files covered. (69.18%)

196 existing lines in 13 files now uncovered.

105256 of 152765 relevant lines covered (68.9%)

2611835.72 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/pdns/recursordist/rec-carbon.cc

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "mtasker.hh"
#include "syncres.hh"
#include "rec_channel.hh"
#include "iputils.hh"
#include "logger.hh"
#include "logging.hh"
#include "arguments.hh"
#include "lock.hh"

GlobalStateHolder<CarbonConfig> g_carbonConfig;

void doCarbonDump(void*)
{
  auto log = g_slog->withName("carbon");
  try {
    static thread_local auto configHolder = g_carbonConfig.getLocal();

    auto config = *configHolder;
    if (config.servers.empty()) {
      return;
    }

    if (config.namespace_name.empty()) {
      config.namespace_name = "pdns";
    }

    if (config.hostname.empty()) {
      try {
        config.hostname = getCarbonHostName();
      }
      catch (const std::exception& e) {
        throw std::runtime_error(std::string("The 'carbon-ourname' setting has not been set and we are unable to determine the system's hostname: ") + e.what());
      }
    }
    if (config.instance_name.empty()) {
      config.instance_name = "recursor";
    }

    PacketBuffer msg;
    for (const auto& carbonServer : config.servers) {
      ComboAddress remote(carbonServer, 2003);
      Socket s(remote.sin4.sin_family, SOCK_STREAM);
      s.setNonBlocking();
      std::shared_ptr<TLSCtx> tlsCtx{nullptr};
      const struct timeval timeout
      {
        g_networkTimeoutMsec / 1000, static_cast<suseconds_t>(g_networkTimeoutMsec) % 1000 * 1000
      };
      auto handler = std::make_shared<TCPIOHandler>("", false, s.releaseHandle(), timeout, tlsCtx);
      handler->tryConnect(SyncRes::s_tcp_fast_open_connect, remote); // we do the connect so the first attempt happens while we gather stats

      if (msg.empty()) {
        auto all = getAllStatsMap(StatComponent::Carbon);

        ostringstream str;
        time_t now = time(0);

        for (const auto& val : all) {
          str << config.namespace_name << '.' << config.hostname << '.' << config.instance_name << '.' << val.first << ' ' << val.second.d_value << ' ' << now << "\r\n";
        }
        const string& x = str.str();
        msg.insert(msg.end(), x.cbegin(), x.cend());
      }

      auto ret = asendtcp(msg, handler); // this will actually do the right thing waiting on the connect
      if (ret == LWResult::Result::Timeout) {
        SLOG(g_log << Logger::Warning << "Timeout connecting/writing carbon data to " << remote.toStringWithPort() << endl,
             log->info(Logr::Warning, "Timeout connecting/writing carbon data", "address", Logging::Loggable(remote)));
      }
      else if (ret != LWResult::Result::Success) {
        int err = errno;
        SLOG(g_log << Logger::Warning << "Error writing carbon data to " << remote.toStringWithPort() << ": " << stringerror(err) << endl,
             log->error(Logr::Warning, err, "Error writing carbon data", "address", Logging::Loggable(remote)));
      }
      handler->close();
    }
  }
  catch (const PDNSException& e) {
    SLOG(g_log << Logger::Error << "Error in carbon thread: " << e.reason << endl,
         log->error(Logr::Error, e.reason, "Error in carbon thread", "exception", Logging::Loggable("PDNSException")));
  }
  catch (const std::exception& e) {
    SLOG(g_log << Logger::Error << "Error in carbon thread: " << e.what() << endl,
         log->error(Logr::Error, e.what(), "Error in carbon thread", "exception", Logging::Loggable("std::exception")));
  }
  catch (...) {
    SLOG(g_log << Logger::Error << "Unknown error in carbon thread" << endl,
         log->info(Logr::Error, "Error in carbon thread"));
  }
}

1	#ifdef HAVE_CONFIG_H
2	#include "config.h"
3	#endif
4	#include "mtasker.hh"
5	#include "syncres.hh"
6	#include "rec_channel.hh"
7	#include "iputils.hh"
8	#include "logger.hh"
9	#include "logging.hh"
10	#include "arguments.hh"
11	#include "lock.hh"
12
13	GlobalStateHolder<CarbonConfig> g_carbonConfig;
14
15	void doCarbonDump(void*)
UNCOV 16	{	×
UNCOV 17	auto log = g_slog->withName("carbon");	×
UNCOV 18	try {	×
UNCOV 19	static thread_local auto configHolder = g_carbonConfig.getLocal();	×
20
UNCOV 21	auto config = *configHolder;	×
UNCOV 22	if (config.servers.empty()) {	×
UNCOV 23	return;	×
UNCOV 24	}	×
25
26	if (config.namespace_name.empty()) {	×
27	config.namespace_name = "pdns";	×
28	}	×
29
30	if (config.hostname.empty()) {	×
31	try {	×
32	config.hostname = getCarbonHostName();	×
33	}	×
34	catch (const std::exception& e) {	×
35	throw std::runtime_error(std::string("The 'carbon-ourname' setting has not been set and we are unable to determine the system's hostname: ") + e.what());	×
36	}	×
37	}	×
38	if (config.instance_name.empty()) {	×
39	config.instance_name = "recursor";	×
40	}	×
41
42	PacketBuffer msg;	×
43	for (const auto& carbonServer : config.servers) {	×
44	ComboAddress remote(carbonServer, 2003);	×
45	Socket s(remote.sin4.sin_family, SOCK_STREAM);	×
46	s.setNonBlocking();	×
47	std::shared_ptr<TLSCtx> tlsCtx{nullptr};	×
48	const struct timeval timeout	×
49	{	×
50	g_networkTimeoutMsec / 1000, static_cast<suseconds_t>(g_networkTimeoutMsec) % 1000 * 1000	×
51	};	×
52	auto handler = std::make_shared<TCPIOHandler>("", false, s.releaseHandle(), timeout, tlsCtx);	×
53	handler->tryConnect(SyncRes::s_tcp_fast_open_connect, remote); // we do the connect so the first attempt happens while we gather stats	×
54
55	if (msg.empty()) {	×
56	auto all = getAllStatsMap(StatComponent::Carbon);	×
57
58	ostringstream str;	×
59	time_t now = time(0);	×
60
61	for (const auto& val : all) {	×
62	str << config.namespace_name << '.' << config.hostname << '.' << config.instance_name << '.' << val.first << ' ' << val.second.d_value << ' ' << now << "\r\n";	×
63	}	×
64	const string& x = str.str();	×
65	msg.insert(msg.end(), x.cbegin(), x.cend());	×
66	}	×
67
68	auto ret = asendtcp(msg, handler); // this will actually do the right thing waiting on the connect	×
69	if (ret == LWResult::Result::Timeout) {	×
70	SLOG(g_log << Logger::Warning << "Timeout connecting/writing carbon data to " << remote.toStringWithPort() << endl,	×
71	log->info(Logr::Warning, "Timeout connecting/writing carbon data", "address", Logging::Loggable(remote)));	×
72	}	×
73	else if (ret != LWResult::Result::Success) {	×
74	int err = errno;	×
75	SLOG(g_log << Logger::Warning << "Error writing carbon data to " << remote.toStringWithPort() << ": " << stringerror(err) << endl,	×
76	log->error(Logr::Warning, err, "Error writing carbon data", "address", Logging::Loggable(remote)));	×
77	}	×
78	handler->close();	×
79	}	×
80	}	×
UNCOV 81	catch (const PDNSException& e) {	×
82	SLOG(g_log << Logger::Error << "Error in carbon thread: " << e.reason << endl,	×
83	log->error(Logr::Error, e.reason, "Error in carbon thread", "exception", Logging::Loggable("PDNSException")));	×
84	}	×
UNCOV 85	catch (const std::exception& e) {	×
86	SLOG(g_log << Logger::Error << "Error in carbon thread: " << e.what() << endl,	×
87	log->error(Logr::Error, e.what(), "Error in carbon thread", "exception", Logging::Loggable("std::exception")));	×
88	}	×
UNCOV 89	catch (...) {	×
90	SLOG(g_log << Logger::Error << "Unknown error in carbon thread" << endl,	×
91	log->info(Logr::Error, "Error in carbon thread"));	×
92	}	×
UNCOV 93	}	×

PowerDNS / pdns / 6576469821

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous