Nginx 之 Location 的整理

1. Location 的整理

在将配置解析完后,所有的 location 此时都以 tree 的形式组织起来,具体可参考 Nginx之 Location 的生成。

此时需要对所有 server 下的 location 进行整理(如把同类型的 location 放置在一起以便于查找等)。

static char *
ngx_http_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
    ...
    
    /* create location trees */

    for (s = 0; s < cmcf->servers.nelts; s++) {

        /* cscfp 指向当前 http{} 下所属于的 ngx_http_conf_ctx_t 结构体的 main_conf 
         * 数组中 ngx_http_core_module.ctx_index 索引处的上下文结构体 
         * ngx_http_core_main_conf_t 结构体中的 servers 成员数组,该数组保存着当前 http{}
         * 下所有的 server{} 的配置上下文结构体 ngx_http_core_srv_conf_t,每一个该结构体
         * 代表一个 server{} */
        clcf = cscfp[s]->ctx->loc_conf[ngx_http_core_module.ctx_index];

        /* 这里会对所有的 location 进行排序,然后:
         * 1. 先将未命名 location 从 locations 队列中拆分出来;
         * 2. 接着将命名 location 从 locations 队列中拆分出来(拆分之前会将所有的
         *    命名 location 逐一保存到 cscf->named_location 数组中)
         * 3. 最后将 regex location 拆分出来(拆分之前会将所有的 regex location 的配置数据
         *    以数组的形式逐一保存到 clcf->regex_locations 数组中)
         * 经过拆分之后,此时 locations 队列中只剩下被称之为 static 的 location (包括绝对匹配 
         * location 和普通的 location)*/
        if (ngx_http_init_locations(cf, cscfp[s], clcf) != NGX_OK) {
            return NGX_CONF_ERROR;
        }

        if (ngx_http_init_static_location_trees(cf, clcf) != NGX_OK) {
            return NGX_CONF_ERROR;
        }
    }
    
    ...
}

1.1 ngx_http_init_locations

/*
 * @cscf: 代表一个 server{}
 * @pclcf: 当前 server{}(即 cscf)下的一个 location
 */
