You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

104 lines
3.7 KiB

#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 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