Parse the HTTP header (more) properly, and send the headers on to any connecting...

[cubemap] / server.h

diff --git a/server.h b/server.h
index d87e7dfab0d8dd9a08423b7b2c47b998e2b277a2..5ebc060e10924e88c675f695fe6caefcb8cd520b 100644 (file)
--- a/server.h
+++ b/server.h
@@ -106,20 +106,43 @@ public:
        // Stop the thread.
        void stop();
 
-       CubemapStateProto serialize() const;
+       // Set header (both HTTP header and any stream headers) for the given stream.
+       void set_header(const std::string &stream_id, const std::string &header);
 
-       void add_client(int sock);
-       void add_client_from_serialized(const ClientProto &client);
+       // These will be deferred until the next time an iteration in do_work() happens,
+       // and the order between them are undefined.
+       // XXX: header should ideally be ordered with respect to data.
+       void add_client_deferred(int sock);
+       void add_data_deferred(const std::string &stream_id, const char *data, size_t bytes);
 
+       // These should not be called while running, since that would violate
+       // threading assumptions (ie., that epoll is only called from one thread
+       // at the same time).
+       CubemapStateProto serialize();
+       void add_client_from_serialized(const ClientProto &client);
        void add_stream(const std::string &stream_id);
        void add_stream_from_serialized(const StreamProto &stream);
 
-       void set_header(const std::string &stream_id, const std::string &header);
-       void add_data(const std::string &stream_id, const char *data, size_t bytes);
-
 private:
        pthread_t worker_thread;
 
+       // Mutex protecting queued_data only. Note that if you want to hold both this
+       // and <mutex> below, you will need to take <mutex> before this one.
+       pthread_mutex_t queued_data_mutex;
+
+       // Deferred commands that should be run from the do_work() thread as soon as possible.
+       // We defer these for two reasons:
+       //
+       //  - We only want to fiddle with epoll from one thread at any given time,
+       //    and doing add_client() from the acceptor thread would violate that.
+       //  - We don't want the input thread(s) hanging on <mutex> when doing
+       //    add_data(), since they want to do add_data() rather often, and <mutex>
+       //    can be taken a lot of the time.
+       //      
+       // Protected by <queued_data_mutex>.
+       std::vector<int> queued_add_clients;
+       std::map<std::string, std::string> queued_data;
+
        // All variables below this line are protected by the mutex.
        pthread_mutex_t mutex;
 
@@ -173,6 +196,11 @@ private:
 
        // TODO: This function should probably die.
        Stream *find_stream(const std::string &stream_id);
+
+       void process_queued_data();
+
+       void add_client(int sock);
+       void add_data(const std::string &stream_id, const char *data, size_t bytes);
 };
 
 #endif  // !defined(_SERVER_H)