static ngx_int_t
ngx_http_init_locations(ngx_conf_t *cf, ngx_http_core_srv_conf_t *cscf,
    ngx_http_core_loc_conf_t *pclcf)
{
    ngx_uint_t                   n;
    ngx_queue_t                 *q, *locations, *named, tail;
    ngx_http_core_loc_conf_t    *clcf;
    ngx_http_location_queue_t   *lq;
    ngx_http_core_loc_conf_t   **clcfp;
#if (NGX_PCRE)
    ngx_uint_t                   r;
    ngx_queue_t                 *regex;
#endif

    /* 获取当前 server{} 下管理的所有 location 的 locations 队列 */
    locations = pclcf->locations;

    /* 若当前 server{} 没有配置 location,则返回 NGX_OK */
    if (locations == NULL) {
        return NGX_OK;
    }

    /* 对该 server 下的 location 进行排序,大致排序如下:
     * 绝对匹配 location,正则 location,命名location,未命名location */
    ngx_queue_sort(locations, ngx_http_cmp_locations);

    named = NULL;
    n = 0;
#if (NGX_PCRE)
    regex = NULL;
    r = 0;
#endif

    for (q = ngx_queue_head(locations);
         q != ngx_queue_sentinel(locations);
         q = ngx_queue_next(q))
    {
        lq = (ngx_http_location_queue_t *) q;

        clcf = lq->exact ? lq->exact : lq->inclusive;

        /* 若该 location 下有嵌套的 location,则同样对其进行排序,否则直接返回 */
        if (ngx_http_init_locations(cf, NULL, clcf) != NGX_OK) {
            return NGX_ERROR;
        }

#if (NGX_PCRE)

        /* 若为正则location,则 r 加 1,同时记录第一个正则 location */
        if (clcf->regex) {
            r++;

            if (regex == NULL) {
                regex = q;
            }

            continue;
        }

#endif

        /* 若为命名 location,则 n 加 1,同时记录第一个命名 location */
        if (clcf->named) {
            n++;

            if (named == NULL) {
                named = q;
            }

            continue;
        }

        /* 若当前 location 为未命名 location,则退出循环 */
        if (clcf->noname) {
            break;
        }
    }

    /* 上面遍历完排序后的 locations 时,假设此时 q 指向一个未命名 location,则
     * 这里会将 locatons 队列中的所有未命名 location 从 locations 队列中拆分
     * 出来,将其保存到 q 和 tail 构成的双向循环链表中;
     * 而此时 locations 剩下的是除未命名 locations 以外的所有 location */
    if (q != ngx_queue_sentinel(locations)) {
        ngx_queue_split(locations, q, &tail);
    }
    
    /* 从这里之后 locations 队列就不存在有未命名 location 了,配置解析时之所以将
     * 未命名 location 也加入到 locations 队列中,是因为在进行配置合并的时候,可以
     * 让它们也可以继承接受来自上层 location 的相关设置值,因此在配置合并完之后,
     * 这里也就把未命名 location 中 locations 队列中移除了
     * 注意,这里虽然没有对拆分后的未命名 location 进行保存,看似这些数据丢失了,
     * 但是,在其他地方的其他字段,如 limit_except_loc_conf 或脚本引擎里已经保存
     * 了对这些 location 数据的引用 */

    if (named) {
        /* 为命名 location 分配内存 */
        clcfp = ngx_palloc(cf->pool,
                           (n + 1) * sizeof(ngx_http_core_loc_conf_t *));
        if (clcfp == NULL) {
            return NGX_ERROR;
        }

        cscf->named_locations = clcfp;
        
        /* named location 有两个限定:
         * 1. named location 只会出现在 server 上下文里
         * 2. named location 配置数据(即 clcf)固定保存在 exact 字段下 */

        /* 将 locations 队列中的所有命名 location 都存放到上面
         * named_locations 数组指针指向的新分配的内存中 */
        for (q = named;
             q != ngx_queue_sentinel(locations);
             q = ngx_queue_next(q))
        {
            lq = (ngx_http_location_queue_t *) q;

            /* 将命名 location 的配置项结构体保存到 named_locations 数组中 */
            *(clcfp++) = lq->exact;
        }

        *clcfp = NULL;

        /* 将命名 location 从 locations 队列中拆分出来 */
        ngx_queue_split(locations, named, &tail);
    }

#if (NGX_PCRE)

    if (regex) {

        /* 这里为所有的正则匹配 location 分配存储空间 */
        clcfp = ngx_palloc(cf->pool,
                           (r + 1) * sizeof(ngx_http_core_loc_conf_t *));
        if (clcfp == NULL) {
            return NGX_ERROR;
        }

        /* 下面的循环中将 locations 队列中所有的正则匹配 location 
         * 存放到 regex_locations 指针数组中 */
        pclcf->regex_locations = clcfp;

        for (q = regex;
             q != ngx_queue_sentinel(locations);
             q = ngx_queue_next(q))
        {
            lq = (ngx_http_location_queue_t *) q;

            *(clcfp++) = lq->exact;
        }

        *clcfp = NULL;

        /* 然后将正则匹配 location 中 locations 队列中移除,
         * 此时 locations 队列只剩下被称为静态(static)的 location
         * 配置(包括绝对匹配 location 和不属于正则、命名、未命名外的
         * location 配置)*/
        ngx_queue_split(locations, regex, &tail);
    }

#endif

    return NGX_OK;
}

1.1.1 ngx_queue_sort

/* the stable insertion sort */

void
ngx_queue_sort(ngx_queue_t *queue,
    ngx_int_t (*cmp)(const ngx_queue_t *, const ngx_queue_t *))
{
    ngx_queue_t  *q, *prev, *next;

    /* 获取该队列中的第一个节点 */
    q = ngx_queue_head(queue);

    /* 若该队列为空,则直接返回 */
    if (q == ngx_queue_last(queue)) {
        return;
    }

    /* 遍历该队列中的所有节点 */
    for (q = ngx_queue_next(q); q != ngx_queue_sentinel(queue); q = next) {

        prev = ngx_queue_prev(q);
        next = ngx_queue_next(q);

        /* 将当前节点从队列中移除 */
        ngx_queue_remove(q);

        do {
            /* 将当前节点与它的上一个节点进行比较
             * 返回 0,则表示插入到 prev 之后 */
            if (cmp(prev, q) <= 0) {
                break;
            }
            
            /* 返回 1,则继续取 prev 的上一个节点,再次进行比较 */
            prev = ngx_queue_prev(prev);

        } while (prev != ngx_queue_sentinel(queue));

        /* 将该 q 插入到 prev 的后面 */
        ngx_queue_insert_after(prev, q);
    }
}

