csilk.h

Go to the documentation of this file.

 
#ifndef CSILK_H
#define CSILK_H
 
#include <setjmp.h>
#include <stddef.h>
#include <stdint.h>
#include <uv.h>
 
#include "cJSON.h"
 
/* Forward declarations to break circular dependency:
   csilk/drivers/db.h includes csilk.h, so types defined in db.h
   must be forward-declared here before the include. */
typedef struct csilk_db_pool_s csilk_db_pool_t;
 
#include "csilk/drivers/ai.h"
#include "csilk/drivers/cipher.h"
#include "csilk/drivers/db.h"
#include "csilk/drivers/perm.h"
#include "csilk/reflection/reflect.h"
 
#define CSILK_VERSION "0.2.3"
 
#define CSILK_MAX_PARAMS 20
 
#define CSILK_MAX_STORAGE 64
 
#define CSILK_STATUS_CONTINUE 100
#define CSILK_STATUS_SWITCHING_PROTOCOLS 101
#define CSILK_STATUS_OK 200
#define CSILK_STATUS_CREATED 201
#define CSILK_STATUS_NO_CONTENT 204
#define CSILK_STATUS_PARTIAL_CONTENT 206
#define CSILK_STATUS_MOVED_PERMANENTLY 301
#define CSILK_STATUS_FOUND 302
#define CSILK_STATUS_NOT_MODIFIED 304
#define CSILK_STATUS_TEMPORARY_REDIRECT 307
#define CSILK_STATUS_BAD_REQUEST 400
#define CSILK_STATUS_UNAUTHORIZED 401
#define CSILK_STATUS_PAYMENT_REQUIRED 402
#define CSILK_STATUS_FORBIDDEN 403
#define CSILK_STATUS_NOT_FOUND 404
#define CSILK_STATUS_METHOD_NOT_ALLOWED 405
#define CSILK_STATUS_REQUEST_TIMEOUT 408
#define CSILK_STATUS_CONFLICT 409
#define CSILK_STATUS_GONE 410
#define CSILK_STATUS_PAYLOAD_TOO_LARGE 413
#define CSILK_STATUS_RANGE_NOT_SATISFIABLE 416
#define CSILK_STATUS_URI_TOO_LONG 414
#define CSILK_STATUS_UNSUPPORTED_MEDIA_TYPE 415
#define CSILK_STATUS_TOO_MANY_REQUESTS 429
#define CSILK_STATUS_INTERNAL_SERVER_ERROR 500
#define CSILK_STATUS_NOT_IMPLEMENTED 501
#define CSILK_STATUS_BAD_GATEWAY 502
#define CSILK_STATUS_SERVICE_UNAVAILABLE 503
#define CSILK_STATUS_GATEWAY_TIMEOUT 504
typedef struct csilk_ctx_s csilk_ctx_t;
 
typedef struct {
    void (*set)(csilk_ctx_t* c, const char* key, void* value);
    void* (*get)(csilk_ctx_t* c, const char* key);
    void (*clear)(csilk_ctx_t* c);
} csilk_storage_driver_t;
 
typedef void (*csilk_handler_t)(csilk_ctx_t* c);
 
typedef struct csilk_header_s {
    char* key;    
    char* value;      
    size_t key_len;   
    size_t value_len; 
    struct csilk_header_s* next; 
} csilk_header_t;
 
#ifndef CSILK_HEADER_BUCKETS
#define CSILK_HEADER_BUCKETS 64
#endif
 
typedef struct csilk_header_map_s {
    csilk_header_t* buckets[CSILK_HEADER_BUCKETS]; 
} csilk_header_map_t;
 
typedef struct {
    char* method;    
    char* path;  
    char* body;  
    size_t body_len; 
    csilk_header_map_t headers;  
    csilk_header_map_t query_params; 
    csilk_header_map_t form_params;  
} csilk_request_t;
 
typedef struct {
    int status;         
    const char* body;       
    size_t body_len;        
    csilk_header_map_t headers; 
    int body_is_managed;        
} csilk_response_t;
 
typedef struct {
    char* key;   
    char* value; 
} csilk_param_t;
 
