当前位置: > Linux服务器 > nginx >

nginx 配置文件解析

时间:2016-06-06 12:06来源:linux.it.net.cn 作者:IT

首先来看一下,配置文件解析时的数据结构,这里主要是ngx_conf_t,这个结构保存了解析配置文件所需要的一些域,是一个非常重要的数据结构.

struct  ngx_conf_s{
       char                          *name;//当前解析的命令名
       ngx_array_t              *args;  //当前命令的所有参数
       
       ngx_cycle_t               *cycle;
       ngx_pool_t                *pool;   
       ngx_pool_t                *temp_pool;
       ngx_conf_file_t          *conf_file;////这个表示将要解析的配置文件
       ngx_log_t                   *log;

       void                            *ctx;
       ngx_uint_t                  module_type;
       ngx_uint_t                   cmd_type;
       
       ngx_conf_handler_pt        handler;
       char                       *handler_conf          
}

我们来看配置文件的解析人口,入口在ngx_init_cycle中,就是设置ngx_conf_t然后传递给ngx_conf_parse解析.

//创建conf_ctx
cycle->conf_ctx = ngx_pcalloc(pool, ngx_max_module * sizeof(void *));
    if (cycle->conf_ctx == NULL) {
        ngx_destroy_pool(pool);
        return NULL;
    }
 for (i = 0; ngx_modules[i]; i++) {
        if (ngx_modules[i]->type != NGX_CORE_MODULE) {
            continue;
        }

        module = ngx_modules[i]->ctx;

        if (module->create_conf) {
            rv = module->create_conf(cycle);
            if (rv == NULL) {
                ngx_destroy_pool(pool);
                return NULL;
            }
           //这里看到的conf_ctx里面就是放对应模块的main conf
            cycle->conf_ctx[ngx_modules[i]->index] = rv;
        }
    }
    conf.ctx = cycle->conf_ctx;  //初始化conf
    conf.cycle = cycle;
    conf.pool = pool;
    conf.log = log;
    conf.module_type = NGX_CORE_MODULE;//注意,一开始命令的类型就是MAIN,并且模块类型是core。
    conf.cmd_type = NGX_MAIN_CONF;

    if (ngx_conf_param(&conf) != NGX_CONF_OK) {
        environ = senv;
        ngx_destroy_cycle_pools(&conf);
        return NULL;
    }
     //开始解析文件
    if (ngx_conf_parse(&conf, &cycle->conf_file) != NGX_CONF_OK) {
        environ = senv;
        ngx_destroy_cycle_pools(&conf);
        return NULL;
    }

    然后我们来看一下 ngx_conf_parse这个函数,这个函数的第二个参数是解析文件名(nginx.conf),不过这里要注意一点,那就是第二个参数是可以为空的,

 如果为空,则说明将要解析的是block或者param.   

