Nginx の上流メカニズムの負荷分散

<code><span>typedef</span><span>struct</span> {
    <span>/* 负载均衡的类型 */</span>
    ngx_http_upstream_init_pt        init_upstream;
    <span>/* 负载均衡类型的初始化函数 */</span>
    ngx_http_upstream_init_peer_pt   init;
    <span>/* 指向 ngx_http_upstream_rr_peers_t 结构体 */</span><span>void</span>                            *data;
} ngx_http_upstream_peer_t;</code>

<code><span>/* 服务器结构体 */</span><span>typedef</span><span>struct</span> {
    <span>/* 指向存储 IP 地址的数组，因为同一个域名可能会有多个 IP 地址 */</span>
    ngx_addr_t                      *addrs;
    <span>/* IP 地址数组中元素个数 */</span>
    ngx_uint_t                       naddrs;
    <span>/* 权重 */</span>
    ngx_uint_t                       weight;
    <span>/* 最大失败次数 */</span>
    ngx_uint_t                       max_fails;
    <span>/* 失败时间阈值 */</span>
    time_t                           fail_timeout;

    <span>/* 标志位，若为 1，表示不参与策略选择 */</span><span>unsigned</span>                         down:<span>1</span>;
    <span>/* 标志位，若为 1，表示为备用服务器 */</span><span>unsigned</span>                         backup:<span>1</span>;
} ngx_http_upstream_server_t;</code>

<code>typedef <span>struct</span> {
    <span>/* 后端服务器 IP 地址 */</span><span>struct</span> sockaddr                *sockaddr;
    <span>/* 后端服务器 IP 地址的长度 */</span>
    socklen_t                       socklen;
    <span>/* 后端服务器的名称 */</span>
    ngx_str_t                       name;

    <span>/* 后端服务器当前的权重 */</span>
    ngx_int_t                       current_weight;
    <span>/* 后端服务器有效权重 */</span>
    ngx_int_t                       effective_weight;
    <span>/* 配置项所指定的权重 */</span>
    ngx_int_t                       weight;

    <span>/* 已经失败的次数 */</span>
    ngx_uint_t                      fails;
    <span>/* 访问时间 */</span>
    time_t                          accessed;
    time_t                          <span>checked</span>;

    <span>/* 最大失败次数 */</span>
    ngx_uint_t                      max_fails;
    <span>/* 失败时间阈值 */</span>
    time_t                          fail_timeout;

    <span>/* 后端服务器是否参与策略，若为1，表示不参与 */</span>
    ngx_uint_t                      down;          <span>/* unsigned  down:1; */</span><span>#<span>if</span> (NGX_HTTP_SSL)</span>
    ngx_ssl_session_t              *ssl_session;   <span>/* local to a process */</span><span>#<span>endif</span></span>
} ngx_http_upstream_rr_peer_t;</code>

<code><span>typedef</span><span>struct</span> ngx_http_upstream_rr_peers_s  ngx_http_upstream_rr_peers_t;

<span>struct</span> ngx_http_upstream_rr_peers_s {
    <span>/* 竞选队列中后端服务器的数量 */</span>
    ngx_uint_t                      number;

 <span>/* ngx_mutex_t                    *mutex; */</span><span>/* 所有后端服务器总的权重 */</span>
    ngx_uint_t                      total_weight;

    <span>/* 标志位，若为 1，表示后端服务器仅有一台，此时不需要选择策略 */</span><span>unsigned</span>                        single:<span>1</span>;
    <span>/* 标志位，若为 1，表示所有后端服务器总的权重等于服务器的数量 */</span><span>unsigned</span>                        weighted:<span>1</span>;

    ngx_str_t                      *name;

    <span>/* 后端服务器的链表 */</span>
    ngx_http_upstream_rr_peers_t   *next;

    <span>/* 特定的后端服务器 */</span>
    ngx_http_upstream_rr_peer_t     peer[<span>1</span>];
};</code>