typedef struct csilk_arena_s csilk_arena_t;
 
const char* csilk_get_method(csilk_ctx_t* c);
 
const char* csilk_get_path(csilk_ctx_t* c);
 
const char* csilk_get_body(csilk_ctx_t* c, size_t* out_len);
 
size_t csilk_get_body_len(csilk_ctx_t* c);
 
int csilk_is_websocket(csilk_ctx_t* c);
 
void csilk_ws_join_room(csilk_ctx_t* c, const char* room_name);
 
void csilk_ws_leave_room(csilk_ctx_t* c, const char* room_name);
 
void csilk_ws_broadcast_room(csilk_ctx_t* c, const char* room_name, const char* message);
 
void csilk_set_websocket(csilk_ctx_t* c, int is_websocket);
 
int csilk_is_sse(csilk_ctx_t* c);
 
void csilk_set_sse(csilk_ctx_t* c, int is_sse);
 
int csilk_is_aborted(csilk_ctx_t* c);
 
void csilk_set_on_ws_message(
    csilk_ctx_t* c,
    void (*callback)(csilk_ctx_t* c, const uint8_t* payload, size_t len, int opcode));
 
void csilk_set_on_ws_send(
    csilk_ctx_t* c,
    void (*callback)(csilk_ctx_t* c, const uint8_t* payload, size_t len, int opcode));
 
void (*csilk_get_on_ws_message(csilk_ctx_t* c))(csilk_ctx_t* c,
                        const uint8_t* payload,
                        size_t len,
                        int opcode);
 
const char* csilk_get_request_id(csilk_ctx_t* c);
 
csilk_arena_t* csilk_get_arena(csilk_ctx_t* c);
 
int csilk_get_status(csilk_ctx_t* c);
 
void csilk_set_async(csilk_ctx_t* c, int is_async);
 
int csilk_is_async(csilk_ctx_t* c);
 
int csilk_get_handler_index(csilk_ctx_t* c);
 
void csilk_set_request_id(csilk_ctx_t* c, const char* id);
 
uv_work_t* csilk_get_work_req(csilk_ctx_t* c);
 
void csilk_set_file_response(csilk_ctx_t* c, int fd, size_t offset, size_t size);
 
int csilk_get_file_fd(csilk_ctx_t* c);
 
const char* csilk_ctx_get_handler_path(csilk_ctx_t* c);
 
const char* csilk_ctx_get_handler_perm_required(csilk_ctx_t* c);
 
const char* csilk_ctx_get_handler_perm_resource(csilk_ctx_t* c);
 
void csilk_set_response_body(csilk_ctx_t* c, const char* body, size_t len, int managed);
 
const char* csilk_get_response_body(csilk_ctx_t* c, size_t* out_len);
 
void csilk_redirect(csilk_ctx_t* c, int status, const char* location);
 
void csilk_redirect_simple(csilk_ctx_t* c, const char* url);
 
void csilk_set(csilk_ctx_t* c, const char* key, void* value);
 
void* csilk_get(csilk_ctx_t* c, const char* key);
 
void csilk_next(csilk_ctx_t* c);
 
void csilk_abort(csilk_ctx_t* c);
 
void csilk_status(csilk_ctx_t* c, int status);
 
void csilk_string(csilk_ctx_t* c, int status, const char* msg);
 
const char* csilk_get_param(csilk_ctx_t* c, const char* key);
 
int csilk_get_params_count(csilk_ctx_t* c);
 
const char* csilk_get_param_key(csilk_ctx_t* c, int index);
 
const char* csilk_get_param_value(csilk_ctx_t* c, int index);
 
const char* csilk_get_header(csilk_ctx_t* c, const char* key);
 
const char* csilk_get_response_header(csilk_ctx_t* c, const char* key);
 
const char* csilk_get_query(csilk_ctx_t* c, const char* key);
 
void csilk_parse_form_urlencoded(csilk_ctx_t* c);
 
const char* csilk_get_form_field(csilk_ctx_t* c, const char* key);
 
void csilk_set_request_header(csilk_ctx_t* c, const char* key, const char* value);
 
