haproxy主要代码

主要代码：
=======================================================================================

haproxy.c

主要配置都由全局变量global保存(global的定义在include/types/global.h中,其中还声明了很多全局变量)

* 捕获多个信号,包括
SIGQUIT
SIGUSR1
SIGHUP
SIGPIPE
* 调整资源上线,包括
rlim_max
rlim_cur
rlimit_memmax

void run_poll_loop()
程序进入工作状态后的主循环,其内容

int next;
while (1) {
/* 检查是否捕获了新signals,并处理它们 */
signal_process_queue();

/* 检查是否需要处理一些超时tasks */
wake_expired_tasks(&next);

/* 执行tasks */
process_runnable_tasks(&next);

/* 维护所有proxies.
* 当proxies增多时,消耗增大,计划后续作为一个来task处理
*/
maintain_proxies(&next);

/* 不再接收新请求 & 已无当前监听 */
if (!actconn && listeners == 0)
break;

/* The poller will ensure it returns around  ?? */
cur_poller.poll(&cur_poller, next);
}


memory.c
一开始会分配的内存,以list方式管理
内存不够时,可追加分配
但内存释放不是真正的释放,只是放入空闲list中,因此haproxy使用的内存量不会随着负载降低而减少

proto_http.c
HTTP协议解析

task.c
task管理
这里面的实现

struct task *__task_wakeup(struct task *t)
根据t->nice,将task  移到执行队列中
这个任务不能之前已经在执行队列中,如果不确定,使用更安全的函数task_wakeup()

void __task_queue(struct task *task)
不应由外面直接调用,应由task_queue()调用,因为调用前它会做几个小test

void wake_expired_tasks(int *next)

void process_runnable_tasks(int *next)

int init_task()
初始化任务池


session.c

struct task *process_session(struct task *t)
回调的处理(类),会话处理的主要部分,输入单位是task(参考task.c)
这里面用了goto...
resync_stream_interface:				/* Check for connection closure */
resync_request:							/* Analyse request */
resync_response:						/* Analyse response */

void session_free(struct session *s)
释放session及上下文,必须先删除该session再调用本函数

void sess_set_term_flags(struct session *s)
根据session状态设置本session标志位

void sess_change_server(struct session *sess, struct server *newsrv)
将一个已有的session转移到另一个server去提供服务

int process_store_rules(struct session *s, struct buffer *rep, int an_bit)


int sess_update_st_con_tcp(struct session *s, struct stream_interface *si)


void sess_establish(struct session *s, struct stream_interface *si)
仅在SI_ST_CON向SI_ST_EST转移时可以调用

int sess_update_st_cer(struct session *s, struct stream_interface *si)
当si->state == SI_ST_CER时调用,可能因为之前的connection已经释放
返回：
SI_ST_CLO		重试已耗尽
SI_ST_TAR		当重新连接之前,delay一阵
SI_ST_ASS		建议连接同一server
SI_ST_REQ		进行重新分配(到不同server)

proxy.c

全局参数
struct proxy *proxy  = NULL;	当前所有的proxy链表
(层次：proxy链表-->proxy-->server)

int get_backend_server(const char *bk_name, const char *sv_name,
struct proxy **bk, struct server **sv)
获取指定名称的backend和server并返回

void listen_proxies(void)
重新激活监听
--试图激活所有为PR_STPAUSED状态的监听
--若监听失败,将停用该proxy
--若监听数超过配置的最大连接数,将超出部分状态置为PR_STIDLE
--若成功,状态置为PR_STRUN

int session_set_backend(struct session *s, struct proxy *be)
将s的backend设置为be
--如果s已经有backend(即s->flags & SN_BE_ASSIGNED),则什么都不做

signal.c

void __signal_process_queue()
调用所有pending signals的handler,且将计数器和队列长度清0
-----------
sigprocmask(SIG_SETMASK, &blocked_sig, &old_sig);
//mask期间，任何SIGQUIT信号都会被阻塞，如果在mask期间收到任何键盘的quit信号，则此时会把这些信息存在内核的队列中，等待mask结束后，可能要处理此信号

sigprocmask(SIG_SETMASK, &old_sig, NULL);
-----------

backend.c

void recount_servers(struct proxy *px)
更新px的active 和 backup servers

struct server *get_server_sh(struct proxy *px, const char *addr, int len)
为px找一个运行中的server(会在active和backup的server中查找)
--若找到,返回该server
--若未找到,返回null
--仅使用最基本的hash方式
--若px仅剩一个server,不用hash,直接用该server

struct server *get_server_uh(struct proxy *px, char *uri, int uri_len)
为px找一个运行中的server(会在active和backup的server中查找)
--与get_server_sh的区别是,使用对URI的hash
-- In order to optimize cache hits, the hash computation ends at the question mark ??

struct server *get_server_ph(struct proxy *px, const char *uri, int uri_len)
为px找一个运行中的server(会在active和backup的server中查找)
--根据url中的参数进行hash

struct server *get_server_ph_post(struct session *s)
和get_server_ph类似,但根据body contents来hash

struct server *get_server_hh(struct session *s)
和get_server_ph_post类似,但根据head来hash


proto_http.c
http协议处理

int http_process_request(struct session *s, struct buffer *req, int an_bit)
处理当前请求
--返回0 成功;返回1  数据不够/失败/抛弃该request(支持连接拒绝)
--依赖buffers flags, 并会更新 s->req->analysers.

lb_xxx的文件都是load balance的各种实现

lb_chash.c	为一致性hash的实现
lb_fwlc.c	为最少连接者先处理(Fast Weighted Least Connection)的实现
lb_fwrr.c	为简单的轮询(Fast Weighted Round Robin)的实现
lb_map.c	为基于映射的hash(Map-based load-balancing : RR and HASH)的实现