<code><span>typedef</span> struct {
    ngx_http_upstream_rr_peers_t   *peers;
    ngx_uint_t                      current;
    uintptr_t                      *tried;
    uintptr_t                       <span><span>data</span>;</span>
} ngx_http_upstream_rr_peer_data_t;</code>

<code><span>for</span> (i = <span>0</span>; i < umcf->upstreams.nelts; i++) {  

    init = uscfp[i]<span>-></span>peer.init_upstream ? 
        uscfp[i]<span>-></span>peer.<span>init_upstream</span>:                                  ngx_http_upstream_init_round_robin;  

    <span>if</span> (init(cf, uscfp[i]) != NGX_OK) {  
            <span>return</span> NGX_CONF_ERROR;  
    }  
}  </code>

<code>static void  
ngx_http_upstream_init_request(ngx_http_request_t *r)  
{  
<span>...</span><span>if</span> (uscf->peer.init(r, uscf) != NGX_OK) {  
        ngx_http_upstream_finalize_request(r, u,  
                                           NGX_HTTP_INTERNAL_SERVER_ERROR);  
        <span>return</span>;  
    }  

    ngx_http_upstream_connect(r, u);  
}  </code>

<code>ngx_int_t  
ngx_event_connect_peer(ngx_peer_connection_t *pc)  
{  
<span>...</span>/* 调用 ngx_http_upstream_get_round_robin_peer  */
   rc = pc->get(pc, pc->data);  
   <span>if</span> (rc != NGX_OK) {  
       <span>return</span> rc;  
   }  

  s = ngx_socket(pc->sockaddr->sa_family, SOCK_STREAM, <span>0</span>);  
<span>...</span>}  </code>

<code>static void  
ngx_http_upstream_send_request(ngx_http_request_t *r, ngx_http_upstream_t *u)  
{  
<span>...</span><span>if</span> (!u->request_sent && ngx_http_upstream_test_connect(c) != NGX_OK) {  
        /* 测试连接失败 */ 
        ngx_http_upstream_next(r, u, NGX_HTTP_UPSTREAM_FT_ERROR);  
        <span>return</span>;  
    }  
<span>...</span>}  </code>

