#include <string.h>
#include <sys/time.h>
#include <sys/wait.h>
+#include <systemd/sd-daemon.h>
#include <unistd.h>
#include <algorithm>
#include <map>
{
}
-CubemapStateProto collect_state(const timeval &serialize_start,
+CubemapStateProto collect_state(const timespec &serialize_start,
const vector<Acceptor *> acceptors,
const multimap<string, InputWithRefcount> inputs,
ServerPool *servers)
{
CubemapStateProto state = servers->serialize(); // Fills streams() and clients().
state.set_serialize_start_sec(serialize_start.tv_sec);
- state.set_serialize_start_usec(serialize_start.tv_usec);
+ state.set_serialize_start_usec(serialize_start.tv_nsec / 1000);
for (size_t i = 0; i < acceptors.size(); ++i) {
state.add_acceptors()->MergeFrom(acceptors[i]->serialize());
start_logging();
}
-bool dry_run_config(const std::string &argv0, const std::string &config_filename)
+bool dry_run_config(const string &argv0, const string &config_filename)
{
char *argv0_copy = strdup(argv0.c_str());
char *config_filename_copy = strdup(config_filename.c_str());
find_deleted_streams(config, &deleted_urls);
CubemapStateProto loaded_state;
- struct timeval serialize_start;
+ timespec serialize_start;
set<string> deserialized_urls;
map<sockaddr_in6, Acceptor *, Sockaddr6Compare> deserialized_acceptors;
multimap<string, InputWithRefcount> inputs; // multimap due to older versions without deduplication.
}
serialize_start.tv_sec = loaded_state.serialize_start_sec();
- serialize_start.tv_usec = loaded_state.serialize_start_usec();
+ serialize_start.tv_nsec = loaded_state.serialize_start_usec() * 1000ull;
// Deserialize the streams.
map<string, string> stream_headers_for_url; // See below.
input_stats_thread->run();
}
- struct timeval server_start;
- gettimeofday(&server_start, NULL);
+ timespec server_start;
+ int err = clock_gettime(CLOCK_MONOTONIC, &server_start);
+ assert(err != -1);
if (state_fd != -1) {
// Measure time from we started deserializing (below) to now, when basically everything
// is up and running. This is, in other words, a conservative estimate of how long our
// “glitch” period was, not counting of course reconnects if the configuration changed.
double glitch_time = server_start.tv_sec - serialize_start.tv_sec +
- 1e-6 * (server_start.tv_usec - serialize_start.tv_usec);
+ 1e-9 * (server_start.tv_nsec - serialize_start.tv_nsec);
log(INFO, "Re-exec happened in approx. %.0f ms.", glitch_time * 1000.0);
}
+ sd_notify(0, "READY=1");
+
while (!hupped) {
usleep(100000);
}
+ if (stopped) {
+ sd_notify(0, "STOPPING=1");
+ } else {
+ sd_notify(0, "RELOADING=1");
+ }
+
// OK, we've been HUPed. Time to shut down everything, serialize, and re-exec.
- gettimeofday(&serialize_start, NULL);
+ err = clock_gettime(CLOCK_MONOTONIC, &serialize_start);
+ assert(err != -1);
if (input_stats_thread != NULL) {
input_stats_thread->stop();