void csilk_set_header(csilk_ctx_t* c, const char* key, const char* value);
 
void csilk_add_header(csilk_ctx_t* c, const char* key, const char* value);
 
void csilk_ctx_cleanup(csilk_ctx_t* c);
 
csilk_arena_t* csilk_arena_new(size_t default_chunk_size);
 
void* csilk_arena_alloc(csilk_arena_t* arena, size_t size);
 
char* csilk_arena_strdup(csilk_arena_t* arena, const char* s);
 
char* csilk_arena_strndup(csilk_arena_t* arena, const char* s, size_t n);
 
void csilk_arena_free(csilk_arena_t* arena);
 
void csilk_arena_reset(csilk_arena_t* arena);
void csilk_arena_get_stats(csilk_arena_t* arena, size_t* total_size, size_t* total_used);
 
void csilk_recovery_handler(csilk_ctx_t* c);
 
void csilk_panic(csilk_ctx_t* c);
 
typedef enum {
    CSILK_LOG_TRACE, 
    CSILK_LOG_DEBUG, 
    CSILK_LOG_INFO,  
    CSILK_LOG_WARN,  
    CSILK_LOG_ERROR, 
    CSILK_LOG_FATAL  
} csilk_log_level_t;
 
typedef struct {
    csilk_log_level_t level; 
    const char* file_path;   
    size_t max_file_size;    
    int use_colors;      
    int json_format;     
} csilk_log_config_t;
 
int csilk_log_init(csilk_log_config_t config);
 
void _csilk_log_internal(
    csilk_log_level_t lv, const char* file, int line, const char* func, const char* fmt, ...);
 
void csilk_log_close();
 
void _csilk_log_structured(csilk_log_level_t lv,
               const char* file,
               int line,
               const char* func,
               cJSON* extra,
               const char* fmt,
               ...);
 
int csilk_log_is_json(void);
 
void csilk_log_set_request_id(const char* request_id);
 
cJSON* csilk_log_make_kv(const char* key, ...);
 
#define CSILK_LOG_T(...)                                                                           \
    _csilk_log_internal(CSILK_LOG_TRACE, __FILE__, __LINE__, __func__, __VA_ARGS__)
#define CSILK_LOG_D(...)                                                                           \
    _csilk_log_internal(CSILK_LOG_DEBUG, __FILE__, __LINE__, __func__, __VA_ARGS__)
#define CSILK_LOG_I(...)                                                                           \
    _csilk_log_internal(CSILK_LOG_INFO, __FILE__, __LINE__, __func__, __VA_ARGS__)
#define CSILK_LOG_W(...)                                                                           \
    _csilk_log_internal(CSILK_LOG_WARN, __FILE__, __LINE__, __func__, __VA_ARGS__)
#define CSILK_LOG_E(...)                                                                           \
    _csilk_log_internal(CSILK_LOG_ERROR, __FILE__, __LINE__, __func__, __VA_ARGS__)
#define CSILK_LOG_F(...)                                                                           \
    _csilk_log_internal(CSILK_LOG_FATAL, __FILE__, __LINE__, __func__, __VA_ARGS__)
 
#define CSILK_LOG_STRUCT(level, extra, ...)                                                        \
    _csilk_log_structured(level, __FILE__, __LINE__, __func__, extra, __VA_ARGS__)
void csilk_logger_handler(csilk_ctx_t* c);
 
void csilk_request_id_middleware(csilk_ctx_t* c);
 
void csilk_health_check_handler(csilk_ctx_t* c);
 
void csilk_ready_check_handler(csilk_ctx_t* c);
 
typedef struct {
    const char* allow_origin;  
    const char* allow_methods; 
    const char* allow_headers; 
    int allow_credentials;     
    int max_age;           
} csilk_cors_config_t;
 
void csilk_cors_middleware(csilk_ctx_t* c, const csilk_cors_config_t* config);
 
void csilk_rate_limit_middleware(csilk_ctx_t* c, int limit);
 
void csilk_csrf_middleware(csilk_ctx_t* c);
 
