Add support for setting fwmarks per-connection. Useful for shaping individual streams...

[cubemap] / main.cpp

diff --git a/main.cpp b/main.cpp
index 1773af3bff7e9341ef89e7ae39dd9e41813f1f88..1300508f314dc7b5909e6567c80832ac01432345 100644 (file)
--- a/main.cpp
+++ b/main.cpp
@@ -18,6 +18,7 @@
 #include <map>
 #include <set>
 
+#include "markpool.h"
 #include "metacube.h"
 #include "parse.h"
 #include "server.h"
@@ -254,6 +255,33 @@ CubemapStateProto read_tempfile(int state_fd)
 
        return state;
 }
+       
+// Reuse mark pools if one already exists.
+MarkPool *get_mark_pool(map<pair<int, int>, MarkPool *> *mark_pools, int from, int to)
+{
+       pair<int, int> mark_range(from, to);
+       if (mark_pools->count(mark_range) != 0) {
+               return (*mark_pools)[mark_range];
+       }
+
+       // Check if we're overlapping some other mark pool.
+       for (map<pair<int, int>, MarkPool *>::const_iterator mp_it = mark_pools->begin();
+            mp_it != mark_pools->end();
+            ++mp_it) {
+               int other_from = mp_it->first.first;
+               int other_to = mp_it->first.second;
+               if ((from >= other_from && from < other_to) ||
+                   (to >= other_from && to < other_to)) {
+                       fprintf(stderr, "WARNING: Mark pool %d-%d partially overlaps with %d-%d, you may get duplicate marks.\n",
+                               from, to, other_from, other_to);
+                       fprintf(stderr, "         Mark pools must either be completely disjunct, or completely overlapping.\n");
+               }
+       }       
+
+       MarkPool *mark_pool = new MarkPool(from, to);
+       mark_pools->insert(make_pair(mark_range, mark_pool));
+       return mark_pool;
+}
 
 int main(int argc, char **argv)
 {
@@ -270,6 +298,7 @@ int main(int argc, char **argv)
 
        servers = new ServerPool(num_servers);
 
+       CubemapStateProto loaded_state;
        int server_sock = -1, old_port = -1;
        set<string> deserialized_stream_ids;
        map<string, Input *> deserialized_inputs;
@@ -278,7 +307,7 @@ int main(int argc, char **argv)
 
                fprintf(stderr, "Deserializing state from previous process... ");
                int state_fd = atoi(argv[3]);
-               CubemapStateProto loaded_state = read_tempfile(state_fd);
+               loaded_state = read_tempfile(state_fd);
 
                serialize_start.tv_sec = loaded_state.serialize_start_sec();
                serialize_start.tv_usec = loaded_state.serialize_start_usec();
@@ -289,12 +318,6 @@ int main(int argc, char **argv)
                        deserialized_stream_ids.insert(loaded_state.streams(i).stream_id());
                }
 
-               // Put back the existing clients. It doesn't matter which server we
-               // allocate them to, so just do round-robin.
-               for (int i = 0; i < loaded_state.clients_size(); ++i) {
-                       servers->add_client_from_serialized(loaded_state.clients(i));
-               }
-
                // Deserialize the inputs. Note that we don't actually add them to any state yet.
                for (int i = 0; i < loaded_state.inputs_size(); ++i) {
                        deserialized_inputs.insert(make_pair(
@@ -311,6 +334,7 @@ int main(int argc, char **argv)
 
        // Find all streams in the configuration file, and create them.
        set<string> expecting_stream_ids = deserialized_stream_ids;
+       map<pair<int, int>, MarkPool *> mark_pools;
        for (unsigned i = 0; i < config.size(); ++i) {
                if (config[i].keyword != "stream") {
                        continue;
@@ -324,6 +348,31 @@ int main(int argc, char **argv)
                        servers->add_stream(stream_id);
                }
                expecting_stream_ids.erase(stream_id);
+
+               // Set up marks, if so desired.
+               if (config[i].parameters.count("mark")) {
+                       string mark_str = config[i].parameters["mark"];
+                       size_t split = mark_str.find_first_of('-');
+                       if (split == string::npos) {
+                               fprintf(stderr, "WARNING: Invalid mark specification '%s' (expected 'X-Y'), ignoring.\n",
+                                       mark_str.c_str());
+                               continue;
+                       }
+
+                       string from_str(mark_str.begin(), mark_str.begin() + split);
+                       string to_str(mark_str.begin() + split + 1, mark_str.end());
+                       int from = atoi(from_str.c_str());
+                       int to = atoi(to_str.c_str());
+
+                       if (from <= 0 || from >= 65536 || to <= 0 || to >= 65536) {
+                               fprintf(stderr, "WARNING: Mark pool range %d-%d is outside legal range [1,65536>, ignoring.\n",
+                                       from, to);
+                               continue;
+                       }
+
+                       MarkPool *mark_pool = get_mark_pool(&mark_pools, from, to);
+                       servers->set_mark_pool(stream_id, mark_pool);
+               }
        }
 
        // Warn about any servers we've lost.
@@ -396,6 +445,15 @@ int main(int argc, char **argv)
                input->run();
                inputs.push_back(input);
        }
+       
+       if (is_reexec) {        
+               // Put back the existing clients. It doesn't matter which server we
+               // allocate them to, so just do round-robin. However, we need to add
+               // them after the mark pools have been set up.
+               for (int i = 0; i < loaded_state.clients_size(); ++i) {
+                       servers->add_client_from_serialized(loaded_state.clients(i));
+               }
+       }
 
        // All deserialized inputs should now have been taken care of, one way or the other.
        assert(deserialized_inputs.empty());