<code><span>/* 初始化服务器负载均衡列表 */</span>
ngx_int_t
ngx_http_upstream_init_round_robin(ngx_conf_t *cf,
    ngx_http_upstream_srv_conf_t *us)
{
    ngx_url_t                      u;
    ngx_uint_t                     i, j, n, w;
    ngx_http_upstream_server_t    *<span>server</span>;
    ngx_http_upstream_rr_peers_t  *peers, *backup;

    <span>/* 设置 ngx_http_upstream_peer_t 结构体中 init 的回调方法 */</span>
    us->peer.init = ngx_http_upstream_init_round_robin_peer;

    <span>/* 第一种情况：若 upstream 机制中有配置后端服务器 */</span><span>if</span> (us->servers) {
        <span>/* ngx_http_upstream_srv_conf_t us 结构体成员 servers 是一个指向服务器数组 ngx_array_t 的指针，*/</span><span>server</span> = us->servers->elts;

        n = <span>0</span>;
        w = <span>0</span>;
        <span>/* 在这里说明下：一个域名可能会对应多个 IP 地址，upstream 机制中把一个 IP 地址看作一个后端服务器 */</span><span>/* 遍历服务器数组中所有后端服务器，统计非备用后端服务器的 IP 地址总个数(即非备用后端服务器总的个数) 和 总权重 */</span><span>for</span> (i = <span>0</span>; i < us->servers->nelts; i++) {
            <span>/* 若当前服务器是备用服务器，则 continue 跳过以下检查，继续检查下一个服务器 */</span><span>if</span> (<span>server</span>[i].backup) {ngx_http_upstream_peer_t
                <span>continue</span>;
            }

            <span>/* 统计所有非备用后端服务器 IP 地址总的个数(即非备用后端服务器总的个数) */</span>
            n += <span>server</span>[i].naddrs;
            <span>/* 统计所有非备用后端服务器总的权重 */</span>
            w += <span>server</span>[i].naddrs * <span>server</span>[i].weight;
        }

        <span>/* 若 upstream 机制中配置项指令没有设置后端服务器，则出错返回 */</span><span>if</span> (n == <span>0</span>) {
            ngx_log_error(NGX_LOG_EMERG, cf->log, <span>0</span>,
                          <span>"no servers in upstream \"%V\" in %s:%ui"</span>,
                          &us->host, us->file_name, us->line);
            <span>return</span> NGX_ERROR;
        }

        <span>/* 值得注意的是：备用后端服务器列表 和 非备用后端服务器列表 是分开挂载的，因此需要分开设置 */</span><span>/* 为非备用后端服务器分配内存空间 */</span>
        peers = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_rr_peers_t)
                              + sizeof(ngx_http_upstream_rr_peer_t) * (n - <span>1</span>));
        <span>if</span> (peers == NULL) {
            <span>return</span> NGX_ERROR;
        }

        <span>/* 初始化非备用后端服务器列表 ngx_http_upstream_rr_peers_t 结构体 */</span>
        peers->single = (n == <span>1</span>);<span>/* 表示只有一个非备用后端服务器 */</span>
        peers->number = n;<span>/* 非备用后端服务器总的个数 */</span>
        peers->weighted = (w != n);<span>/* 设置默认权重为 1 或 0 */</span>
        peers->total_weight = w;<span>/* 设置非备用后端服务器总的权重 */</span>
        peers->name = &us->host;<span>/* 非备用后端服务器名称 */</span>        n = <span>0</span>;

        <span>/* 遍历服务器数组中所有后端服务器，初始化非备用后端服务器 */</span><span>for</span> (i = <span>0</span>; i < us->servers->nelts; i++) {
            <span>if</span> (<span>server</span>[i].backup) {<span>/* 若为备用服务器则 continue 跳过 */</span><span>continue</span>;
            }
            <span>/* 以下关于 ngx_http_upstream_rr_peer_t 结构体中三个权重值的说明 */</span><span>/*
             * effective_weight 相当于质量(来源于配置文件配置项的 weight)，current_weight 相当于重量。
             * 前者反应本质，一般是不变的。current_weight 是运行时的动态权值，它的变化基于 effective_weight。
             * 但是 effective_weight 在其对应的 peer 服务异常时，会被调低，
             * 当服务恢复正常时，effective_weight 会逐渐恢复到实际值（配置项的weight）;
             */</span><span>/* 遍历非备用后端服务器所对应 IP 地址数组中的所有 IP 地址(即一个后端服务器域名可能会对应多个 IP 地址) */</span><span>for</span> (j = <span>0</span>; j < <span>server</span>[i].naddrs; j++) {
                <span>/* 为每个非备用后端服务器初始化 */</span>
                peers->peer[n].sockaddr = <span>server</span>[i].addrs[j].sockaddr;<span>/* 设置非备用后端服务器 IP 地址 */</span>
                peers->peer[n].socklen = <span>server</span>[i].addrs[j].socklen;<span>/* 设置非备用后端服务器 IP 地址长度 */</span>
                peers->peer[n].name = <span>server</span>[i].addrs[j].name;<span>/* 设置非备用后端服务器域名 */</span>
                peers->peer[n].weight = <span>server</span>[i].weight;<span>/* 设置非备用后端服务器配置项权重 */</span>
                peers->peer[n].effective_weight = <span>server</span>[i].weight;<span>/* 设置非备用后端服务器有效权重 */</span>
                peers->peer[n].current_weight = <span>0</span>;<span>/* 设置非备用后端服务器当前权重 */</span>
                peers->peer[n].max_fails = <span>server</span>[i].max_fails;<span>/* 设置非备用后端服务器最大失败次数 */</span>
                peers->peer[n].fail_timeout = <span>server</span>[i].fail_timeout;<span>/* 设置非备用后端服务器失败时间阈值 */</span>
                peers->peer[n].down = <span>server</span>[i].down;<span>/* 设置非备用后端服务器 down 标志位，若该标志位为 1，则不参与策略 */</span>
                n++;
            }
        }

        <span>/*
         * 将非备用服务器列表挂载到 ngx_http_upstream_srv_conf_t 结构体成员结构体
         * ngx_http_upstream_peer_t peer 的成员 data 中；
         */</span>
        us->peer.data = peers;

        <span>/* backup servers */</span>        n = <span>0</span>;
        w = <span>0</span>;

         <span>/* 遍历服务器数组中所有后端服务器，统计备用后端服务器的 IP 地址总个数(即备用后端服务器总的个数) 和 总权重 */</span><span>for</span> (i = <span>0</span>; i < us->servers->nelts; i++) {
            <span>if</span> (!<span>server</span>[i].backup) {
                <span>continue</span>;
            }

            n += <span>server</span>[i].naddrs;<span>/* 统计所有备用后端服务器的 IP 地址总的个数 */</span>
            w += <span>server</span>[i].naddrs * <span>server</span>[i].weight;<span>/* 统计所有备用后端服务器总的权重 */</span>
        }

        <span>if</span> (n == <span>0</span>) {<span>/* 若没有备用后端服务器，则直接返回 */</span><span>return</span> NGX_OK;
        }

        <span>/* 分配备用服务器列表的内存空间 */</span>
        backup = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_rr_peers_t)
                              + sizeof(ngx_http_upstream_rr_peer_t) * (n - <span>1</span>));
        <span>if</span> (backup == NULL) {
            <span>return</span> NGX_ERROR;
        }

        peers->single = <span>0</span>;
        <span>/* 初始化备用后端服务器列表 ngx_http_upstream_rr_peers_t 结构体 */</span>
        backup->single = <span>0</span>;
        backup->number = n;
        backup->weighted = (w != n);
        backup->total_weight = w;
        backup->name = &us->host;

        n = <span>0</span>;

        <span>/* 遍历服务器数组中所有后端服务器，初始化备用后端服务器 */</span><span>for</span> (i = <span>0</span>; i < us->servers->nelts; i++) {
            <span>if</span> (!<span>server</span>[i].backup) {<span>/* 若是非备用后端服务器，则 continue 跳过当前后端服务器，检查下一个后端服务器 */</span><span>continue</span>;
            }

            <span>/* 遍历备用后端服务器所对应 IP 地址数组中的所有 IP 地址(即一个后端服务器域名可能会对应多个 IP 地址) */</span><span>for</span> (j = <span>0</span>; j < <span>server</span>[i].naddrs; j++) {
                backup->peer[n].sockaddr = <span>server</span>[i].addrs[j].sockaddr;<span>/* 设置备用后端服务器 IP 地址 */</span>
                backup->peer[n].socklen = <span>server</span>[i].addrs[j].socklen;<span>/* 设置备用后端服务器 IP 地址长度 */</span>
                backup->peer[n].name = <span>server</span>[i].addrs[j].name;<span>/* 设置备用后端服务器域名 */</span>
                backup->peer[n].weight = <span>server</span>[i].weight;<span>/* 设置备用后端服务器配置项权重 */</span>
                backup->peer[n].effective_weight = <span>server</span>[i].weight;<span>/* 设置备用后端服务器有效权重 */</span>
                backup->peer[n].current_weight = <span>0</span>;<span>/* 设置备用后端服务器当前权重 */</span>
                backup->peer[n].max_fails = <span>server</span>[i].max_fails;<span>/* 设置备用后端服务器最大失败次数 */</span>
                backup->peer[n].fail_timeout = <span>server</span>[i].fail_timeout;<span>/* 设置备用后端服务器失败时间阈值 */</span>
                backup->peer[n].down = <span>server</span>[i].down;<span>/* 设置备用后端服务器 down 标志位，若该标志位为 1，则不参与策略 */</span>
                n++;
            }
        }

        <span>/*
         * 将备用服务器列表挂载到 ngx_http_upstream_rr_peers_t 结构体中
         * 的成员 next 中；
         */</span>
        peers->next = backup;

        <span>/* 第一种情况到此返回 */</span><span>return</span> NGX_OK;
    }


     <span>/* 第二种情况：若 upstream 机制中没有直接配置后端服务器，则采用默认的方式 proxy_pass 配置后端服务器地址 */</span><span>/* an upstream implicitly defined by proxy_pass, etc. */</span><span>/* 若端口号为 0，则出错返回 */</span><span>if</span> (us->port == <span>0</span>) {
        ngx_log_error(NGX_LOG_EMERG, cf->log, <span>0</span>,
                      <span>"no port in upstream \"%V\" in %s:%ui"</span>,
                      &us->host, us->file_name, us->line);
        <span>return</span> NGX_ERROR;
    }

    <span>/* 初始化 ngx_url_t 结构体所有成员为 0 */</span>
    ngx_memzero(&u, sizeof(ngx_url_t));

    u.host = us->host;
    u.port = us->port;

    <span>/* 解析 IP 地址 */</span><span>if</span> (ngx_inet_resolve_host(cf->pool, &u) != NGX_OK) {
        <span>if</span> (u.err) {
            ngx_log_error(NGX_LOG_EMERG, cf->log, <span>0</span>,
                          <span>"%s in upstream \"%V\" in %s:%ui"</span>,
                          u.err, &us->host, us->file_name, us->line);
        }

        <span>return</span> NGX_ERROR;
    }

    n = u.naddrs;

    <span>/* 分配非备用后端服务器列表的内存空间 */</span>
    peers = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_rr_peers_t)
                              + sizeof(ngx_http_upstream_rr_peer_t) * (n - <span>1</span>));
    <span>if</span> (peers == NULL) {
        <span>return</span> NGX_ERROR;
    }

    <span>/* 初始化非备用后端服务器列表 */</span>
    peers->single = (n == <span>1</span>);
    peers->number = n;
    peers->weighted = <span>0</span>;
    peers->total_weight = n;
    peers->name = &us->host;

    <span>for</span> (i = <span>0</span>; i < u.naddrs; i++) {
        peers->peer[i].sockaddr = u.addrs[i].sockaddr;
        peers->peer[i].socklen = u.addrs[i].socklen;
        peers->peer[i].name = u.addrs[i].name;
        peers->peer[i].weight = <span>1</span>;
        peers->peer[i].effective_weight = <span>1</span>;
        peers->peer[i].current_weight = <span>0</span>;
        peers->peer[i].max_fails = <span>1</span>;
        peers->peer[i].fail_timeout = <span>10</span>;
    }

    <span>/* 挂载非备用后端服务器列表 */</span>
    us->peer.data = peers;

    <span>/* implicitly defined upstream has no backup servers */</span><span>return</span> NGX_OK;
}</code>

