app.h

Go to the documentation of this file.

 
#ifndef __CWIST_APP_H__
#define __CWIST_APP_H__
 
#include <cwist/net/http/http.h>
#include <cwist/net/http/https.h>
#include <cwist/core/db/sql.h>
#include <cwist/core/db/pool.h>
#include <cwist/net/redis/cwist_redis.h>
#include <cwist/net/grpc/grpc.h>
#include <cwist/sys/job/scheduler.h>
#include <cwist/sys/err/cwist_err.h>
#include <cwist/core/macros.h>
#include <cwist/sys/app/big_dumb_reply.h>
#include <ttak/mem_tree/mem_tree.h>
 
#include <cwist/net/websocket/websocket.h>
#include <cwist/net/websocket/websocket_async.h>
 
/* Forward declaration for auto-mounted RDBMS runtime */
struct cwist_rdbms_runtime;
 
typedef void (*cwist_handler_func)(cwist_http_request *req, cwist_http_response *res);
 
typedef void (*cwist_handler_ex_func)(void *user_ctx, cwist_http_request *req,
                                      cwist_http_response *res);
 
typedef void (*cwist_handler_ctx_destroy_func)(void *user_ctx);
 
typedef void (*cwist_ws_handler_func)(cwist_websocket *ws);
 
typedef void (*cwist_error_handler_func)(cwist_http_request *req, cwist_http_response *res,
                                         cwist_http_status_t status);
 
typedef void (*cwist_webtransport_handler_func)(cwist_http_request *req, cwist_http_response *res,
                                                void *stream);
 
typedef struct cwist_error_handler_entry {
    cwist_http_status_t status_code;
    cwist_error_handler_func handler;
    struct cwist_error_handler_entry *next;
} cwist_error_handler_entry;
 
typedef enum cwist_rdbms_provider {
    CWIST_RDBMS_NONE = 0,
    CWIST_RDBMS_POSTGRES,
    CWIST_RDBMS_MYSQL,
    CWIST_RDBMS_MARIADB,
} cwist_rdbms_provider_t;
 
typedef struct cwist_rdbms_runtime {
    cwist_rdbms_provider_t provider; 
    int port;                        
    char *host;                      
    bool ready;                      
} cwist_rdbms_runtime;
 
cwist_rdbms_provider_t cwist_rdbms_probe_port(int port);
 
bool cwist_rdbms_mount_runtime(cwist_app *app, cwist_rdbms_provider_t provider, int port);
 
typedef void (*cwist_middleware_func)(cwist_http_request *req, cwist_http_response *res,
                                      cwist_handler_func next);
 
typedef void (*cwist_middleware_func_ex)(cwist_http_request *req, cwist_http_response *res,
                                          cwist_handler_func next, void *user_ctx);
 
typedef void (*cwist_middleware_ctx_destroy_func)(void *user_ctx);
 
typedef void (*cwist_https_request_handler_func)(cwist_https_connection *conn, void *ctx);
 
typedef struct cwist_middleware_node {
    cwist_middleware_func func;
    cwist_middleware_func_ex func_ex;
    void *user_ctx;
    cwist_middleware_ctx_destroy_func destroy;
    bool is_ex;
    struct cwist_middleware_node *next;
} cwist_middleware_node;
 
typedef struct cwist_route_table cwist_route_table;
typedef struct cwist_static_dir cwist_static_dir;
typedef struct cwist_config cwist_config;
typedef struct cwist_logger cwist_logger;
 
typedef struct cwist_app {
    int port;
    bool use_ssl;
    bool use_http2;   
    bool use_http3;   
    bool use_https2;  
    bool use_https3;  
    char *cert_path;
    char *key_path;
    cwist_https_request_handler_func https_request_handler;
 
    cwist_middleware_node *middlewares; 
 
    cwist_route_table *router; 
    cwist_static_dir *static_dirs; 
 
    cwist_error_handler_func error_handler; 
    cwist_error_handler_entry *error_handlers; 
 
    struct cwist_config *config; 
    struct cwist_logger *logger; 
 
    cwist_https_context *ssl_ctx; 
    struct cwist_http3_context *h3_ctx; 
    cwist_db *db; 
    char *db_path; 
    bool nuke_enabled; 
 
    size_t max_mem_space;
    struct cwist_fix_server_mem *mem_manager;
 
    cwist_bdr_t *bdr_ctx;
 
    struct cwist_rdbms_runtime *rdbms;
 
    bool pqc_layer_enabled;
    char *tls_groups;
 
    cwist_webtransport_handler_func wt_handler;
 
    char *session_secret;
    char *session_name;
    int session_max_age;
 
    void *db_pool;
 
    void *redis_pool;
 
    void *scheduler;
 
    void *grpc_routes;
 
    void *assets;
} cwist_app;
 
