#include "accesslog.h"
#include "log.h"
-#include "markpool.h"
-#include "metacube.h"
+#include "metacube2.h"
#include "mutexlock.h"
#include "parse.h"
#include "server.h"
#include "stream.h"
#include "util.h"
+#ifndef SO_MAX_PACING_RATE
+#define SO_MAX_PACING_RATE 47
+#endif
+
using namespace std;
extern AccessLogThread *access_log;
Server::Server()
{
pthread_mutex_init(&mutex, NULL);
- pthread_mutex_init(&queued_data_mutex, NULL);
+ pthread_mutex_init(&queued_clients_mutex, NULL);
epoll_fd = epoll_create(1024); // Size argument is ignored.
if (epoll_fd == -1) {
void Server::add_client_deferred(int sock)
{
- MutexLock lock(&queued_data_mutex);
+ MutexLock lock(&queued_clients_mutex);
queued_add_clients.push_back(sock);
}
assert(stream_index >= 0 && stream_index < ssize_t(streams.size()));
streams[stream_index]->http_header = http_header;
streams[stream_index]->stream_header = stream_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<int, Client>::iterator client_it = clients.begin();
- client_it != clients.end();
- ++client_it) {
- Client *client = &client_it->second;
- if (client->state == Client::SENDING_DATA &&
- client->stream_pos == 0) {
- construct_header(client);
- }
- }
}
-void Server::set_mark_pool(int stream_index, MarkPool *mark_pool)
+void Server::set_pacing_rate(int stream_index, uint32_t pacing_rate)
{
MutexLock lock(&mutex);
assert(clients.empty());
assert(stream_index >= 0 && stream_index < ssize_t(streams.size()));
- streams[stream_index]->mark_pool = mark_pool;
+ streams[stream_index]->pacing_rate = pacing_rate;
}
void Server::add_data_deferred(int stream_index, const char *data, size_t bytes, StreamStartSuitability suitable_for_stream_start)
{
- MutexLock lock(&queued_data_mutex);
assert(stream_index >= 0 && stream_index < ssize_t(streams.size()));
streams[stream_index]->add_data_deferred(data, bytes, suitable_for_stream_start);
}
ssize_t ret;
do {
- loff_t offset = client->stream_pos % stream->backlog_size;
+ off_t offset = client->stream_pos % stream->backlog_size;
ret = sendfile(client->sock, stream->data_fd, &offset, bytes_to_send);
} while (ret == -1 && errno == EINTR);
void Server::skip_lost_data(Client *client)
{
Stream *stream = client->stream;
+ if (stream == NULL) {
+ return;
+ }
size_t bytes_to_send = stream->bytes_received - client->stream_pos;
if (bytes_to_send > stream->backlog_size) {
size_t bytes_lost = bytes_to_send - stream->backlog_size;
client->stream_pos = stream->bytes_received - stream->backlog_size;
client->bytes_lost += bytes_lost;
++client->num_loss_events;
-
- double loss_fraction = double(client->bytes_lost) / double(client->bytes_lost + client->bytes_sent);
- log(WARNING, "[%s] Client lost %lld bytes (total loss: %.2f%%), maybe too slow connection",
- client->remote_addr.c_str(),
- (long long int)(bytes_lost),
- 100.0 * loss_fraction);
}
}
return 404; // Not found.
}
- client->url = request_tokens[1];
- client->stream = streams[url_map_it->second];
- if (client->stream->mark_pool != NULL) {
- client->fwmark = client->stream->mark_pool->get_mark();
- } else {
- client->fwmark = 0; // No mark.
+ Stream *stream = streams[url_map_it->second];
+ if (stream->http_header.empty()) {
+ return 503; // Service unavailable.
}
- if (setsockopt(client->sock, SOL_SOCKET, SO_MARK, &client->fwmark, sizeof(client->fwmark)) == -1) {
- if (client->fwmark != 0) {
- log_perror("setsockopt(SO_MARK)");
+
+ client->url = request_tokens[1];
+ client->stream = stream;
+ if (setsockopt(client->sock, SOL_SOCKET, SO_MAX_PACING_RATE, &client->stream->pacing_rate, sizeof(client->stream->pacing_rate)) == -1) {
+ if (client->stream->pacing_rate != ~0U) {
+ log_perror("setsockopt(SO_MAX_PACING_RATE)");
}
}
client->request.clear();
"Content-encoding: metacube\r\n" +
"\r\n";
if (!stream->stream_header.empty()) {
- metacube_block_header hdr;
- memcpy(hdr.sync, METACUBE_SYNC, sizeof(hdr.sync));
+ metacube2_block_header hdr;
+ memcpy(hdr.sync, METACUBE2_SYNC, sizeof(hdr.sync));
hdr.size = htonl(stream->stream_header.size());
- hdr.flags = htonl(METACUBE_FLAGS_HEADER);
+ hdr.flags = htons(METACUBE_FLAGS_HEADER);
+ hdr.csum = htons(metacube2_compute_crc(&hdr));
client->header_or_error.append(
string(reinterpret_cast<char *>(&hdr), sizeof(hdr)));
}
if (client->stream != NULL) {
delete_from(&client->stream->sleeping_clients, client);
delete_from(&client->stream->to_process, client);
- if (client->stream->mark_pool != NULL) {
- int fwmark = client->fwmark;
- client->stream->mark_pool->release_mark(fwmark);
- }
}
// Log to access_log.
void Server::process_queued_data()
{
- MutexLock lock(&queued_data_mutex);
+ {
+ MutexLock lock(&queued_clients_mutex);
- for (size_t i = 0; i < queued_add_clients.size(); ++i) {
- add_client(queued_add_clients[i]);
+ for (size_t i = 0; i < queued_add_clients.size(); ++i) {
+ add_client(queued_add_clients[i]);
+ }
+ queued_add_clients.clear();
}
- queued_add_clients.clear();
for (size_t i = 0; i < streams.size(); ++i) {
streams[i]->process_queued_data();