har *
ngx_conf_parse(ngx_conf_t *cf, ngx_str_t *filename)
{
    char             *rv;
    ngx_fd_t          fd;
    ngx_int_t         rc;
    ngx_buf_t         buf;
    ngx_conf_file_t  *prev, conf_file;
    enum {
        parse_file = 0,
        parse_block,
        parse_param
    } type;
    .......
    if (filename) {
            /* open configuration file */
    } else if (cf->conf_file->file.fd != NGX_INVALID_FILE) {
        type = parse_block;
    } else {
        type = parse_param;
    }

   
    for ( ;; ) {
        rc = ngx_conf_read_token(cf);

        /*
         * ngx_conf_read_token() may return
         *
         *    NGX_ERROR             there is error
         *    NGX_OK                the token terminated by ";" was found
         *    NGX_CONF_BLOCK_START  the token terminated by "{" was found
         *    NGX_CONF_BLOCK_DONE   the "}" was found
         *    NGX_CONF_FILE_DONE    the configuration file is done
         */
     ........
     if (cf->handler) {//如果有handler,则调用handler
              rv = (*cf->handler)(cf, NULL, cf->handler_conf);
     }
     ...........
     rc = ngx_conf_handler(cf, rc);//没有handler则调用默认解析函数
}

在看ngx_conf_handler之前,我们先看一下nginx的配置文件,以及为什么调用cf->handler。

worker_processes 1;

error_log logs/error.log;

pid logs/nginx.pid;

events {
worker_connections 1024;
}

http {
include mime.types;
default_type application/octet-stream;

sendfile on;

keepalive_timeout 65;

#gzip on;

server {
listen 80;
server_name localhost;

access_log logs/host.access.log main;

location / {
root html;
index index.html index.htm;
}

error_page 500 502 503 504 /50x.html;
location = /50x.html {
root html;
}
}

}

可以看到nginx配置文件是分级的,然后event,http都是一个core模块,然后core模块中包含了很多2级模块(epoll,kqueue).也就是1级模块中必须包含一个上下文用来保存2级模块的配置信息。而在http模块中又有一些特殊,就是http模块中每个指令都具有3个作用域,那就是main/server/loc,所以在http上下文中,必须保存3个上下文.

然后看一下nginx的命令有那些类型:

#define NGX_DIRECT_CONF      0x00010000
 
#define NGX_MAIN_CONF        0x01000000
#define NGX_ANY_CONF         0x0F000000
 
#define NGX_EVENT_CONF        0x02000000
 
#define NGX_HTTP_MAIN_CONF        0x02000000
#define NGX_HTTP_SRV_CONF         0x04000000
#define NGX_HTTP_LOC_CONF         0x08000000
#define NGX_HTTP_UPS_CONF         0x10000000
#define NGX_HTTP_SIF_CONF         0x20000000
#define NGX_HTTP_LIF_CONF         0x40000000
#define NGX_HTTP_LMT_CONF         0x80000000
 
#define NGX_MAIL_MAIN_CONF      0x02000000
#define NGX_MAIL_SRV_CONF       0x04000000

nginx中的参数类型有这么多种,其中最有必要的是(NGX_DIRECT_CONF,NGX_MAIN_CONF),一般来说这2个命令类型是同时使用的。DIRECT_CONF就是直接存取CONF,也就是说进入命令解析函数的同时,conf已经被创建好了,直需直接使用即可.而MAIN_CONF就是最顶层的CONF。如HTTP/EVENT/pid等,可以看到都是core模块。而NGX_HTTP_xxx就是http的子模块.

理解了nginx的配置的基本结构,我们来看ngx_conf_handler函数:

static ngx_int_t
ngx_conf_handler(ngx_conf_t *cf, ngx_int_t last)
{
      .........
      for (i = 0; ngx_modules[i]; i++) {
        cmd = ngx_modules[i]->commands; //初始话 每个模块中的ngx_command_s
         ........
           conf = NULL;
            ///最核心的地方 
            if (cmd->type & NGX_DIRECT_CONF) {
                conf = ((void **) cf->ctx)[ngx_modules[i]->index];//我们还记得最开始ctx是包含了所有core模块的conf(create_conf回调),因此这里取出对应的模块conf.
            } else if (cmd->type & NGX_MAIN_CONF) {
                //如果不是DIRECT_CONF并且是MAIN,则说明我们需要在配置中创建自己模块的上下文(也就是需要进入二级模块)
                conf = &(((void **) cf->ctx)[ngx_modules[i]->index]);
            } else if (cf->ctx) {//否则进入二级模块处理
                confp = *(void **) ((char *) cf->ctx + cmd->conf);

                if (confp) {
                    conf = confp[ngx_modules[i]->ctx_index];
                }
            }
            rv = cmd->set(cf, cmd, conf);  //ngx_commands_s 中set函数回调 
 ....
}          
 

我们以http模块举例:

//可以看到没有direct_conf,是因为http有2级模块
static ngx_command_t  ngx_http_commands[] = {

    { ngx_string("http"),
      NGX_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_NOARGS,
      ngx_http_block,
      0,
      0,
      NULL },

      ngx_null_command
};
static char *
ngx_http_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
    char                        *rv;
    ngx_uint_t                   mi, m, s;
    ngx_conf_t                   pcf;
    ngx_http_module_t           *module;
    ngx_http_conf_ctx_t         *ctx;
    ngx_http_core_loc_conf_t    *clcf;
    ngx_http_core_srv_conf_t   **cscfp;
    ngx_http_core_main_conf_t   *cmcf;
 
    /* the main http context */
 
    ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
    if (ctx == NULL) {
        return NGX_CONF_ERROR;
    }
//最核心的地方,可以看到修改了传递进来的conf
    *(ngx_http_conf_ctx_t **) conf = ctx;
 
    /* count the number of the http modules and set up their indices */
 
    ngx_http_max_module = 0;
    for (m = 0; ngx_modules[m]; m++) {
        if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
            continue;
        }
//然后保存了对应模块的索引.
        ngx_modules[m]->ctx_index = ngx_http_max_module++;
    }
 
 
    /* the http main_conf context, it is the same in the all http contexts */
//创建HTTP对应的conf,因为每个级别(main/ser/loc)都会包含模块的conf.
    ctx->main_conf = ngx_pcalloc(cf->pool,
                                 sizeof(void *) * ngx_http_max_module);
    if (ctx->main_conf == NULL) {
        return NGX_CONF_ERROR;
    }
 
 
    /*
     * the http null srv_conf context, it is used to merge
     * the server{}s' srv_conf's
     */
 
    ctx->srv_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
    if (ctx->srv_conf == NULL) {
        return NGX_CONF_ERROR;
    }
 
 
    /*
     * the http null loc_conf context, it is used to merge
     * the server{}s' loc_conf's
     */
 
    ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
    if (ctx->loc_conf == NULL) {
        return NGX_CONF_ERROR;
    }
 
 
    /*
     * create the main_conf's, the null srv_conf's, and the null loc_conf's
     * of the all http modules
     */
....................................
//保存当前使用的cf,因为我们只是在解析HTTP时需要改变当前的cf,
    pcf = *cf;
//保存当前模块的上下文
    cf->ctx = ctx;
..........................................
 
    /* parse inside the http{} block */
//设置模块类型和命令类型
    cf->module_type = NGX_HTTP_MODULE;
    cf->cmd_type = NGX_HTTP_MAIN_CONF;
//开始解析,这里注意传递进去的文件名是空
    rv = ngx_conf_parse(cf, NULL);
 
    if (rv != NGX_CONF_OK) {
        goto failed;
    }
 
    /*
     * init http{} main_conf's, merge the server{}s' srv_conf's
     * and its location{}s' loc_conf's
     */
.........................................
    /*
     * http{}'s cf->ctx was needed while the configuration merging
     * and in postconfiguration process
     */
//回复cf
    *cf = pcf;
}

