// Copyright (C) 2003 Davis E. King (davis@dlib.net)
// License: Boost Software License See LICENSE.txt for the full license.
#ifndef DLIB_SERVER_KERNEL_1_
#define DLIB_SERVER_KERNEL_1_
#include "server_kernel_abstract.h"
#include <memory>
#include <string>
#include "../threads.h"
#include "../sockets.h"
#include "../algs.h"
#include "../set.h"
#include "../logger.h"
namespace dlib
{
// These forward declarations are here so we can use them in the typedefs in the server
// class. The reason for this is for backwards compatibility with previous versions of
// dlib.
class server_http;
class server_iostream;
class server
{
/*!
INITIAL VALUE
listening_port == 0
listening_ip == ""
running == false
shutting_down == false
cons.size() == 0
listening_port_mutex == a mutex
listening_ip_mutex == a mutex
running_mutex == a mutex
running_signaler == a signaler associated with running_mutex
shutting_down_mutex == a mutex
cons_mutex == a mutex
thread_count == 0
thread_count_mutex == a mutex
thread_count_signaler == a signaler associated with thread_count_mutex
thread_count_zero == a signaler associated with thread_count_mutex
max_connections == 1000
max_connections_mutex == a mutex for max_connections and graceful_close_timeout
graceful_close_timeout == 500
CONVENTION
listening_port == get_listening_port()
listening_ip == get_listening_ip()
running == is_running()
shutting_down == true while clear() is running. this
bool is used to tell the thread blocked on
accept that it should terminate
cons == a set containing all open connections
listening_port_mutex == a mutex for listening_port
listening_ip_mutex == a mutex for listening_ip
running_mutex == a mutex for running
running_signaler == a signaler for running and
is associated with running_mutex. it is
used to signal when running is false
shutting_down_mutex == a mutex for shutting_down
cons_mutex == a mutex for cons
thread_count == the number of threads currently running
thread_count_mutex == a mutex for thread_count
thread_count_signaler == a signaler for thread_count and
is associated with thread_count_mutex. it
is used to signal when thread_count is
decremented
thread_count_zero == a signaler for thread_count and
is associated with thread_count_mutex. it
is used to signal when thread_count becomes
zero
max_connections == get_max_connections()
max_connections_mutex == a mutex for max_connections
!*/
typedef set<connection*>::kernel_1a set_of_connections;
// this structure is used to pass parameters to new threads
struct param
{
param (
server& server_,
connection& new_connection_,
unsigned long graceful_close_timeout_
) :
the_server(server_),
new_connection(new_connection_),
graceful_close_timeout(graceful_close_timeout_)
{}
server& the_server;
connection& new_connection;
unsigned long graceful_close_timeout;
};
public:
// These typedefs are here for backward compatibility with previous versions of dlib
typedef server kernel_1a;
typedef server kernel_1a_c;
typedef server_iostream iostream_1a;
typedef server_iostream iostream_1a_c;
typedef server_http http_1a;
typedef server_http http_1a_c;
server(
);
virtual ~server(
);
void clear(
);
void start (
);
bool is_running (
) const;
const std::string get_listening_ip (
) const;
int get_listening_port (
) const;
void set_listening_port (
int port
);
void set_listening_ip (
const std::string& ip
);
void set_max_connections (
int max
);
int get_max_connections (
) const;
void start_async (
);
void set_graceful_close_timeout (
unsigned long timeout
);
unsigned long get_graceful_close_timeout (
) const;
private:
void start_async_helper (
);
void start_accepting_connections (
);
void open_listening_socket (
);
virtual void on_connect (
connection& new_connection
)=0;
virtual void on_listening_port_assigned (
) {}
const static logger sdlog;
static void service_connection(
void* item
);
/*!
requires
item is a pointer to a param struct
ensures
services the new connection
will take care of closing the connection and
adding the connection to cons when it first starts and
remove the connection from cons and signal that it has
done so when it ends
!*/
// data members
int listening_port;
std::string listening_ip;
bool running;
bool shutting_down;
set_of_connections cons;
mutex listening_port_mutex;
mutex listening_ip_mutex;
rmutex running_mutex;
rsignaler running_signaler;
mutex shutting_down_mutex;
mutex cons_mutex;
int thread_count;
mutex thread_count_mutex;
signaler thread_count_signaler;
int max_connections;
mutex max_connections_mutex;
signaler thread_count_zero;
std::unique_ptr<thread_function> async_start_thread;
std::unique_ptr<listener> sock;
unsigned long graceful_close_timeout;
// restricted functions
server(server&);
server& operator= (
server&
);
};
// ----------------------------------------------------------------------------------------
}
#ifdef NO_MAKEFILE
#include "server_kernel.cpp"
#endif
#endif // DLIB_SERVER_KERNEL_1_