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_nsec / 1000);
-
- for (size_t i = 0; i < acceptors.size(); ++i) {
- state.add_acceptors()->MergeFrom(acceptors[i]->serialize());
+
+ for (Acceptor *acceptor : acceptors) {
+ state.add_acceptors()->MergeFrom(acceptor->serialize());
}
- for (multimap<InputKey, InputWithRefcount>::const_iterator input_it = inputs.begin();
- input_it != inputs.end();
- ++input_it) {
- state.add_inputs()->MergeFrom(input_it->second.input->serialize());
+ for (const auto &key_and_input_with_refcount : inputs) {
+ state.add_inputs()->MergeFrom(key_and_input_with_refcount.second.input->serialize());
}
return state;
map<AcceptorConfig, Acceptor *, AcceptorConfigCompare> *deserialized_acceptors)
{
vector<Acceptor *> acceptors;
- for (unsigned i = 0; i < config.acceptors.size(); ++i) {
- const AcceptorConfig &acceptor_config = config.acceptors[i];
+ for (const AcceptorConfig &acceptor_config : config.acceptors) {
Acceptor *acceptor = NULL;
- map<AcceptorConfig, Acceptor *, AcceptorConfigCompare>::iterator deserialized_acceptor_it =
- deserialized_acceptors->find(acceptor_config);
+ const auto deserialized_acceptor_it = deserialized_acceptors->find(acceptor_config);
if (deserialized_acceptor_it != deserialized_acceptors->end()) {
acceptor = deserialized_acceptor_it->second;
deserialized_acceptors->erase(deserialized_acceptor_it);
}
// Close all acceptors that are no longer in the configuration file.
- for (map<AcceptorConfig, Acceptor *, AcceptorConfigCompare>::iterator
- acceptor_it = deserialized_acceptors->begin();
- acceptor_it != deserialized_acceptors->end();
- ++acceptor_it) {
- acceptor_it->second->close_socket();
- delete acceptor_it->second;
+ for (auto &config_and_acceptor : *deserialized_acceptors) {
+ config_and_acceptor.second->close_socket();
+ delete config_and_acceptor.second;
}
return acceptors;
// Find all streams in the configuration file, and create inputs for them.
void create_config_inputs(const Config &config, multimap<InputKey, InputWithRefcount> *inputs)
{
- for (unsigned i = 0; i < config.streams.size(); ++i) {
- const StreamConfig &stream_config = config.streams[i];
+ for (const StreamConfig &stream_config : config.streams) {
if (stream_config.src != "delete") {
create_config_input(stream_config.src, Input::Encoding(stream_config.src_encoding), inputs);
}
}
- for (unsigned i = 0; i < config.udpstreams.size(); ++i) {
- const UDPStreamConfig &udpstream_config = config.udpstreams[i];
+ for (const UDPStreamConfig &udpstream_config : config.udpstreams) {
create_config_input(udpstream_config.src, Input::INPUT_ENCODING_RAW, inputs);
}
}
{
// HTTP streams.
set<string> expecting_urls = deserialized_urls;
- for (unsigned i = 0; i < config.streams.size(); ++i) {
- const StreamConfig &stream_config = config.streams[i];
+ for (const StreamConfig &stream_config : config.streams) {
int stream_index;
expecting_urls.erase(stream_config.url);
string src = stream_config.src;
Input::Encoding src_encoding = Input::Encoding(stream_config.src_encoding);
if (!src.empty()) {
- multimap<InputKey, InputWithRefcount>::iterator input_it = inputs->find(make_pair(src, src_encoding));
+ const auto input_it = inputs->find(make_pair(src, src_encoding));
if (input_it != inputs->end()) {
input_it->second.input->add_destination(stream_index);
++input_it->second.refcount;
}
// Warn about any streams servers we've lost.
- for (set<string>::const_iterator stream_it = expecting_urls.begin();
- stream_it != expecting_urls.end();
- ++stream_it) {
- string url = *stream_it;
+ for (const string &url : expecting_urls) {
log(WARNING, "stream '%s' disappeared from the configuration file. "
"It will not be deleted, but clients will not get any new inputs. "
"If you really meant to delete it, set src=delete and reload.",
}
// UDP streams.
- for (unsigned i = 0; i < config.udpstreams.size(); ++i) {
- const UDPStreamConfig &udpstream_config = config.udpstreams[i];
+ for (const UDPStreamConfig &udpstream_config : config.udpstreams) {
int stream_index = servers->add_udpstream(
udpstream_config.dst,
udpstream_config.pacing_rate,
string src = udpstream_config.src;
if (!src.empty()) {
- multimap<InputKey, InputWithRefcount>::iterator input_it = inputs->find(make_pair(src, Input::INPUT_ENCODING_RAW));
+ auto input_it = inputs->find(make_pair(src, Input::INPUT_ENCODING_RAW));
assert(input_it != inputs->end());
input_it->second.input->add_destination(stream_index);
++input_it->second.refcount;
}
// HTTP gen204 endpoints.
- for (unsigned i = 0; i < config.pings.size(); ++i) {
- const Gen204Config &ping_config = config.pings[i];
+ for (const Gen204Config &ping_config : config.pings) {
servers->add_gen204(ping_config.url, ping_config.allow_origin);
}
}
void open_logs(const vector<LogConfig> &log_destinations)
{
- for (size_t i = 0; i < log_destinations.size(); ++i) {
- if (log_destinations[i].type == LogConfig::LOG_TYPE_FILE) {
- add_log_destination_file(log_destinations[i].filename);
- } else if (log_destinations[i].type == LogConfig::LOG_TYPE_CONSOLE) {
+ for (const LogConfig &log_destination : log_destinations) {
+ if (log_destination.type == LogConfig::LOG_TYPE_FILE) {
+ add_log_destination_file(log_destination.filename);
+ } else if (log_destination.type == LogConfig::LOG_TYPE_CONSOLE) {
add_log_destination_console();
- } else if (log_destinations[i].type == LogConfig::LOG_TYPE_SYSLOG) {
+ } else if (log_destination.type == LogConfig::LOG_TYPE_SYSLOG) {
add_log_destination_syslog();
} else {
assert(false);
void find_deleted_streams(const Config &config, set<string> *deleted_urls)
{
- for (unsigned i = 0; i < config.streams.size(); ++i) {
- const StreamConfig &stream_config = config.streams[i];
+ for (const StreamConfig &stream_config : config.streams) {
if (stream_config.src == "delete") {
log(INFO, "Deleting stream '%s'.", stream_config.url.c_str());
deleted_urls->insert(stream_config.url);
// Deserialize the streams.
map<string, string> stream_headers_for_url; // See below.
- for (int i = 0; i < loaded_state.streams_size(); ++i) {
- const StreamProto &stream = loaded_state.streams(i);
-
+ for (const StreamProto &stream : loaded_state.streams()) {
if (deleted_urls.count(stream.url()) != 0) {
// Delete the stream backlogs.
- for (int j = 0; j < stream.data_fds_size(); ++j) {
- safe_close(stream.data_fds(j));
+ for (const int fd : stream.data_fds()) {
+ safe_close(fd);
}
} else {
vector<int> data_fds;
- for (int j = 0; j < stream.data_fds_size(); ++j) {
- data_fds.push_back(stream.data_fds(j));
+ for (const int fd : stream.data_fds()) {
+ data_fds.push_back(fd);
}
servers->add_stream_from_serialized(stream, data_fds);
}
// Deserialize the inputs. Note that we don't actually add them to any stream yet.
- for (int i = 0; i < loaded_state.inputs_size(); ++i) {
- InputProto serialized_input = loaded_state.inputs(i);
-
+ for (const InputProto &serialized_input : loaded_state.inputs()) {
InputWithRefcount iwr;
iwr.input = create_input(serialized_input);
iwr.refcount = 0;
}
// Deserialize the acceptors.
- for (int i = 0; i < loaded_state.acceptors_size(); ++i) {
+ for (const AcceptorProto &serialized_acceptor : loaded_state.acceptors()) {
AcceptorConfig config;
- config.addr = extract_address_from_acceptor_proto(loaded_state.acceptors(i));
- config.certificate_chain = loaded_state.acceptors(i).certificate_chain();
- config.private_key = loaded_state.acceptors(i).private_key();
+ config.addr = extract_address_from_acceptor_proto(serialized_acceptor);
+ config.certificate_chain = serialized_acceptor.certificate_chain();
+ config.private_key = serialized_acceptor.private_key();
deserialized_acceptors.insert(make_pair(
config,
- new Acceptor(loaded_state.acceptors(i))));
+ new Acceptor(serialized_acceptor)));
}
log(INFO, "Deserialization done.");
servers->run();
// Now delete all inputs that are longer in use, and start the others.
- for (multimap<InputKey, InputWithRefcount>::iterator input_it = inputs.begin();
- input_it != inputs.end(); ) {
+ for (auto input_it = inputs.begin(); input_it != inputs.end(); ) {
if (input_it->second.refcount == 0) {
if (input_it->first.second == Input::INPUT_ENCODING_RAW) {
log(WARNING, "Raw input '%s' no longer in use, closing.",
InputStatsThread *input_stats_thread = NULL;
if (!config.input_stats_file.empty()) {
vector<Input*> inputs_no_refcount;
- for (multimap<InputKey, InputWithRefcount>::iterator input_it = inputs.begin();
- input_it != inputs.end(); ++input_it) {
- inputs_no_refcount.push_back(input_it->second.input);
+ for (const auto &key_and_input_with_refcount : inputs) {
+ inputs_no_refcount.push_back(key_and_input_with_refcount.second.input);
}
input_stats_thread = new InputStatsThread(config.input_stats_file, config.input_stats_interval, inputs_no_refcount);
stats_thread->stop();
delete stats_thread;
}
- for (size_t i = 0; i < acceptors.size(); ++i) {
- acceptors[i]->stop();
+ for (Acceptor *acceptor : acceptors) {
+ acceptor->stop();
}
- for (multimap<InputKey, InputWithRefcount>::iterator input_it = inputs.begin();
- input_it != inputs.end();
- ++input_it) {
- input_it->second.input->stop();
+ for (const auto &key_and_input_with_refcount : inputs) {
+ key_and_input_with_refcount.second.input->stop();
}
servers->stop();
projects / cubemap / blobdiff