这里有个非常关键的地方,那就是在每个级别都会保存对应的ctx(main/ser/loc),怎么说呢,就是在解析HTTP main中创建了3个ctx(main/srv/loc),而在HTTP srv block中将会创建2个ctx(main/srv/loc),或许会问重复了怎么办?重复了,那就需要merge了。比如一个命令(srv_offset)在HTTP main中有一个,那么Nginx将会把它放入到HTTP main的ctx的srv ctx中,然后server block也有一个,那么Nginx会继续把它放到Server ctx的 srv_conf中,最后merge他们。

 { ngx_string("server"),
      NGX_HTTP_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_MULTI|NGX_CONF_NOARGS,
      ngx_http_core_server,
      0,
      0,
      NULL },
 
static char *
ngx_http_core_server(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy)
{
    char                        *rv;
    void                        *mconf;
    ngx_uint_t                   i;
    ngx_conf_t                   pcf;
    ngx_http_module_t           *module;
    struct sockaddr_in          *sin;
    ngx_http_conf_ctx_t         *ctx, *http_ctx;
    ngx_http_listen_opt_t        lsopt;
    ngx_http_core_srv_conf_t    *cscf, **cscfp;
    ngx_http_core_main_conf_t   *cmcf;
 
    ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
    if (ctx == NULL) {
        return NGX_CONF_ERROR;
    }
 
    http_ctx = cf->ctx;
//main conf不变
    ctx->main_conf = http_ctx->main_conf;
 
    /* the server{}'s srv_conf */
//创建新的srv和loc conf.
    ctx->srv_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
    if (ctx->srv_conf == NULL) {
        return NGX_CONF_ERROR;
    }
 
    /* the server{}'s loc_conf */
 
    ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
    if (ctx->loc_conf == NULL) {
        return NGX_CONF_ERROR;
    }
............................
 
    /* the server configuration context */
 
    cscf = ctx->srv_conf[ngx_http_core_module.ctx_index];
    cscf->ctx = ctx;
 
 
    cmcf = ctx->main_conf[ngx_http_core_module.ctx_index];
//保存所有的servers,可以看到是保存在main中的。这样子最后在HTTP main中就可以取到这个srv conf.
    cscfp = ngx_array_push(&cmcf->servers);
    if (cscfp == NULL) {
        return NGX_CONF_ERROR;
    }
 
    *cscfp = cscf;
 
 
    /* parse inside server{} */
//解析,可以看到设置type为srv_conf.
    pcf = *cf;
    cf->ctx = ctx;
    cf->cmd_type = NGX_HTTP_SRV_CONF;
 
    rv = ngx_conf_parse(cf, NULL);
//恢复cf.
    *cf = pcf;
}