typedef struct {
    uint64_t rate_limit_blocks; 
    uint64_t csrf_violations;   
    uint64_t auth_failures;     
} csilk_security_stats_t;
 
typedef struct {
    size_t rss_bytes;     
    double cpu_user_time_sec; 
    double cpu_sys_time_sec;  
} csilk_process_stats_t;
 
void csilk_security_get_stats(csilk_security_stats_t* stats);
void csilk_process_get_stats(csilk_process_stats_t* stats);
 
int csilk_csrf_generate_token(char* buf, size_t buf_size);
 
typedef struct csilk_server_config_s {
    unsigned int idle_timeout_ms;    
    unsigned int read_timeout_ms;    
    unsigned int write_timeout_ms;   
    unsigned int request_timeout_ms; 
    size_t max_body_size;        
    size_t max_header_size;      
    size_t max_url_size;         
    size_t max_headers_count;    
    int max_connections;         
    int listen_backlog;      
    int tcp_nodelay;         
    int tcp_keepalive;       
    int worker_threads;      
    /* TLS configuration */
    int enable_tls;      
    char* tls_cert_file; 
    char* tls_key_file;  
    char* tls_ca_file;   
    int tls_verify_peer; 
} csilk_server_config_t;
 
typedef struct {
    int port;             
    csilk_server_config_t server; 
    csilk_log_config_t logger;    
    struct {
        int enable;         
        csilk_cors_config_t config; 
    } cors;                 
    struct {
        int enable;      
        int requests_per_minute; 
    } rate_limit;            
    struct {
        int enable; 
        char* root_dir; 
        char* prefix;   
    } static_files;     
    struct {
        int enable_logger;   
        int enable_recovery; 
        int enable_csrf;     
        int enable_auth;     
        char* auth_token;    
    } middleware;            
    struct {
        char* driver;   
        char* model;    
        char* api_key;  
        char* base_url; 
    } ai;           
    struct {
        int enable;   
        char* driver; 
    } cipher;         
} csilk_config_t;
 
int csilk_load_config(const char* yaml_path, csilk_config_t* config);
 
int csilk_config_validate(const csilk_config_t* config, const char** error_msg);
 
void csilk_config_free(csilk_config_t* config);
 
typedef int (*csilk_auth_validator_t)(const char* token);
 
void csilk_auth_middleware(csilk_ctx_t* c, csilk_auth_validator_t validator);
 
void csilk_static(csilk_ctx_t* c, const char* root_dir);
 
void csilk_file(csilk_ctx_t* c, const char* file_path);
 
cJSON* csilk_bind_json(csilk_ctx_t* c);
 
cJSON* csilk_bind_json_err(csilk_ctx_t* c, const char** error);
 
const char* csilk_get_cookie(csilk_ctx_t* c, const char* name);
 
void csilk_set_cookie(csilk_ctx_t* c,
              const char* name,
              const char* value,
              int max_age,
              const char* path,
              const char* domain,
              int secure,
              int http_only);
 
void csilk_session_init(void);
 
void csilk_session_start(csilk_ctx_t* c);
 
void csilk_session_set(csilk_ctx_t* c, const char* key, void* value);
 
void* csilk_session_get(csilk_ctx_t* c, const char* key);
 
void csilk_session_destroy(csilk_ctx_t* c);
 
#define CSILK_VALID_REQUIRED (1 << 0) 
#define CSILK_VALID_INT (1 << 1)      
#define CSILK_VALID_STRING                                                                         \
    (1 << 2) 
#define CSILK_VALID_EMAIL                                                                          \
    (1 << 3) 
typedef struct csilk_valid_rule_s {
    const char* field;  
    int flags;      
    int min;        
    int max;        
    const char* source; 
} csilk_valid_rule_t;
 
const char* csilk_validate(csilk_ctx_t* c, const csilk_valid_rule_t* rules);
 
void csilk_json(csilk_ctx_t* c, int status, cJSON* json);
 
void csilk_json_error(csilk_ctx_t* c, int status, const char* message);
 
int csilk_bind_reflect(csilk_ctx_t* c, const char* type_name, void* ptr);
 