<code>/* 释放后端服务器 */
<span>void</span><span>ngx_http_upstream_free_round_robin_peer</span>(ngx_peer_connection_t *pc, void *<span><span>data</span>,</span>
    ngx_uint_t state)
{
    ngx_http_upstream_rr_peer_data_t  *rrp = <span><span>data</span>;</span>    time_t                       now;
    ngx_http_upstream_rr_peer_t  *peer;

    ngx_log_debug2(<span>NGX_LOG_DEBUG_HTTP</span>, pc->log, <span>0</span>,
                   <span>"free rr peer %ui %ui"</span>, pc->tries, state);

    /* <span>TODO</span>: <span>NGX_PEER_KEEPALIVE</span> */

    /* 若只有一个后端服务器，则设置 ngx_peer_connection_t 结构体成员 tries 为 <span>0</span>，并 return 返回 */
    <span>if</span> (rrp->peers->single) {
        pc->tries = <span>0</span>;
        return;
    }

    /* 若不止一个后端服务器，则执行以下程序 */

    /* 获取已经被选中的后端服务器 */
    peer = &rrp->peers->peer[rrp->current];

    /*
     * 若在本轮被选中的后端服务器在进行连接测试时失败，或者在处理请求过程中失败，
     * 则需要进行重新选择后端服务器；
     */
    <span>if</span> (state & <span>NGX_PEER_FAILED</span>) {
        now = ngx_time();

        /* ngx_lock_mutex(rrp->peers->mutex); */

        peer->fails++;/* 增加当前后端服务器失败的次数 */
        /* 设置当前后端服务器访问的时间 */
        peer->accessed = now;
        peer->checked = now;

        <span>if</span> (peer->max_fails) {
            /* 由于当前后端服务器失败，表示发生异常，此时降低 effective_weight 的值 */
            peer->effective_weight -= peer->weight / peer->max_fails;
        }

        ngx_log_debug2(<span>NGX_LOG_DEBUG_HTTP</span>, pc->log, <span>0</span>,
                       <span>"free rr peer failed: %ui %i"</span>,
                       rrp->current, peer->effective_weight);

        /* 保证 effective_weight 的值不能小于 <span>0</span> */
        <span>if</span> (peer->effective_weight < <span>0</span>) {
            peer->effective_weight = <span>0</span>;
        }

        /* ngx_unlock_mutex(rrp->peers->mutex); */

    } <span>else</span> {/* 若被选中的后端服务器成功处理请求，并返回，则将其 fails 设置为 <span>0</span> */

        /* mark peer live <span>if</span> check passed */

        /* 若 fail_timeout 时间已过，则将其 fails 设置为 <span>0</span> */
        <span>if</span> (peer->accessed < peer->checked) {
            peer->fails = <span>0</span>;
        }
    }

    /* 减少 tries 的值 */
    <span>if</span> (pc->tries) {
        pc->tries<span>--;</span>
    }

    /* ngx_unlock_mutex(rrp->peers->mutex); */
}</code>