对于 locations 队列中的所有节点(即location),进行比较的函数为 ngx_http_cmp_locations:

static ngx_int_t
ngx_http_cmp_locations(const ngx_queue_t *one, const ngx_queue_t *two)
{
    ngx_int_t                   rc;
    ngx_http_core_loc_conf_t   *first, *second;
    ngx_http_location_queue_t  *lq1, *lq2;

    lq1 = (ngx_http_location_queue_t *) one;
    lq2 = (ngx_http_location_queue_t *) two;

    /* 获取该location挂载在 exact 或 inclusive 字段下的  
     * ngx_http_core_loc_conf_t 配置结构体 */
    first = lq1->exact ? lq1->exact : lq1->inclusive;
    second = lq2->exact ? lq2->exact : lq2->inclusive;

    /* 若前一个 location 为未命名 location,且当前 location 不为
     * 未命名 location 时,则将一个 location(即 first)后移 */
    if (first->noname && !second->noname) {
        /* shift no named locations to the end */
        return 1;
    }

    /* 未命名 location 排到后面 */
    if (!first->noname && second->noname) {
        /* shift no named locations to the end */
        return -1;
    }

    /* 都为未命名 location 则,排序不变 */
    if (first->noname || second->noname) {
        /* do not sort no named locations */
        return 0;
    }

    /* 命名 location 后移 */
    if (first->named && !second->named) {
        /* shift named locations to the end */
        return 1;
    }

    if (!first->named && second->named) {
        /* shift named locations to the end */
        return -1;
    }

    /* 若两个 location 都为命名 location,则按它们名称的字符序进行排序,
     * 名称字符序大的排到后面 */
    if (first->named && second->named) {
        return ngx_strcmp(first->name.data, second->name.data);
    }

#if (NGX_PCRE)

    /* 正则 location 排到后面 */
    if (first->regex && !second->regex) {
        /* shift the regex matches to the end */
        return 1;
    }

    if (!first->regex && second->regex) {
        /* shift the regex matches to the end */
        return -1;
    }

    if (first->regex || second->regex) {
        /* do not sort the regex matches */
        return 0;
    }

#endif

    /* 其他情况,按名称的字符序进行排序 */
    rc = ngx_filename_cmp(first->name.data, second->name.data,
                          ngx_min(first->name.len, second->name.len) + 1);

    /* 但有一个特殊处理,即对于出现比较的两个 location 名称相同的情况,
     * 如果存在有绝对匹配 location,则将其放到前面 */
    if (rc == 0 && !first->exact_match && second->exact_match) {
        /* an exact match must be before the same inclusive one */
        return 1;
    }

    return rc;
}

对 locations 队列中任意两个 location 进行排序的规则如下:

  1. 两个比较 location 中的未命名 location(即 noname 为 1)排到后面。
  2. 如果比较的两个 location 都为未命名 location,那么保持原定次序,即保持用户在配置文件里书写的先后顺序(按文件从头到尾)。
  3. 两个比较 location 中的命名 location(即 named 为 1)排到后面。
  4. 如果比较的两个 location 都为命名 location,那么按它们名称的字符序进行排序,即通过函数 strcmp() 比较它们的名称,名称字符序大的排到后面。
  5. 两个比较 location 中的正则匹配 location(即 regex 字段不为空)排到后面。
  6. 如果比较的两个 location 都为正则匹配 location,那么保持原定次序,即保持用户在配置文件里书写的先后顺序(按文件从头到尾)。
  7. 其他情况,按名称的字符序进行排序。但是有一个特别处理,即对于出现比较的两个 loaction 名称相同的情况,如果存在有绝对匹配 location,那么要把它放在前面。

1.1.2 ngx_http_init_static_location_trees