typedef struct cwist_file_t {
    char *path;       
    char *fs_path;    
    void *data;       
    size_t size;      
    time_t last_mod;  
    char etag[40];          
    char last_mod_hdr[30];  
    ttak_mem_node_t *node; 
} cwist_file_t;
 
typedef struct cwist_fix_server_mem {
    size_t total_capacity;     
    size_t current_used;       
 
    cwist_file_t *files;       
    size_t file_count;
    size_t files_capacity;     
 
    uint64_t retire_grace_ns;  
    ttak_mem_tree_t file_tree; 
 
    pthread_mutex_t lock;
    pthread_t watcher_thread;
    bool watcher_running;
    int check_interval_ms;
} cwist_fix_server_mem;
 
cwist_app *cwist_app_create(void);
 
void cwist_app_enable_swagger(cwist_app *app, const char *mount_path,
                              const char *openapi_json_path);
 
void cwist_app_destroy(cwist_app *app);
 
void cwist_app_set_max_memspace(cwist_app *app, size_t size);
 
void cwist_app_use(cwist_app *app, cwist_middleware_func mw);
 
cwist_error_t cwist_app_use_ex(cwist_app *app, cwist_middleware_func mw,
                               cwist_middleware_func_ex mw_ex, void *user_ctx,
                               cwist_middleware_ctx_destroy_func destroy);
void cwist_app_set_error_handler(cwist_app *app, cwist_error_handler_func handler);
void cwist_app_register_error_handler(cwist_app *app, cwist_http_status_t status,
                                      cwist_error_handler_func handler);
void cwist_app_configure_bdr(cwist_app *app, size_t max_bytes, time_t max_entry_age_sec,
                             uint64_t revalidate_hits);
 
cwist_error_t cwist_app_use_https(cwist_app *app, const char *cert_path, const char *key_path);
 
cwist_error_t cwist_app_reload_tls(cwist_app *app, const char *cert_path, const char *key_path);
cwist_error_t cwist_app_use_https2(cwist_app *app, bool enabled);
cwist_error_t cwist_app_use_https3(cwist_app *app, bool enabled);
 
cwist_error_t cwist_app_use_http2(cwist_app *app, bool enabled);
 
cwist_error_t cwist_app_use_http3(cwist_app *app, bool enabled);
 
void cwist_app_use_webtransport(cwist_app *app, cwist_webtransport_handler_func handler);
 
void cwist_app_use_pqc_layer(cwist_app *app, bool enabled);
 
void cwist_app_set_tls_groups(cwist_app *app, const char *groups);
 
cwist_error_t cwist_app_use_db(cwist_app *app, const char *db_path);
cwist_error_t cwist_app_use_nuke_db(cwist_app *app, const char *db_path, int sync_interval_ms);
cwist_db *cwist_app_get_db(cwist_app *app);
 
cwist_error_t cwist_app_use_db_pool(cwist_app *app, const char *db_path, size_t max_conns);
 
cwist_db_pool_t *cwist_app_get_db_pool(cwist_app *app);
 
cwist_error_t cwist_app_use_redis(cwist_app *app, const char *host, int port, size_t max_conns);
 
cwist_redis_pool_t *cwist_app_get_redis_pool(cwist_app *app);
 
cwist_error_t cwist_app_use_scheduler(cwist_app *app, size_t worker_count, size_t queue_capacity);
 
cwist_scheduler_t *cwist_app_get_scheduler(cwist_app *app);
 
bool cwist_app_auto_rdbms(cwist_app *app, int port);
 
#define cwist_use_https2(enabled) cwist_app_use_https2((app), (enabled))
#define cwist_use_https3(enabled) cwist_app_use_https3((app), (enabled))
#define cwist_use_http2(enabled) cwist_app_use_http2((app), (enabled))
#define cwist_use_http3(enabled) cwist_app_use_http3((app), (enabled))
 
void cwist_app_get(cwist_app *app, const char *path, cwist_handler_func handler);
void cwist_app_post(cwist_app *app, const char *path, cwist_handler_func handler);
void cwist_app_put(cwist_app *app, const char *path, cwist_handler_func handler);
void cwist_app_delete(cwist_app *app, const char *path, cwist_handler_func handler);
void cwist_app_patch(cwist_app *app, const char *path, cwist_handler_func handler);
void cwist_app_ws(cwist_app *app, const char *path, cwist_ws_handler_func handler);
 
cwist_error_t cwist_app_get_ex(cwist_app *app, const char *path, cwist_handler_ex_func handler,
                               void *user_ctx, cwist_handler_ctx_destroy_func destroy);
cwist_error_t cwist_app_post_ex(cwist_app *app, const char *path, cwist_handler_ex_func handler,
                                void *user_ctx, cwist_handler_ctx_destroy_func destroy);