<code><span>static</span> ngx_int_t
ngx_http_upstream_init_ip_hash(ngx_conf_t *cf, ngx_http_upstream_srv_conf_t *us)
{
    <span>/* 调用加权轮询策略的初始化函数 */</span><span>if</span> (ngx_http_upstream_init_round_robin(cf, us) != NGX_OK) {
        <span>return</span> NGX_ERROR;
    }

    <span>/* 由于 ngx_http_upstream_init_round_robin 方法的选择后端服务器处理客户请求的初始化函数
     * 为 us->peer.init = ngx_http_upstream_init_round_robin_peer;
     */</span><span>/* 重新设置 ngx_http_upstream_peer_t 结构体中 init 的回调方法为  ngx_http_upstream_init_ip_hash_peer */</span>    us->peer.init = ngx_http_upstream_init_ip_hash_peer;

    <span>return</span> NGX_OK;
}</code>

<code>static ngx_int_t
ngx_http_upstream_init_ip_hash_peer(ngx_http_request_t <span>*</span>r,
    ngx_http_upstream_srv_conf_t <span>*</span>us)
{
    struct sockaddr_in                     <span>*</span>sin;
<span>#if</span> (NGX_HAVE_INET6)
    struct sockaddr_in6                    <span>*</span>sin6;
<span>#endif</span>
    ngx_http_upstream_ip_hash_peer_data_t  <span>*</span>iphp;

    <span>/* 分配 ngx_http_upstream_ip_hash_peer_data_t 结构体内存空间 */</span>
    iphp <span>=</span> ngx_palloc(r<span>-></span>pool, sizeof(ngx_http_upstream_ip_hash_peer_data_t));
    <span>if</span> (iphp <span>==</span><span>NULL</span>) {
        <span>return</span> NGX_ERROR;
    }

    r<span>-></span>upstream<span>-></span>peer<span>.</span><span>data</span><span>=</span><span>&</span>iphp<span>-></span>rrp;

    <span>/* 调用加权轮询策略的初始化函数 ngx_http_upstream_init_round_robin_peer */</span><span>if</span> (ngx_http_upstream_init_round_robin_peer(r, us) <span>!=</span> NGX_OK) {
        <span>return</span> NGX_ERROR;
    }

    <span>/* 设置 IP hash 的决策函数  */</span>
    r<span>-></span>upstream<span>-></span>peer<span>.</span>get <span>=</span> ngx_http_upstream_get_ip_hash_peer;

    switch (r<span>-></span>connection<span>-></span>sockaddr<span>-></span>sa_family) {

    <span>/* 保存客户端 IP 地址 */</span><span>/* IPv4 地址 */</span><span>case</span> AF_INET:
        sin <span>=</span> (struct sockaddr_in <span>*</span>) r<span>-></span>connection<span>-></span>sockaddr;
        iphp<span>-></span>addr <span>=</span> (u_char <span>*</span>) <span>&</span>sin<span>-></span>sin_addr<span>.</span>s_addr;
        iphp<span>-></span>addrlen <span>=</span><span>3</span>;
        break;

    <span>/* IPv6 地址 */</span><span>#if</span> (NGX_HAVE_INET6)
    <span>case</span> AF_INET6:
        sin6 <span>=</span> (struct sockaddr_in6 <span>*</span>) r<span>-></span>connection<span>-></span>sockaddr;
        iphp<span>-></span>addr <span>=</span> (u_char <span>*</span>) <span>&</span>sin6<span>-></span>sin6_addr<span>.</span>s6_addr;
        iphp<span>-></span>addrlen <span>=</span><span>16</span>;
        break;
<span>#endif</span><span>/* 非法地址 */</span>
    default:
        iphp<span>-></span>addr <span>=</span> ngx_http_upstream_ip_hash_pseudo_addr;
        iphp<span>-></span>addrlen <span>=</span><span>3</span>;
    }

    <span>/* 初始化 ngx_http_upstream_ip_hash_peer_data_t结构体成员 */</span>
    iphp<span>-></span>hash <span>=</span><span>89</span>;
    iphp<span>-></span>tries <span>=</span><span>0</span>;
    <span>/* 这个是设置为加权轮询策略的决策函数 */</span>
    iphp<span>-></span>get_rr_peer <span>=</span> ngx_http_upstream_get_round_robin_peer;

    <span>return</span> NGX_OK;
}</code>

