KeyIndex.new(shared_dict, prefix)
  self.dict = shared_dict
  self.key_prefix = prefix .. "key_"
  self.delete_count = prefix .. "delete_count"
  self.key_count = prefix .. "key_count"
  self.last = 0
  self.deleted = 0
  self.keys = {}
  self.index = {}

KeyIndex:sync() 
   获取 dict delete_count 和 dict key数量 N
   如果本地的 delete  和 delete_count 不同,说明有删除
     执行 sync_range(0,N)
   如果当前的 last 和 N 不同说明有更新，那么执行 sync_reange(N,last) 
   并返回 N

KeyIndex:sync_range(first, last) 
   从 dict 同步 first 到 last 区间的内容到当前对象
      从 dict 获取 keyi 
      记录映射关系 keys[i] = key ,index[key]=i     
   如果 keyi 是不存在的，从映射关系删除内容

KeyIndex:list() 
   执行同步 sync()
   并返回 keys 的 copy

KeyIndex:add(key_or_keys, err_msg_lru_eviction) 
   对每一个 key 执行：
      同步并获取N
      如果 key 存在，就跳过
      如果 key 不存在就设置 dict N+1 为 key 
           key_count ++ 
           设置 keys 和 index 
           
KeyIndex:remove(key, err_msg_lru_eviction)
   

总结：
利用 dict 存储数据，利用 sync 将数据同步到 worker 进程的函数

register(self, name, help, label_names, buckets, TYPE_HISTOGRAM)
	   构建指标需要的数据，对传入的name 去掉 _bucket _sum _count 的后缀
    当为 historgram 时 name 或 name_maybe_historgram 存在
    当为其他时， name 或者加入了后缀的存在都认为是指标存在，返回错误。 
    label_names ：label 名列表
    label_count： label 数量
    lookup = {} :用table 来存储指标树 
      例如 ['me.com']['200'][LEAF_KEY] = 'http_count{host="me.com",status="200"}' 
   
yield :执行读写 dict 次数 200 次就释放一次 cpu 时间片占用

lookup_or_create(self, label_values) 
   返回完整的指标名 counter 和 gauge 直接返回字符串
   histogram 返回 list 
   如果 lookup_size > lookup_max_size ,清空 lookup
inc_gauge: dict incr 
   
 

local get_var      = require("resty.ngxvar").fetch   
local get_request  = require("resty.ngxvar").request  

function _M.fetch(name, request)
    -- 从 vars 获取值，var 实现了 ffi 获取 uri  host  remote_addr request_time scheme upstream_response_time 等
    local method = vars[name]
    
    -- 未实现的直接从 ngx_var 取值 
    if not var_patched or not method then
        if num_type[name] then
            return tonumber(ngx_var[name])
        elseif ups_num_type[name] then
            return sum_upstream_num(ngx_var[name])
        end

        return ngx_var[name]
    end

    return method(request)
end

type TrieNode struct {
    // Value rune 
    Iskey bool
    Next map[rune]*TrieNode 
}

type RedixNode struct {
    Value string 
    Iskey bool
    Next map[rune]*RedixNode 
}

typedef struct raxNode {
    uint32_t iskey:1;     /* Does this node contain a key? */
    uint32_t isnull:1;    /* Associated value is NULL (don't store it). */
    uint32_t iscompr:1;   /* Node is compressed. */
    uint32_t size:29;     /* Number of children, or compressed string len. */
    unsigned char data[];
} raxNode;

*
*                    (f) ""
*                    /
*                 (i o) "f"
*                 /   \
*    "firs"  ("rst")  (o) "fo"
*              /        \
*    "first" []       [t   b] "foo"
*                     /     \
*           "foot" ("er")    ("ar") "foob"
*                    /          \
*          "footer" []          [] "foobar"

