server.h

Go to the documentation of this file.

#ifndef KEEL_SERVER_H
#define KEEL_SERVER_H
 
#include <keel/allocator.h>
#include <keel/compress.h>
#include <keel/error.h>
#include <keel/parser.h>
#include <keel/router.h>
#include <keel/tls.h>
#include <keel/h2_server.h>
#include <keel/connection.h>
#include <keel/event_ctx.h>
#include <stdarg.h>
#include <stdatomic.h>
#include <stdint.h>
 
typedef struct KlWsServerConfig KlWsServerConfig;
typedef KlParser *(*KlParserFactory)(KlAllocator *alloc);
 
typedef void (*KlAccessLogFn)(const KlRequest *req, int status,
                               size_t body_bytes, double duration_ms,
                               void *user_data);
 
#define KL_LOG_TRACE 0  
#define KL_LOG_DEBUG 1  
#define KL_LOG_INFO  2  
#define KL_LOG_WARN  3  
#define KL_LOG_ERROR 4  
#define KL_LOG_FATAL 5  
typedef void (*KlLogFn)(int level, const char *fmt, va_list ap,
                         void *user_data);
 
#define KL_DEFAULT_MAX_CONNS      256
#define KL_DEFAULT_READ_TIMEOUT   30000           
#define KL_DEFAULT_MAX_BODY_SIZE  (1024 * 1024)   
typedef struct KlConfig {
    int port;
    const char *bind_addr;      
    int max_connections;        
    int read_timeout_ms;        
    int body_timeout_ms;        
    KlAllocator *alloc;         
    KlParserFactory parser;     
    KlAccessLogFn access_log;   
    void *access_log_data;      
    KlLogFn log_fn;             
    void   *log_user_data;
    int install_signal_handlers; 
    int drain_timeout_ms;        
    KlTlsConfig *tls;           
    KlH2ServerConfig *h2;             
    size_t max_body_size;       
    size_t max_header_size;     
    KlCompressConfig *compress; 
} KlConfig;
 
typedef struct KlAsyncOp KlAsyncOp;
 
typedef struct KlServer {
    KlConfig config;
    KlAllocator alloc_storage;  
    KlTlsConfig tls_storage;   
    KlH2ServerConfig h2_storage;     
    KlCompressConfig compress_storage; 
    KlRouter router;            
    KlConnPool pool;            
    KlEventCtx ev;              
    int listen_fd;              
    int bound_port;             
    int listen_paused;          
    _Atomic int running;        
    _Atomic int draining;       
    uint64_t drain_deadline_ms; 
    KlAsyncOp *async_ops;       
    KlFileIO *file_io;          
    KlError last_error;         
} KlServer;
 
int  kl_server_init(KlServer *s, const KlConfig *config);
 
int  kl_server_route(KlServer *s, const char *method, const char *pattern,
                     KlHandler handler, void *user_data,
                     KlBodyReaderFactory body_reader);
 
int  kl_server_use(KlServer *s, const char *method, const char *pattern,
                   KlMiddleware fn, void *user_data);
 
int  kl_server_use_post(KlServer *s, const char *method, const char *pattern,
                        KlMiddleware fn, void *user_data);
 
int  kl_server_ws(KlServer *s, const char *pattern, KlWsServerConfig *config);
 
int  kl_server_run(KlServer *s);
 
void kl_server_stop(KlServer *s);
 
void kl_server_free(KlServer *s);
 
typedef struct {
    int active_connections;    
    int max_connections;       
    int async_suspended;       
    int listen_paused;         
} KlServerStats;
 
void kl_server_stats(const KlServer *s, KlServerStats *out);
 
#endif