<code>/* 选择后端服务器处理请求 */
<span>static</span> ngx_int_t
<span>ngx_http_upstream_get_ip_hash_peer</span>(ngx_peer_connection_t *pc, void *<span><span>data</span>)</span>
{
    ngx_http_upstream_ip_hash_peer_data_t  *iphp = <span><span>data</span>;</span>    time_t                        now;
    ngx_int_t                     w;
    uintptr_t                     m;
    ngx_uint_t                    i, n, p, hash;
    ngx_http_upstream_rr_peer_t  *peer;

    ngx_log_debug1(<span>NGX_LOG_DEBUG_HTTP</span>, pc->log, <span>0</span>,
                   <span>"get ip hash peer, try: %ui"</span>, pc->tries);

    /* <span>TODO</span>: cached */

    /* 若重试连接的次数 tries 大于 <span>20</span>，或 只有一台后端服务器，则直接调用加权轮询策略选择当前后端服务器处理请求 */
    <span>if</span> (iphp->tries > <span>20</span> || iphp->rrp.peers->single) {
        return iphp->get_rr_peer(pc, &iphp->rrp);
    }

    now = ngx_time();

    pc->cached = <span>0</span>;
    pc->connection = <span>NULL</span>;

    hash = iphp->hash;

    for ( ;; ) {

        /* 计算 <span>IP</span> 地址的 hash 值 */
        for (i = <span>0</span>; i < (ngx_uint_t) iphp->addrlen; i++) {
            hash = (hash * <span>113</span> + iphp->addr[i]) % <span>6271</span>;/* hash 函数 */
        }

        /* 以下是根据 hash 值选择合适的后端服务器来处理请求 */

        /* 若 ngx_http_upstream_rr_peers_t 结构体中 weighted 标志位为 <span>1</span>，
         * 表示所有后端服务器的总权重 与 后端服务器的数量 相等，
         * 则被选中的后端服务器在后端服务器列表中的位置为 hash 值与后端服务器数量的余数 p；
         */
        <span>if</span> (!iphp->rrp.peers->weighted) {
            p = hash % iphp->rrp.peers->number;

        } <span>else</span> {
            /* 若 ngx_http_upstream_rr_peers_t 结构体中 weighted 标志位为 <span>0</span>，
             * 首先计算 hash 值与后端服务器总权重的余数 w；
             * 将 w 值减去后端服务器的权重，直到有一个后端服务器使 w 值小于 <span>0</span>，
             * 则选中该后端服务器来处理请求，并记录在后端服务器列表中的位置 p；
             */
            w = hash % iphp->rrp.peers->total_weight;

            for (i = <span>0</span>; i < iphp->rrp.peers->number; i++) {
                w -= iphp->rrp.peers->peer[i].weight;
                <span>if</span> (w < <span>0</span>) {
                    break;
                }
            }

            p = i;
        }

        /* 计算被选中后端服务器在位图中的位置 n */
        n = p / (<span>8</span> * sizeof(uintptr_t));
        m = (uintptr_t) <span>1</span> << p % (<span>8</span> * sizeof(uintptr_t));

        /* 若当前被选中的后端服务器已经在位图记录过，则跳至 goto next 执行 */
        <span>if</span> (iphp->rrp.tried[n] & m) {
            goto next;
        }

        ngx_log_debug2(<span>NGX_LOG_DEBUG_HTTP</span>, pc->log, <span>0</span>,
                       <span>"get ip hash peer, hash: %ui %04XA"</span>, p, m);

        /* 获取当前被选中的后端服务器 */
        peer = &iphp->rrp.peers->peer[p];

        /* ngx_lock_mutex(iphp->rrp.peers->mutex); */

        /* 检查当前被选中后端服务器的 down 标志位，若该标志位为<span>1</span>，则跳至 goto next_try 执行 */
        <span>if</span> (peer->down) {
            goto next_try;
        }

        /* 若 down 标志位为 <span>0</span>，接着检查当前被选中后端服务器失败连接次数是否到达 max_fails，
         * 若已经达到 max_fails 次，并且睡眠时间还没到 fail_timeout，则跳至 goto next_try 执行；
         */
        <span>if</span> (peer->max_fails
            && peer->fails >= peer->max_fails
            && now - peer->checked <= peer->fail_timeout)
        {
            goto next_try;
        }

        /* 若不满足以上条件，则表示选择后方服务器成功 */
        break;

    next_try:

        /* 把当前后端服务器记录在位图中 */
        iphp->rrp.tried[n] |= m;

        /* ngx_unlock_mutex(iphp->rrp.peers->mutex); */

        /* 减少当前后端服务器重试连接的次数 */
        pc->tries<span>--;</span>    next:

        /* tries 重试连接的次数加 <span>1</span>，并判断 tries 是否大于阈值 <span>20</span>，若大于，则采用加权轮询策略 */
        <span>if</span> (++iphp->tries >= <span>20</span>) {
            return iphp->get_rr_peer(pc, &iphp->rrp);
        }
    }

    /* 到此已经成功选择了后端服务器来处理请求 */

    /* 记录当前后端服务器在后端服务器列表中的位置，该位置方便释放后端服务器调用 */
    iphp->rrp.current = p;

    /* 记录当前后端服务器的地址信息 */
    pc->sockaddr = peer->sockaddr;
    pc->socklen = peer->socklen;
    pc->name = &peer->name;

    <span>if</span> (now - peer->checked > peer->fail_timeout) {
        peer->checked = now;
    }

    /* ngx_unlock_mutex(iphp->rrp.peers->mutex); */

    /* 把当前后端服务器记录在位图相应的位置 */
    iphp->rrp.tried[n] |= m;
    /* 记录 hash 值 */
    iphp->hash = hash;

    return <span>NGX_OK</span>;
}</code>