X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=main.cpp;h=faf4be8ad6e7a07b30204412c9937dfbbb01a634;hb=4934a0983fee26765a3c1a5b6bf5834ba6e7e52c;hp=2080d73e82fc75acb066ad36b44cee93d1956cac;hpb=1dfa45f9af3f885a50d2bef384ea89b0a4cf17c5;p=cubemap

diff --git a/main.cpp b/main.cpp
index 2080d73..faf4be8 100644
--- a/main.cpp
+++ b/main.cpp
@@ -9,6 +9,7 @@
 #include <string.h>
 #include <sys/time.h>
 #include <sys/wait.h>
+#include <systemd/sd-daemon.h>
 #include <unistd.h>
 #include <algorithm>
 #include <map>
@@ -67,14 +68,14 @@ void do_nothing(int signum)
 {
 }
 
-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());
@@ -185,6 +186,7 @@ void create_streams(const Config &config,
 			stream_index = servers->lookup_stream_by_url(stream_config.url);
 			assert(stream_index != -1);
 			servers->set_backlog_size(stream_index, stream_config.backlog_size);
+			servers->set_prebuffering_bytes(stream_index, stream_config.prebuffering_bytes);
 			servers->set_encoding(stream_index,
 			                      Stream::Encoding(stream_config.encoding));
 		}
@@ -229,6 +231,12 @@ void create_streams(const Config &config,
 			++input_it->second.refcount;
 		}
 	}
+
+	// HTTP ping endpoints.
+	for (unsigned i = 0; i < config.pings.size(); ++i) {
+		const PingConfig &ping_config = config.pings[i];
+		servers->add_ping(ping_config.url, ping_config.allow_origin);
+	}
 }
 	
 void open_logs(const vector<LogConfig> &log_destinations)
@@ -247,7 +255,7 @@ void open_logs(const vector<LogConfig> &log_destinations)
 	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());
@@ -389,7 +397,7 @@ start:
 	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.
@@ -405,7 +413,7 @@ start:
 		}
 
 		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.
@@ -528,23 +536,33 @@ start:
 		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();