void csilk_json_reflect(csilk_ctx_t* c, int status, const char* type_name, const void* ptr);
 
#define csilk_bind(c, type, ptr) csilk_bind_reflect(c, #type, ptr)
#define csilk_json_t(c, status, type, ptr) csilk_json_reflect(c, status, #type, ptr)
 
const char* csilk_get_client_ip(csilk_ctx_t* c);
 
void csilk_split_url(const char* url, char** path, char** query);
 
void csilk_parse_query(csilk_ctx_t* c, const char* query_string);
 
typedef struct csilk_router_node_s csilk_router_node_t;
 
typedef struct csilk_router_s {
    csilk_router_node_t* root; 
} csilk_router_t;
 
typedef struct csilk_group_s csilk_group_t;
 
csilk_router_t* csilk_router_new(void);
 
void csilk_router_add(csilk_router_t* r,
              const char* method,
              const char* path,
              csilk_handler_t* handlers,
              size_t handler_count);
 
csilk_handler_t* csilk_router_match(csilk_router_t* r, const char* method, const char* path);
 
int csilk_router_match_ctx(csilk_router_t* r, csilk_ctx_t* c);
 
void csilk_router_free(csilk_router_t* r);
 
cJSON* csilk_router_collect_routes(csilk_router_t* r);
 
cJSON* csilk_router_collect_routes(csilk_router_t* r);
 
cJSON* csilk_generate_openapi_json(csilk_router_t* router,
                   const char* title,
                   const char* version,
                   const char* description);
 
void csilk_router_add_extended(csilk_router_t* r,
                   const char* method,
                   const char* path,
                   csilk_handler_t* handlers,
                   size_t handler_count,
                   const char* path_pattern,
                   const char* input_type,
                   const char* output_type,
                   const char* summary,
                   const char* description);
 
void csilk_router_add_perm(csilk_router_t* r,
               const char* method,
               const char* path,
               csilk_handler_t* handlers,
               size_t handler_count,
               const char* perm_required,
               const char* perm_resource);
 
void csilk_router_add_extended_perm(csilk_router_t* r,
                    const char* method,
                    const char* path,
                    csilk_handler_t* handlers,
                    size_t handler_count,
                    const char* path_pattern,
                    const char* input_type,
                    const char* output_type,
                    const char* summary,
                    const char* description,
                    const char* perm_required,
                    const char* perm_resource);
 
#define CSILK_ROUTE(                                                                               \
    r, method, path, handlers, handler_count, input_type, output_type, summary, desc)              \
    csilk_router_add_extended(r,                                                               \
                  method,                                                          \
                  path,                                                            \
                  handlers,                                                        \
                  handler_count,                                                   \
                  path,                                                            \
                  input_type,                                                      \
                  output_type,                                                     \
                  summary,                                                         \
                  desc)
 
void csilk_serve_openapi(csilk_ctx_t* c,
             csilk_router_t* r,
             const char* title,
             const char* version,
             const char* description);
 
void csilk_serve_swagger_ui(csilk_ctx_t* c);
 
csilk_group_t* csilk_group_new(csilk_router_t* router, const char* prefix);
 
csilk_group_t* csilk_group_group(csilk_group_t* parent, const char* prefix);
 
void csilk_group_use(csilk_group_t* group, csilk_handler_t handler);
 
void csilk_group_add_route(csilk_group_t* group,
               const char* method,
               const char* path,
               csilk_handler_t handler);
 
void csilk_group_add_route_extended(csilk_group_t* group,
                    const char* method,
                    const char* path,
                    csilk_handler_t handler,
                    const char* input_type,
                    const char* output_type,
                    const char* summary,
                    const char* description);
 
void csilk_group_add_route_extended_perm(csilk_group_t* group,
                     const char* method,
                     const char* path,
                     csilk_handler_t handler,
                     const char* input_type,
                     const char* output_type,
                     const char* summary,
                     const char* description,
                     const char* perm_required,
                     const char* perm_resource);
 
void csilk_group_add_handlers(csilk_group_t* group,
                  const char* method,
                  const char* path,
                  csilk_handler_t* handlers,
                  size_t count);
 