然后来看一些简单的命令是如何使用和配置的。在看之前先来看几个核心的结构:

typedef struct {
    void        **main_conf;
    void        **srv_conf;
    void        **loc_conf;
} ngx_http_conf_ctx_t;
 
//下面这些就是放到ngx_command_t的conf域,可以看到就是对应conf的偏移.
#define NGX_HTTP_MAIN_CONF_OFFSET  offsetof(ngx_http_conf_ctx_t, main_conf)
#define NGX_HTTP_SRV_CONF_OFFSET   offsetof(ngx_http_conf_ctx_t, srv_conf)
#define NGX_HTTP_LOC_CONF_OFFSET   offsetof(ngx_http_conf_ctx_t, loc_conf)
 
//下面就是如何来取模块的配置
#define ngx_http_get_module_main_conf(r, module)                             \
    (r)->main_conf[module.ctx_index]
#define ngx_http_get_module_srv_conf(r, module)  (r)->srv_conf[module.ctx_index]
#define ngx_http_get_module_loc_conf(r, module)  (r)->loc_conf[module.ctx_index]
 
 
#define ngx_http_conf_get_module_main_conf(cf, module)                        \
    ((ngx_http_conf_ctx_t *) cf->ctx)->main_conf[module.ctx_index]
#define ngx_http_conf_get_module_srv_conf(cf, module)                         \
    ((ngx_http_conf_ctx_t *) cf->ctx)->srv_conf[module.ctx_index]
#define ngx_http_conf_get_module_loc_conf(cf, module)                         \
    ((ngx_http_conf_ctx_t *) cf->ctx)->loc_conf[module.ctx_index]
 
#define ngx_http_cycle_get_module_main_conf(cycle, module)                    \
    (cycle->conf_ctx[ngx_http_module.index] ?                                 \
        ((ngx_http_conf_ctx_t *) cycle->conf_ctx[ngx_http_module.index])      \
            ->main_conf[module.ctx_index]:                                    \
        NULL)
 
#define ngx_get_conf(conf_ctx, module)  conf_ctx[module.index]




(责任编辑:IT)
------分隔线----------------------------
栏目列表
推荐内容