You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
105 lines
3.7 KiB
C
105 lines
3.7 KiB
C
#ifndef _LIGHTTPD_BACKENDS_H_
|
|
#define _LIGHTTPD_BACKENDS_H_
|
|
|
|
#include <lighttpd/base.h>
|
|
|
|
enum liBackendResult {
|
|
LI_BACKEND_SUCCESS, /* got a connection */
|
|
LI_BACKEND_WAIT, /* establishing new connection, or waiting for a free slot */
|
|
LI_BACKEND_TIMEOUT /* wait timed out, no free slots available */
|
|
};
|
|
|
|
typedef enum liBackendResult liBackendResult;
|
|
typedef struct liBackendCallbacks liBackendCallbacks;
|
|
typedef struct liBackendWait liBackendWait;
|
|
typedef struct liBackendConnection liBackendConnection;
|
|
typedef struct liBackendPool liBackendPool;
|
|
typedef struct liBackendConfig liBackendConfig;
|
|
|
|
typedef void (*liBackendConnectionThreadCB)(liBackendPool *bpool, liWorker *wrk, liBackendConnection *bcon);
|
|
typedef void (*liBackendCB)(liBackendPool *bpool);
|
|
|
|
|
|
struct liBackendConnection {
|
|
liEventIO watcher;
|
|
gpointer data;
|
|
};
|
|
|
|
/* states: [start] ->(new)-> [INACTIVE] ->(detach)-> [detached] ->(attach)-> [INACTIVE] ->get-> [active] ->put-> [INACTIVE] ->(close)-> [done] */
|
|
/* the backend pool might be locked while the callbacks are running, but don't rely on it */
|
|
struct liBackendCallbacks {
|
|
/* for moving connection between threads */
|
|
liBackendConnectionThreadCB detach_thread_cb;
|
|
liBackendConnectionThreadCB attach_thread_cb;
|
|
|
|
/* for initializing/shutdown */
|
|
liBackendConnectionThreadCB new_cb;
|
|
liBackendConnectionThreadCB close_cb;
|
|
|
|
/* free pool config */
|
|
liBackendCB free_cb;
|
|
};
|
|
|
|
|
|
struct liBackendPool {
|
|
/* READ ONLY CONFIGURATION DATA */
|
|
const liBackendConfig *config;
|
|
};
|
|
|
|
struct liBackendConfig {
|
|
const liBackendCallbacks *callbacks;
|
|
|
|
liSocketAddress sock_addr;
|
|
|
|
/* >0: real limit for current connections + pendings connects
|
|
* <0: unlimited connections, absolute value limits the number of pending connects per worker
|
|
* =0: no limit
|
|
*
|
|
* if there is no limit (i.e. <= 0), backend connections won't be moved between threads
|
|
*/
|
|
int max_connections;
|
|
|
|
/* how long we wait on keep-alive connections. 0: no keep-alive;
|
|
* also used for new connection we didn't use
|
|
*/
|
|
guint idle_timeout;
|
|
|
|
/* how long we wait for connect to succeed, must be > 0; when connect fails the pool gets "disabled". */
|
|
guint connect_timeout;
|
|
|
|
/* how long a vrequest is allowed to wait for a connect before we return an error. if pool gets disabled all requests fail.
|
|
* if a pending connect is assigned to a vrequest wait_timeout is not active.
|
|
*/
|
|
guint wait_timeout;
|
|
|
|
/* how long the pool stays disabled. even if this is 0, all vrequests will receive an error on disable */
|
|
guint disable_time;
|
|
|
|
/* max requests per connection. -1: unlimited */
|
|
int max_requests;
|
|
|
|
/* if enabled, the backend.watcher will be set to internal callback and LI_EV_READ while the connection
|
|
* is not used by a vrequest;
|
|
* if it sees input data it will log an error and close it, and if it sees eof it will
|
|
* close it too
|
|
* if you disable this you should have to handle this yourself
|
|
*/
|
|
gboolean watch_for_close;
|
|
};
|
|
|
|
LI_API liBackendPool* li_backend_pool_new(const liBackendConfig *config);
|
|
LI_API void li_backend_pool_free(liBackendPool *bpool);
|
|
|
|
LI_API liBackendResult li_backend_get(liVRequest *vr, liBackendPool *bpool, liBackendConnection **pbcon, liBackendWait **pbwait);
|
|
LI_API void li_backend_wait_stop(liVRequest *vr, liBackendPool *bpool, liBackendWait **pbwait);
|
|
|
|
/* set bcon->fd = -1 if you closed the connection after an error */
|
|
LI_API void li_backend_put(liWorker *wrk, liBackendPool *bpool, liBackendConnection *bcon, gboolean closecon); /* if closecon == TRUE or bcon->watcher.fd == -1 the connection gets removed */
|
|
|
|
/* if an idle connections gets closed; bcon must be INACTIVE (i.e. not detached and not active).
|
|
* call in worker that bcon is attached to.
|
|
*/
|
|
LI_API void li_backend_connection_closed(liBackendPool *bpool, liBackendConnection *bcon);
|
|
|
|
#endif
|