void csilk_group_free(csilk_group_t* group);
 
#define csilk_GET(group, path, handler) csilk_group_add_route(group, "GET", path, handler)
#define csilk_POST(group, path, handler) csilk_group_add_route(group, "POST", path, handler)
#define csilk_PUT(group, path, handler) csilk_group_add_route(group, "PUT", path, handler)
#define csilk_DELETE(group, path, handler) csilk_group_add_route(group, "DELETE", path, handler)
#define csilk_PATCH(group, path, handler) csilk_group_add_route(group, "PATCH", path, handler)
#define csilk_OPTIONS(group, path, handler) csilk_group_add_route(group, "OPTIONS", path, handler)
#define csilk_HEAD(group, path, handler) csilk_group_add_route(group, "HEAD", path, handler)
void csilk_ws_handshake(csilk_ctx_t* c);
 
void csilk_ws_send(csilk_ctx_t* c, const uint8_t* payload, size_t len, int opcode);
 
void csilk_ws_close(csilk_ctx_t* c, uint16_t status_code, const char* reason);
 
/* --- Streaming Response (Chunked Transfer Encoding) --- */
 
void csilk_response_write(csilk_ctx_t* c, const uint8_t* data, size_t len);
 
void csilk_response_end(csilk_ctx_t* c);
 
/* --- Server-Sent Events (SSE) --- */
 
void csilk_sse_init(csilk_ctx_t* c);
 
void csilk_sse_send(csilk_ctx_t* c, const char* event, const char* data);
 
void csilk_sse_close(csilk_ctx_t* c);
 
/* --- JWT Authentication Middleware --- */
 
char* csilk_jwt_generate(csilk_ctx_t* c, cJSON* payload, const char* secret);
 
cJSON* csilk_jwt_verify(csilk_ctx_t* c, const char* token, const char* secret);
 
void csilk_jwt_middleware(csilk_ctx_t* c, const char* secret);
 
/* --- Gzip Compression Middleware --- */
 
void csilk_gzip_middleware(csilk_ctx_t* c);
 
/* --- Multipart Form Data --- */
 
typedef struct csilk_multipart_part_s {
    char name[128];        
    char filename[256];    
    char content_type[64]; 
    uint8_t* data;         
    size_t data_len;       
    csilk_ctx_t* ctx;      
} csilk_multipart_part_t;
 
typedef void (*csilk_multipart_handler_t)(csilk_multipart_part_t* part);
 
void csilk_multipart_parse(csilk_ctx_t* c, csilk_multipart_handler_t handler);
 
typedef struct csilk_server_s csilk_server_t;
 
csilk_server_t* csilk_ctx_get_server(csilk_ctx_t* c);
 
/* --- Hook System --- */
 
typedef enum {
    CSILK_HOOK_SERVER_START,  
    CSILK_HOOK_SERVER_STOP,   
    CSILK_HOOK_CONN_OPEN,     
    CSILK_HOOK_CONN_CLOSE,    
    CSILK_HOOK_REQUEST_BEGIN, 
    CSILK_HOOK_REQUEST_END,   
    CSILK_HOOK_COUNT      
} csilk_hook_type_t;
 
typedef void (*csilk_server_hook_handler_t)(csilk_server_t* s);
 
typedef void (*csilk_ctx_hook_handler_t)(csilk_ctx_t* c);
 
void csilk_server_add_hook(csilk_server_t* s, csilk_hook_type_t type, void* handler);
 
/* --- Crypto Driver Interface --- */
 
typedef struct {
    void (*sha256)(const uint8_t* data, size_t len, uint8_t out[32]);
    void (*hmac_sha256)(const uint8_t* key,
                size_t key_len,
                const uint8_t* data,
                size_t data_len,
                uint8_t out[32]);
    void (*generate_uuid)(char buf[37]);
} csilk_crypto_driver_t;
 
void csilk_server_set_crypto_driver(csilk_server_t* server, csilk_crypto_driver_t* driver);
 
void csilk_server_set_cipher_driver(csilk_server_t* server, csilk_cipher_driver_t* driver);
 