/* 对齐函数 ： 在申请内存时对齐到整数倍的字节 
sizeof(void*) 一个指针所占用的内存大小，4个字节或8个字节
nodesize +4   字节数+ 头部占用的32bit（4个字节） 
(nodesize+4) % sizeof(void*)  对整体占用求余
(sizeof(void*)-1) ：前面的已经是padding数了。这里做一个并集。？？
*/
#define raxPadding(nodesize) ((sizeof(void*)-((nodesize+4) % sizeof(void*))) & (sizeof(void*)-1))

void raxSetData(raxNode *n, void *data) {
    n->iskey = 1;
    if (data != NULL) {
        n->isnull = 0;
        void **ndata = (void**)
            ((char*)n+raxNodeCurrentLength(n)-sizeof(void*));
        memcpy(ndata,&data,sizeof(data));
    } else {
        n->isnull = 1;
    }
}
/* Get the node auxiliary data. */
void *raxGetData(raxNode *n) {
    if (n->isnull) return NULL;
    void **ndata =(void**)((char*)n+raxNodeCurrentLength(n)-sizeof(void*));
    void *data;
    memcpy(&data,ndata,sizeof(data));
    return data;
}

// 用来查询字符串在redixtree 中能够匹配到哪个位置
static inline size_t raxLowWalk(rax *rax, unsigned char *s, size_t len, raxNode **stopnode, raxNode ***plink, int *splitpos, raxStack *ts) {
    raxNode *h = rax->head;
    raxNode **parentlink = &rax->head;
    size_t i = 0; /* Position in the string. */
    size_t j = 0; /* Position in the node children (or bytes if compressed).*/
    while(h->size && i < len) {
        debugnode("Lookup current node",h);
        unsigned char *v = h->data;
        if (h->iscompr) {
            for (j = 0; j < h->size && i < len; j++, i++) {
                if (v[j] != s[i]) break;
            }
            if (j != h->size) break;
        } else {
            /* Even when h->size is large, linear scan provides good
             * performances compared to other approaches that are in theory
             * more sounding, like performing a binary search. */
            for (j = 0; j < h->size; j++) {
                if (v[j] == s[i]) break;
            }
            if (j == h->size) break;
            i++;
        }
        if (ts) raxStackPush(ts,h); /* Save stack of parent nodes. */
        raxNode **children = raxNodeFirstChildPtr(h);
        if (h->iscompr) j = 0; /* Compressed node only child is at index 0. */
        memcpy(&h,children+j,sizeof(h));
        parentlink = children+j;
        j = 0; /* If the new node is compressed and we do not
                  iterate again (since i == l) set the split
                  position to 0 to signal this node represents
                  the searched key. */
    }
    debugnode("Lookup stop node is",h);
    if (stopnode) *stopnode = h;
    if (plink) *plink = parentlink;
    if (splitpos && h->iscompr) *splitpos = j;
    return i;
}

void *radix_tree_new();
int radix_tree_destroy(void *t);
int radix_tree_insert(void *t, const unsigned char *buf, size_t len,
    int idx);
void *radix_tree_find(void *t, const unsigned char *buf, size_t len);
void *radix_tree_search(void *t, void *it, const unsigned char *buf, size_t len);
int radix_tree_prev(void *it, const unsigned char *buf, size_t len);
int radix_tree_next(void *it, const unsigned char *buf, size_t len);
int radix_tree_stop(void *it);
void *radix_tree_new_it(void *t);

{
      paths = {"/aa", "/bb*", "/name/:name/*other"},
      hosts = {"*.bar.com", "foo.com"},
      methods = {"GET", "POST", "PUT"},
      remote_addrs = {"127.0.0.1","192.168.0.0/16",
                      "::1", "fe80::/32"},
      vars = {
          {"arg_name", "==", "json"},
          {"arg_weight", ">", 10},
      },
      filter_fun = function(vars, opts)
          return vars["arg_name"] == "json"
      end,

      metadata = "metadata /bb",
  }

function _M.dispatch(self, path, opts, ...)
    ... 
    local route, err = match_route(self, path, opts or empty_table, args)
    ...
    handler(...)
    return true
end