static ngx_int_t
ngx_http_init_static_location_trees(ngx_conf_t *cf,
    ngx_http_core_loc_conf_t *pclcf)
{
    ngx_queue_t                *q, *locations;
    ngx_http_core_loc_conf_t   *clcf;
    ngx_http_location_queue_t  *lq;

    locations = pclcf->locations;

    if (locations == NULL) {
        return NGX_OK;
    }

    if (ngx_queue_empty(locations)) {
        return NGX_OK;
    }

    for (q = ngx_queue_head(locations);
         q != ngx_queue_sentinel(locations);
         q = ngx_queue_next(q))
    {
        lq = (ngx_http_location_queue_t *) q;

        clcf = lq->exact ? lq->exact : lq->inclusive;

        /* 这里是处理 location 嵌套的情况 */
        if (ngx_http_init_static_location_trees(cf, clcf) != NGX_OK) {
            return NGX_ERROR;
        }
    }

    /* 该函数把同一层次里的名称相同的不同 location 合并在一起。
     * "名称相同,但又是不同的 location"?
     * 这主要是因为 location 有绝对匹配(对应 exact 字段)和包含匹配(也就是前缀
     * 匹配,以指定前缀开头的都匹配上,所以是包含匹配,对应 inclusive 字段)。若
     * 这两个 location 的名称相同(如都为 "/"),则可以把它们共用在一个队列节点里 */
    if (ngx_http_join_exact_locations(cf, locations) != NGX_OK) {
        return NGX_ERROR;
    }

    /* Nginx 对包含匹配的查找采用的是最佳匹配原则,也就是说,如果有两个 location 
     * A 和 B 的包含匹配串分别为 "/" 和 "/images/",那么对于 uri 地址 "/images/top.jpg"
     * 在这两个 location 里的查找将匹配到 location B。为了提高这种查找速度,所以
     * 下面两个函数是把队列转换成 tree */
    /*  */
    ngx_http_create_locations_list(locations, ngx_queue_head(locations));

    pclcf->static_locations = ngx_http_create_locations_tree(cf, locations, 0);
    if (pclcf->static_locations == NULL) {
        return NGX_ERROR;
    }

    return NGX_OK;
}

1.1.3 ngx_http_join_exact_locations

static ngx_int_t
ngx_http_join_exact_locations(ngx_conf_t *cf, ngx_queue_t *locations)
{
    ngx_queue_t                *q, *x;
    ngx_http_location_queue_t  *lq, *lx;

    q = ngx_queue_head(locations);

    while (q != ngx_queue_last(locations)) {

        x = ngx_queue_next(q);

        lq = (ngx_http_location_queue_t *) q;
        lx = (ngx_http_location_queue_t *) x;

        /* 比较名称是否相同 */
        if (lq->name->len == lx->name->len
            && ngx_filename_cmp(lq->name->data, lx->name->data, lx->name->len)
               == 0)
        {
            /* 若都为绝对匹配或都为包含匹配,则表示出错 */
            if ((lq->exact && lx->exact) || (lq->inclusive && lx->inclusive)) {
                ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
                              "duplicate location \"%V\" in %s:%ui",
                              lx->name, lx->file_name, lx->line);

                return NGX_ERROR;
            }

            /* 将名称相同的两个 location 公用同一个节点 */
            lq->inclusive = lx->inclusive;

            /* 移除后一个名称相同的节点*/
            ngx_queue_remove(x);

            continue;
        }

        /* 若名称不同,则继续取下一个进行比较 */
        q = ngx_queue_next(q);
    }

    return NGX_OK;
}

经过上面的一系列整理后,所有的 location 都被恰当地整理后放置在对应的字段下:

  • 未命名 location 被 limit_except_loc_conf 或脚本引擎引用
  • 命名 location 被放置在 server 配置的 cscf->named_locations 字段下
  • 正则匹配 location 被放置在 server 或 location 配置的 pclcf->regex_locations 字段下
  • 静态匹配(包括绝对匹配和前缀匹配)location 被放置在 server 或 location 配置的 pclcf->static_locations 字段下

Nginx 之 Location 的整理

原文:https://www.cnblogs.com/jimodetiantang/p/9247916.html

人吐槽 人点赞

猜你喜欢

发表评论

用户名: 密码:
验证码: 匿名发表

你可以使用这些语言

查看评论:Nginx 之 Location 的整理