cwist_error_t cwist_app_put_ex(cwist_app *app, const char *path, cwist_handler_ex_func handler,
                               void *user_ctx, cwist_handler_ctx_destroy_func destroy);
cwist_error_t cwist_app_delete_ex(cwist_app *app, const char *path, cwist_handler_ex_func handler,
                                  void *user_ctx, cwist_handler_ctx_destroy_func destroy);
cwist_error_t cwist_app_patch_ex(cwist_app *app, const char *path, cwist_handler_ex_func handler,
                                 void *user_ctx, cwist_handler_ctx_destroy_func destroy);
 
void cwist_app_ws_async(cwist_app *app, const char *path, cwist_ws_on_message_t on_message,
                        void *user_data);
void cwist_app_get_opt(cwist_app *app, const char *path, cwist_handler_func handler,
                       cwist_endpoint_opt_t opts);
void cwist_app_post_opt(cwist_app *app, const char *path, cwist_handler_func handler,
                        cwist_endpoint_opt_t opts);
void cwist_app_put_opt(cwist_app *app, const char *path, cwist_handler_func handler,
                       cwist_endpoint_opt_t opts);
void cwist_app_delete_opt(cwist_app *app, const char *path, cwist_handler_func handler,
                          cwist_endpoint_opt_t opts);
void cwist_app_patch_opt(cwist_app *app, const char *path, cwist_handler_func handler,
                         cwist_endpoint_opt_t opts);
void cwist_app_ws_opt(cwist_app *app, const char *path, cwist_ws_handler_func handler,
                      cwist_endpoint_opt_t opts);
 
void cwist_app_enable_metrics(cwist_app *app);
void cwist_app_enable_healthz(cwist_app *app);
 
void cwist_app_get_named(cwist_app *app, const char *path, const char *name,
                         cwist_handler_func handler);
void cwist_app_post_named(cwist_app *app, const char *path, const char *name,
                          cwist_handler_func handler);
void cwist_app_put_named(cwist_app *app, const char *path, const char *name,
                         cwist_handler_func handler);
void cwist_app_delete_named(cwist_app *app, const char *path, const char *name,
                            cwist_handler_func handler);
void cwist_app_patch_named(cwist_app *app, const char *path, const char *name,
                           cwist_handler_func handler);
char *cwist_url_for(cwist_app *app, const char *name, cwist_query_map *params);
 
cwist_error_t cwist_app_static(cwist_app *app, const char *url_prefix, const char *directory);
 
cwist_error_t cwist_app_static_with_cache(cwist_app *app, const char *url_prefix,
                                          const char *directory, const char *cache_control);
#ifndef CWIST_MULTIPORT_MAX_PORTS
#define CWIST_MULTIPORT_MAX_PORTS 64
#endif
 
typedef struct cwist_multiport_t {
    unsigned short ports[CWIST_MULTIPORT_MAX_PORTS]; 
    size_t count; 
    bool valid; 
} cwist_multiport_t;
 
cwist_multiport_t cwist_create_multiport_from_array(const unsigned short *ports, size_t count);
 
#define cwist_create_multiport(ports) \
    cwist_create_multiport_from_array((ports), sizeof(ports) / sizeof((ports)[0]))
 
void cwist_app_http_handler(int client_fd, void *ctx);
cwist_async_action_t cwist_app_http_handler_async(int client_fd, cwist_http_async_conn_t *conn);
 
void cwist_apply_profile(void);
 
int cwist_app_listen(cwist_app *app, int port);
 
int cwist_app_listen_ex(cwist_app *app, int port, int workers_override, int c1m_override);
 
int cwist_app_multiport(cwist_app **app_ref, unsigned short public_port, cwist_multiport_t ports);
 
cwist_app *cwist_multiport_get_app(cwist_app **app_ref, unsigned short port);
void cwist_app_dispatch(cwist_app *app, cwist_http_request *req, cwist_http_response *res);
 
int cwist_app_dispatch_memory(cwist_app *app, const char *req_buf, size_t req_len, char **res_buf,
                              size_t *res_len);
 
typedef int (*cwist_stream_write_fn)(void *ctx, const char *data, size_t len);
 
#define CWIST_STREAM_CHUNK (64 * 1024)
 
int cwist_app_dispatch_stream(cwist_app *app, const char *req_buf, size_t req_len,
                              cwist_stream_write_fn write_fn, void *write_ctx);
 
typedef struct cwist_stream_req cwist_stream_req_t;
 
cwist_stream_req_t *cwist_stream_req_begin(const char *head, size_t head_len);
 
int cwist_stream_req_feed(cwist_stream_req_t *req, const char *chunk, size_t len);
 
int cwist_stream_req_end(cwist_stream_req_t *req);
 
int cwist_stream_req_dispatch(cwist_stream_req_t *req, cwist_app *app,
                              cwist_stream_write_fn write_fn, void *write_ctx);
 
#endif