api_ctx.matched_route = route
api_ctx.conf_type = "route&service"
api_ctx.conf_version = route.modifiedIndex .. "&" .. service.modifiedIndex
api_ctx.conf_id = route.value.id .. "&" .. service.value.id
api_ctx.service_id = service.value.id
api_ctx.service_name = service.value.name

api_ctx.route_id = route.value.id
api_ctx.route_name = route.value.name

plugin.run_plugin("rewrite", plugins, api_ctx)
if api_ctx.consumer then
    ...
    route, changed = plugin.merge_consumer_route(
        route,
        api_ctx.consumer,
        api_ctx
    )
    ...
end
plugin.run_plugin("access", plugins, api_ctx)

if route.value.plugin_config_id then
    ...
    route = plugin_config.merge(route, conf)
 end
if route.value.service_id then 
	 ... 
   route = plugin.merge_service_route(service, route)
   ...
end 
if api_ctx.consumer then
    ...
    route, changed = plugin.merge_consumer_route(
        route,
        api_ctx.consumer,
        api_ctx
    )
    ...
end

api_ctx = core.tablepool.fetch("api_ctx", 0, 32) 
ngx_ctx.api_ctx = api_ctx

ssl_certificates, err = core.config.new("/ssl", {
        automatic = true,
        item_schema = core.schema.ssl,
        checker = function (item, schema_type)
            return apisix_ssl.check_ssl_conf(true, item)
        end,
    })

route_items[idx] = {
      paths = sni, -- 反向后的域名
      handler = function (api_ctx) -- 回调函数
          if not api_ctx then
              return
          end
          api_ctx.matched_ssl = ssl
          api_ctx.matched_sni = sni
      end
  }

for _, msni in ipairs(api_ctx.matched_sni) do
    -- 完全匹配 或者 相对于msni sni_srv 后面没有点（泛匹配）? 
    if sni_rev == msni or not str_find(sni_rev, ".", #msni) then
        matched = true
    end
end

router = route.new(uri_route)
events = require("resty.worker.events")
-- 注册插件重启事件 
events.register(reload_plugins, reload_event, "PUT")
if ngx_worker_id() == 0 then
        local ok, err = ngx_timer_at(0, function(premature)
            if premature then
                return
            end
						 -- 将本地插件配置同步到 etcd 
            sync_local_conf_to_etcd(true)
        end)

        if not ok then
            error("failed to sync local configure to etcd: " .. err)
        end
    end

local _M = {
    version = 0.1,
}


local function check_conf(...)
  ... -- 对 put 写入 etcd 的数据校验
      -- 使用 schema_def.lua 里对应的校验数据进行校验
      -- 返回 etcd key
end

_M.put(...) -- etcd set 
_M.get(...) -- etcd get
_M.post(...) -- etcd push 
_M.delete(...) -- etcd delete
return _M 

local dns_resolver = { "127.0.0.11", }
local args = {
    dns_resolver = dns_resolver,
}
apisix.http_init(args)

-- dns 发现设置： args["dns_resolver"]
core.resolver.init_resolver(args) 
 -- 生成 apisix uuid /conf/apisix.uid
core.id.init()                   
--https://github.com/openresty/lua-resty-core/blob/master/lib/ngx/process.md#enable_privileged_agent
-- 开启特权进程，可以使用 master 进程权限执行一些功能
local process = require("ngx.process") 
local ok, err = process.enable_privileged_agent() 
 
-- 读初始化配置， core/config_etcd.lua  执行 init 判断 etcd 是否可访问。
local ok, err = core.config.init() 
 

obj, err = core.config.new("/etcd_path", cfg)

local global_rules, err = core.config.new("/global_rules", {
            automatic = true,
            item_schema = core.schema.global_rule,
            checker = plugin_checker,
        })

nodes[i] = {host = r.address, weight = r.weight or 1, port = r.port or port}
if r.priority then
    -- for SRV record, nodes with lower priority are chosen first
    nodes[i].priority = -r.priority
end