X-Git-Url: https://git.sesse.net/?p=cubemap;a=blobdiff_plain;f=server.cpp;h=5f155c0a699a7723fc0aac09083de1df2eb78aee;hp=25da16cba4c341e0c07b8d06eb4239a63a0f476c;hb=1a6917f77ba35d5397e887a554354a3e49458eb9;hpb=cfe0df3728d8155fb03688f6db69e00971e23685 diff --git a/server.cpp b/server.cpp index 25da16c..5f155c0 100644 --- a/server.cpp +++ b/server.cpp @@ -13,13 +13,81 @@ #include #include #include +#include #include "metacube.h" #include "server.h" #include "mutexlock.h" +#include "state.pb.h" using namespace std; +Client::Client(int sock) + : sock(sock), + state(Client::READING_REQUEST), + header_bytes_sent(0), + bytes_sent(0) +{ + request.reserve(1024); +} + +Client::Client(const ClientProto &serialized) + : sock(serialized.sock()), + state(State(serialized.state())), + request(serialized.request()), + stream_id(serialized.stream_id()), + header(serialized.header()), + header_bytes_sent(serialized.header_bytes_sent()), + bytes_sent(serialized.bytes_sent()) +{ +} + +ClientProto Client::serialize() const +{ + ClientProto serialized; + serialized.set_sock(sock); + serialized.set_state(state); + serialized.set_request(request); + serialized.set_stream_id(stream_id); + serialized.set_header(header); + serialized.set_header_bytes_sent(serialized.header_bytes_sent()); + serialized.set_bytes_sent(bytes_sent); + return serialized; +} + +Stream::Stream(const string &stream_id) + : stream_id(stream_id), + data(new char[BACKLOG_SIZE]), + data_size(0) +{ + memset(data, 0, BACKLOG_SIZE); +} + +Stream::~Stream() +{ + delete[] data; +} + +Stream::Stream(const StreamProto &serialized) + : stream_id(serialized.stream_id()), + header(serialized.header()), + data(new char[BACKLOG_SIZE]), + data_size(serialized.data_size()) +{ + assert(serialized.data().size() == BACKLOG_SIZE); + memcpy(data, serialized.data().data(), BACKLOG_SIZE); +} + +StreamProto Stream::serialize() const +{ + StreamProto serialized; + serialized.set_header(header); + serialized.set_data(string(data, data + BACKLOG_SIZE)); + serialized.set_data_size(data_size); + serialized.set_stream_id(stream_id); + return serialized; +} + Server::Server() { pthread_mutex_init(&mutex, NULL); @@ -31,10 +99,33 @@ Server::Server() } } +Server::~Server() +{ + close(epoll_fd); +} + void Server::run() { - pthread_t thread; - pthread_create(&thread, NULL, Server::do_work_thunk, this); + should_stop = false; + + // Joinable is already the default, but it's good to be certain. + pthread_attr_t attr; + pthread_attr_init(&attr); + pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); + pthread_create(&worker_thread, &attr, Server::do_work_thunk, this); +} + +void Server::stop() +{ + { + MutexLock lock(&mutex); + should_stop = true; + } + + if (pthread_join(worker_thread, NULL) == -1) { + perror("pthread_join"); + exit(1); + } } void *Server::do_work_thunk(void *arg) @@ -48,13 +139,17 @@ void Server::do_work() { for ( ;; ) { int nfds = epoll_wait(epoll_fd, events, EPOLL_MAX_EVENTS, EPOLL_TIMEOUT_MS); - - MutexLock lock(&mutex); // We release the mutex between iterations. if (nfds == -1) { perror("epoll_wait"); exit(1); } - + + MutexLock lock(&mutex); // We release the mutex between iterations. + + if (should_stop) { + return; + } + for (int i = 0; i < nfds; ++i) { int fd = events[i].data.fd; assert(clients.count(fd) != 0); @@ -69,43 +164,112 @@ void Server::do_work() } } } - + +CubemapStateProto Server::serialize() const +{ + CubemapStateProto serialized; + for (map::const_iterator client_it = clients.begin(); + client_it != clients.end(); + ++client_it) { + serialized.add_clients()->MergeFrom(client_it->second.serialize()); + } + for (map::const_iterator stream_it = streams.begin(); + stream_it != streams.end(); + ++stream_it) { + serialized.add_streams()->MergeFrom(stream_it->second->serialize()); + } + return serialized; +} + void Server::add_client(int sock) { MutexLock lock(&mutex); - Client new_client; - new_client.sock = sock; - new_client.client_request.reserve(1024); - new_client.state = Client::READING_REQUEST; - new_client.header_bytes_sent = 0; - new_client.bytes_sent = 0; - - clients.insert(make_pair(sock, new_client)); + clients.insert(make_pair(sock, Client(sock))); // Start listening on data from this socket. epoll_event ev; ev.events = EPOLLIN | EPOLLRDHUP; + ev.data.u64 = 0; // Keep Valgrind happy. ev.data.fd = sock; if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sock, &ev) == -1) { perror("epoll_ctl(EPOLL_CTL_ADD)"); exit(1); } } - + +void Server::add_client_from_serialized(const ClientProto &client) +{ + MutexLock lock(&mutex); + clients.insert(make_pair(client.sock(), Client(client))); + + // Start listening on data from this socket. + epoll_event ev; + if (client.state() == Client::READING_REQUEST) { + ev.events = EPOLLIN | EPOLLRDHUP; + } else { + // If we don't have more data for this client, we'll be putting it into + // the sleeping array again soon. + ev.events = EPOLLOUT | EPOLLRDHUP; + } + ev.data.u64 = 0; // Keep Valgrind happy. + ev.data.fd = client.sock(); + if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client.sock(), &ev) == -1) { + perror("epoll_ctl(EPOLL_CTL_ADD)"); + exit(1); + } +} + void Server::add_stream(const string &stream_id) { - // TODO + MutexLock lock(&mutex); + streams.insert(make_pair(stream_id, new Stream(stream_id))); +} + +void Server::add_stream_from_serialized(const StreamProto &stream) +{ + MutexLock lock(&mutex); + streams.insert(make_pair(stream.stream_id(), new Stream(stream))); } void Server::set_header(const string &stream_id, const string &header) { - // TODO - printf("got header! %lu bytes\n", header.size()); + MutexLock lock(&mutex); + find_stream(stream_id)->header = header; + + // If there are clients we haven't sent anything to yet, we should give + // them the header, so push back into the SENDING_HEADER state. + for (map::iterator client_it = clients.begin(); + client_it != clients.end(); + ++client_it) { + Client *client = &client_it->second; + if (client->state == Client::SENDING_DATA && + client->bytes_sent == 0) { + construct_header(client); + } + } } void Server::add_data(const string &stream_id, const char *data, size_t bytes) { - // TODO + if (bytes == 0) { + return; + } + + MutexLock lock(&mutex); + Stream *stream = find_stream(stream_id); + size_t pos = stream->data_size % BACKLOG_SIZE; + stream->data_size += bytes; + + if (pos + bytes > BACKLOG_SIZE) { + size_t to_copy = BACKLOG_SIZE - pos; + memcpy(stream->data + pos, data, to_copy); + data += to_copy; + bytes -= to_copy; + pos = 0; + } + + memcpy(stream->data + pos, data, bytes); + wake_up_all_clients(); } void Server::process_client(Client *client) @@ -129,7 +293,7 @@ void Server::process_client(Client *client) } // Guard against overlong requests gobbling up all of our space. - if (client->client_request.size() + ret > MAX_CLIENT_REQUEST) { + if (client->request.size() + ret > MAX_CLIENT_REQUEST) { fprintf(stderr, "WARNING: fd %d sent overlong request!\n", client->sock); close_client(client); return; @@ -137,41 +301,129 @@ void Server::process_client(Client *client) // See if we have \r\n\r\n anywhere in the request. We start three bytes // before what we just appended, in case we just got the final character. - size_t existing_req_bytes = client->client_request.size(); - client->client_request.append(string(buf, buf + ret)); + size_t existing_req_bytes = client->request.size(); + client->request.append(string(buf, buf + ret)); size_t start_at = (existing_req_bytes >= 3 ? existing_req_bytes - 3 : 0); const char *ptr = reinterpret_cast( - memmem(client->client_request.data() + start_at, client->client_request.size() - start_at, + memmem(client->request.data() + start_at, client->request.size() - start_at, "\r\n\r\n", 4)); if (ptr == NULL) { // OK, we don't have the entire header yet. Fine; we'll get it later. return; } - if (ptr != client->client_request.data() + client->client_request.size() - 4) { + if (ptr != client->request.data() + client->request.size() - 4) { fprintf(stderr, "WARNING: fd %d had junk data after request!\n", client->sock); close_client(client); return; } - client->state = Client::SENDING_HEADER; + parse_request(client); + construct_header(client); + break; + } + case Client::SENDING_HEADER: { + int ret = write(client->sock, + client->header.data() + client->header_bytes_sent, + client->header.size() - client->header_bytes_sent); + if (ret == -1) { + perror("write"); + close_client(client); + return; + } + + client->header_bytes_sent += ret; + assert(client->header_bytes_sent <= client->header.size()); - epoll_event ev; - ev.events = EPOLLOUT | EPOLLRDHUP; - ev.data.fd = client->sock; + if (client->header_bytes_sent < client->header.size()) { + // We haven't sent all yet. Fine; we'll do that later. + return; + } - if (epoll_ctl(epoll_fd, EPOLL_CTL_MOD, client->sock, &ev) == -1) { - perror("epoll_ctl(EPOLL_CTL_MOD)"); - exit(1); + // We're done sending the header! Clear the entire header to release some memory. + client->header.clear(); + + // Start sending from the end. In other words, we won't send any of the backlog, + // but we'll start sending immediately as we get data. + client->state = Client::SENDING_DATA; + client->bytes_sent = find_stream(client->stream_id)->data_size; + break; + } + case Client::SENDING_DATA: { + // See if there's some data we've lost. Ideally, we should drop to a block boundary, + // but resync will be the mux's problem. + const Stream &stream = *find_stream(client->stream_id); + size_t bytes_to_send = stream.data_size - client->bytes_sent; + if (bytes_to_send > BACKLOG_SIZE) { + fprintf(stderr, "WARNING: fd %d lost %lld bytes, maybe too slow connection\n", + client->sock, + (long long int)(bytes_to_send - BACKLOG_SIZE)); + client->bytes_sent = find_stream(client->stream_id)->data_size - BACKLOG_SIZE; + bytes_to_send = BACKLOG_SIZE; + } + + // See if we need to split across the circular buffer. + ssize_t ret; + if ((client->bytes_sent % BACKLOG_SIZE) + bytes_to_send > BACKLOG_SIZE) { + size_t bytes_first_part = BACKLOG_SIZE - (client->bytes_sent % BACKLOG_SIZE); + + iovec iov[2]; + iov[0].iov_base = const_cast(stream.data + (client->bytes_sent % BACKLOG_SIZE)); + iov[0].iov_len = bytes_first_part; + + iov[1].iov_base = const_cast(stream.data); + iov[1].iov_len = bytes_to_send - bytes_first_part; + + ret = writev(client->sock, iov, 2); + } else { + ret = write(client->sock, + stream.data + (client->bytes_sent % BACKLOG_SIZE), + bytes_to_send); + } + if (ret == -1) { + perror("write/writev"); + close_client(client); + return; + } + client->bytes_sent += ret; + + if (client->bytes_sent == stream.data_size) { + // We don't have any more data for this client, so put it to sleep. + put_client_to_sleep(client); } break; } default: - // TODO assert(false); } } + +void Server::parse_request(Client *client) +{ + // TODO: Actually parse the request. :-) + client->stream_id = "stream"; + client->request.clear(); +} + +void Server::construct_header(Client *client) +{ + client->header = "HTTP/1.0 200 OK\r\nContent-type: video/x-flv\r\nCache-Control: no-cache\r\n\r\n" + + find_stream(client->stream_id)->header; + + // Switch states. + client->state = Client::SENDING_HEADER; + + epoll_event ev; + ev.events = EPOLLOUT | EPOLLRDHUP; + ev.data.u64 = 0; // Keep Valgrind happy. + ev.data.fd = client->sock; + + if (epoll_ctl(epoll_fd, EPOLL_CTL_MOD, client->sock, &ev) == -1) { + perror("epoll_ctl(EPOLL_CTL_MOD)"); + exit(1); + } +} void Server::close_client(Client *client) { @@ -179,8 +431,50 @@ void Server::close_client(Client *client) perror("epoll_ctl(EPOLL_CTL_DEL)"); exit(1); } + + // This client could be sleeping, so we'll need to fix that. (Argh, O(n).) + vector::iterator new_end = + remove(sleeping_clients.begin(), sleeping_clients.end(), client->sock); + sleeping_clients.erase(new_end, sleeping_clients.end()); // Bye-bye! close(client->sock); clients.erase(client->sock); } + +void Server::put_client_to_sleep(Client *client) +{ + epoll_event ev; + ev.events = EPOLLRDHUP; + ev.data.u64 = 0; // Keep Valgrind happy. + ev.data.fd = client->sock; + + if (epoll_ctl(epoll_fd, EPOLL_CTL_MOD, client->sock, &ev) == -1) { + perror("epoll_ctl(EPOLL_CTL_MOD)"); + exit(1); + } + + sleeping_clients.push_back(client->sock); +} + +void Server::wake_up_all_clients() +{ + for (unsigned i = 0; i < sleeping_clients.size(); ++i) { + epoll_event ev; + ev.events = EPOLLOUT | EPOLLRDHUP; + ev.data.u64 = 0; // Keep Valgrind happy. + ev.data.fd = sleeping_clients[i]; + if (epoll_ctl(epoll_fd, EPOLL_CTL_MOD, sleeping_clients[i], &ev) == -1) { + perror("epoll_ctl(EPOLL_CTL_MOD)"); + exit(1); + } + } + sleeping_clients.clear(); +} + +Stream *Server::find_stream(const string &stream_id) +{ + map::iterator it = streams.find(stream_id); + assert(it != streams.end()); + return it->second; +}