When create_input() fails, give an error message instead of crashing.

Do not keep pending data across HTTP connections.

More support for multiple input types.

Move version identification into a common place.

Make Input a bit more generic, to pave the way for UDP.

Support multiple listening sockets. Actually mostly because it makes the code somewhat more regular.

Move stopping into ServerPool.

Factor serializing into its own function. Again, less stuff in main().

Move stream creation out of main().

Some small refactoring of main().

Factor all the common thread starting/stopping into a common Thread class.

Minor nit.

Wrap the acceptor into the same thread logic as everything else.

Merge branch 'master' of /srv/git.sesse.net/www/cubemap

Factor statistics writing into its own class and file.

Small refactoring in main.cpp.

Factor statistics writing into its own class and file.

Separate out the acceptor stuff into its own file.

Add support for setting fwmarks per-connection. Useful for shaping individual streams (for doing TCP pacing).

Remove some obsolete #defines.

Explicitly SIGHUP threads to kill them out of syscalls when we want to join them. Also fixes some bugs related to EINTR handling, since they became very obvious now.

Measure how long the serialize/exec/deserialize process takes.

Support writing a stats file listing the number of clients currently connected.

Rename cubemap.cpp to main.cpp. Aaaa....

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

Deserialize/serialize inputs. Woo, totally glitch-free restarts!

Fix a few issues in the to_process() handling.

Add URL parsing.

Write our own HTTP client instead of using curl. Not finished yet (missing URL parsing, for one).

Make most operations on Server deferred, so that we a) do not get bugs with epoll going out-of-sync with the client state, and b) do not get performance issues stemming from Input not managing to push data often enough to the servers.

Make the acceptor thread stop nicely, so that it does not try to mess up the server while we are shutting down  the server.

Make the list of sleeping clients be per-stream instead of global, so we do not wake up tons of clients for no good reason.

If accept() fails, do not take down the entire thing; it could be a transient error like “too many open files”. Instead, sleep 0.1 seconds and try again.

Fix so clients would actually be woken up from the worker thread, not the input thread. (Gah!)

Fix an error where clients in asleep state would hang after a HUP.

Make edge-triggering more consistent.

Remove some leftover code.

Fix an issue where clients would be put twice into sleeping_clients (probably since the EPOLLOUT trigger would go off once unexpectedly), causing a chain reaction where we did tons of empty write() calls.

Some fixes to issues that could cause client hangs.

Stop doing find_stream() every time we send out data; it takes some CPU.

Change from level-triggered to edge-triggered epoll mode. More than halves CPU usage.

Handle streams coming and going from the configuration file across restarts.

EINTR-protect a bunch of calls, and warn on close() failing.

Handle EINTR in epoll_wait().

Support parsing streams from config file. Also support multiple streams (includes parsing HTTP), with HTTP error messages and all.

When a transfer ends, output the URL.

Factor out some config parsing into its own function.

Add a sample configuration file.

Fetch num_servers from the config file.

Move the logic of load-balancing etc. into ServerPool, which frees external users from knowing anything about NUM_SERVERS.

Reopen the port if it changes between runs.

Take the port from the configuration file.

Parse a config file. Not used for anything yet.

Support deserialization of most state (curl input is not really good yet).

Remember to turn off has_metacube_header once we have consumed a block.

Make Input honor should_stop even when it is not connected to an encoder.

When we get a header, retroactively send it out to all clients that have received no data yet. Useful if the clients connect before the encoder does.

Makefile tweaks to deal with the protobuf dependency.

Reconnect when the input goes away.

Serialize and die on SIGHUP (no deserialization yet). Required a whole bunch of Valgrind fixes to actually work.

Fix broken Client constructor.

Start working on serialization.

Make a useful constructor for Client.

Fix the broken SO_REUSEADDR.

Make Server stoppable.

Merge remote-tracking branch 'origin/master'

Rename client_request to request, and clear it when we are done with it.

Rename client_request to request, and clear it when we are done with it.

Remove a no longer relevant TODO.

When closing a client, make sure it is not left in sleeping_clients.

Implement writev(). Working reflector!

Implement sleeping/waking clients.

Implement add_data().

Implement basic data sending support.

Skip the Metacube header when adding data.

Implement header sending.

Implement epoll main loop in Server, and parse header.

Set SO_REUSEADDR on the server socket.

Split Input into its own file.

Split Server and MutexLock out into separate source files.

Piece a lot more stuff together.

Add a Makefile.

Fire off worker threads (that do nothing right now).

Make a mutex locker.

Open a server socket, and listen on it.

Start adding scaffolds for most of the basic classes.

gitignore the binary.

Remove remux.cpp, which seems to be irrelevant.

Initial checkin.