void csilk_ctx_set_storage_driver(csilk_ctx_t* c, csilk_storage_driver_t* driver);
 
void csilk_ctx_set_crypto_driver(csilk_ctx_t* c, csilk_crypto_driver_t* driver);
 
void csilk_ctx_set_cipher_driver(csilk_ctx_t* c, csilk_cipher_driver_t* driver);
 
csilk_server_t* csilk_server_new(csilk_router_t* router);
 
int csilk_server_use(csilk_server_t* server, csilk_handler_t handler);
 
void csilk_server_set_not_found_handler(csilk_server_t* server, csilk_handler_t handler);
 
void csilk_server_set_spa_fallback(csilk_server_t* server, const char* doc_root);
 
void csilk_server_free(csilk_server_t* server);
 
void csilk_server_stop(csilk_server_t* server);
void csilk_server_get_stats(csilk_server_t* server, int* active_conn, int* pooled_conn);
 
void csilk_server_set_config(csilk_server_t* server, const csilk_server_config_t* config);
 
int csilk_server_set_max_connections(csilk_server_t* server, int max);
 
void csilk_server_set_storage_driver(csilk_server_t* server, csilk_storage_driver_t* driver);
 
int csilk_server_run(csilk_server_t* server, int port);
 
/* --- Database Interface --- */
 
void csilk_db_init(void);
 
csilk_db_pool_t* csilk_db_pool_new(const char* driver_name, const char* dsn);
 
void csilk_db_pool_free(csilk_db_pool_t* pool);
 
cJSON* csilk_db_query_json(csilk_db_pool_t* pool, const char* sql);
 
int csilk_db_exec(csilk_db_pool_t* pool, const char* sql);
 
cJSON* csilk_db_query_param_json(csilk_db_pool_t* pool, const char* sql, const char** params);
 
void csilk_metrics_middleware(csilk_ctx_t* c, const char* arg);
 
void csilk_metrics_handler(csilk_ctx_t* c);
uint64_t csilk_metrics_get_total_requests(void);
uint64_t csilk_metrics_get_total_duration(void);
 
typedef struct csilk_mq_s csilk_mq_t;
 
csilk_mq_t* csilk_ctx_get_mq(csilk_ctx_t* c);
 
csilk_mq_t* csilk_server_get_mq(csilk_server_t* server);
 
csilk_router_t* csilk_server_get_router(csilk_server_t* server);
 
typedef struct csilk_mq_ctx_s csilk_mq_ctx_t;
 
typedef void (*csilk_mq_handler_t)(csilk_mq_ctx_t* ctx);
 
void csilk_mq_next(csilk_mq_ctx_t* ctx);
 
void csilk_mq_abort(csilk_mq_ctx_t* ctx);
 
typedef void (*csilk_mq_worker_t)(const char* topic, const void* payload, size_t len);
 
void csilk_mq_offload(csilk_mq_ctx_t* ctx, csilk_mq_worker_t worker);
 
const char* csilk_mq_get_topic(csilk_mq_ctx_t* ctx);
 
const void* csilk_mq_get_payload(csilk_mq_ctx_t* ctx, size_t* len);
 
void csilk_mq_use(csilk_mq_t* mq, const char* topic, csilk_mq_handler_t middleware);
 
void csilk_mq_subscribe(csilk_mq_t* mq, const char* topic, csilk_mq_handler_t subscriber);
 
int csilk_mq_publish(csilk_mq_t* mq, const char* topic, const void* payload, size_t len);
 
typedef struct {
    uint64_t published_total; 
    uint64_t delivered_total; 
    uint64_t failed_total;    
    uint32_t queue_depth;     
    uint32_t topic_count;     
} csilk_mq_stats_t;
 
void csilk_mq_get_stats(csilk_mq_t* mq, csilk_mq_stats_t* stats);
 
char* csilk_mq_stats_to_json(const csilk_mq_stats_t* stats);
 
void csilk_mq_register_monitor(csilk_mq_t* mq, csilk_ctx_t* c);
 
int csilk_mq_set_persistence(csilk_mq_t* mq, const char* wal_path);
 
#endif /* CSILK_H */