开发指南_文档-OpenNJet开源社区

data;

helper ctrl modules/njt_helper_ctrl_module.so conf/njet_ctrl.conf; 
helper broker modules/njt_helper_broker_module.so conf/mqtt.conf;

helper ha modules/njt_helper_ha_module.so conf/vrrp.conf;

1）unsigned int njt_helper_check_version(void)      注：当前版本号是 1      #define NJT_HELPER_VER          1                 2）void njt_helper_run(helper_param param)      注：helper_param是一个struc类型，定义如下

      typedef unsigned int (*helper_check_cmd_fp)(void* ctx);      typedef struct {          size_t      conf_fn_len;          u_char     *conf_fn_data;*          *helper_check_cmd_fp check_cmd_fp;*          *void*       ctx;      } helper_param;

      在njt_helper_run的事件循环中，需调用param.check_cmd_fp()接收命令

      例如：      unsigned int cmd;      cmd = param.check_cmd_fp(param.ctx);

      命令宏定义如下：      #define NJT_HELPER_CMD_NO          0      #define NJT_HELPER_CMD_STOP       1      #define *NJT_HELPER_CMD_RESTART*  2

      接收到命令后，需进行命令处理。      NJT_HELPER_CMD_STOP命令，要进行停止操作；      NJT_HELPER_CMD_RESTART 为预留命令，暂不会发送该命令，在事件处理中可以按停止操作处理该命令，或者执行自身业务逻辑的重新开始。

3）unsigned int njt_helper_ignore_reload(void)

返回1，表示该so的copilot进程，不会在reload的时候重启。

放回0，表示该so的copilot进程，会在reload的时候重启。

注1：so可以不实现该接口。若不实现，则等同于返回0。

注2：如果so实现该接口并且返回1，那么在reload的时候该so的copilot进程不会重启，但是有一点需要注意：reload的时候配置文件中需保留原helper指令，这是配置上的强制要求，不满足此要求会导致reload失败。

helper ctrl modules/njt_helper_ctrl_module.so conf/njet_ctrl.conf;

load_module modules/njt_http_sendmsg_module.so;
load_module modules/njt_http_location_api_module.so;
load_module modules/njt_ctrl_config_api_module.so;
load_module modules/njt_http_health_check_helper.so;
load_module modules/njt_http_vtsd_module.so; 

user njet njet;
error_log logs/error-ctrl.log info;
events {
    worker_connections  1024;
}

http {
    dyn_sendmsg_conf conf/iot-ctrl.cfg;
    access_log logs/access-ctrl.log combined;

    server {
        listen       8081;
        location /kv  {
            dyn_sendmsg_kv;
        }
        location /config {
            config_api;
        }

        location /dyn_loc {
            dyn_location_api;
        }

        location /hc {
                health_check_api;
        }

        location /metrics {
            vhost_traffic_status_display;
            vhost_traffic_status_display_format html;
        }
    }
}

njt_pid_t njt_helper_go_start(njt_cycle_t *cycle, char *prefix, char *fullfn) {
    njt_exec_ctx_t ctx;
    char *n, *p;
    char *name = "gocop";
    njt_pid_t pid;

    //这里是拼接出go二进制文件的路径，install脚本会在conf-prefix路径下作了一个软链接
    n = njt_calloc(njt_strlen(prefix) + njt_strlen(name) + 1, cycle->log);
    p = (char *)njt_cpymem(n, prefix, njt_strlen(prefix));
    njt_cpystrn((u_char *)p, (u_char *)name, strlen(name) + 1);

    ctx.path = n;
    ctx.name = "go copilot in njt_execute";
    ctx.argv = (char* const[]){name, "--conf", fullfn, NULL}; //命令行参数，指定了配置文件位置
    ctx.envp = (char* const[]){"GIN_MODE=release",NULL}; //要传入的环境变量
    pid = njt_execute(cycle, &ctx);

    njt_free(n);
    return pid;
}

# 在 OPENSSL=NONE 下面增加
USE_GOCOP=NO
GOCOP_PATH=NONE

# 在--with-openssl-opt=*)            OPENSSL_OPT="$value"       ;; 之前增加
--with-gocop=*)                      GOCOP_PATH="$value"           ;;

# 在--with-openssl=DIR                 set path to OpenSSL library sources下面增加
--with-gocop=PATH                  set path to gocop binrary executable

if test -n "$GOCOP_PATH"; then
if test -f "$GOCOP_PATH"; then

    cat << END                                                >> $NJT_MAKEFILE

        cp $GOCOP_PATH '\$(DESTDIR)`dirname "$NJT_SBIN_PATH"`/gocop'
        ln -sf '\$(DESTDIR)`dirname "$NJT_SBIN_PATH"`/gocop' '\$(DESTDIR)$NJT_CONF_PREFIX/gocop'
END

fi
fi

增加
NJET_MODULES="$NJET_MODULES --add-dynamic-module=./modules/njet-helper-go-module"
在LIB_SRC_PATH上增加
LIB_SRC_PATH=" --with-openssl=auto/lib/tassl --with-pcre=auto/lib/pcre-8.45 --with-gocop=/root/go/src/gitee.com/liismn/go-copilot/cmd/main"

.
  ├── 3rd_lib         依赖的第三方动态库, 比如libmosquitto_emb.so
  ├── build/rpm       rpm包编译脚本
  ├── auto            自动检测系统环境以及编译相关的脚本
  │   ├── cc          关于编译器相关的编译选项的检测脚本
  │   ├── lib         njet编译所需要的一些库的检测脚本
  │   ├── os          与平台相关的一些系统参数与系统调用相关的检测
  │   └── types       与数据类型相关的一些辅助脚本
  ├── conf            存放默认配置文件，在make install后，会拷贝到安装目录中去
  ├── contrib         存放一些实用工具，如geo配置生成工具（geo2njet.pl）
  ├── html            存放默认的网页文件，在make install后，会拷贝到安装目录中去
  ├── repos           存放yum数据源
  ├── doc             njet的api文档
  │   ├── swagger     openapi 接口网页文档
  │   ├── gui         前端展示页面文档
  │   └── manual      njet文档手册
  ├── luajit          luajit
  ├── lualib          lualib
  ├── modules         njet动态模块以及util模块
  ├── openapi         openapi 定义文件
  └── src             存放njet的源代码
      ├── core        njet的核心源代码，包括常用数据结构的定义，以及njet初始化运行的核心代码如main函数
      ├── event       对系统事件处理机制的封装，以及定时器的实现相关代码
      │   └── modules 不同事件处理方式的模块化，如select、poll、epoll、kqueue等
      ├── http        njet作为http服务器相关的代码
      │   └── modules 包含http的各种功能模块
      ├── ext/lua     lua模块
      ├── mail        njet作为邮件代理服务器相关的代码
      ├── stream      tcp/udp四层网络代理服务器相关的代码
      ├── misc        一些辅助代码，测试c++头的兼容性，以及对google_perftools的支持
      └── os          主要是对各种不同体系统结构所提供的系统函数的封装，对外提供统一的系统调用接口

#include <njt_config.h>
#include <njt_core.h>

#include <njt_http.h>

#include <njt_mail.h> 

#include <njt_stream.h>

njt_int_t
njt_my_kill(njt_pid_t pid, njt_log_t *log, int signo)
{
    njt_err_t  err;

    if (kill(pid, signo) == -1) {
        err = njt_errno;

        njt_log_error(NJT_LOG_ALERT, log, err, "kill(%P, %d) failed", pid, signo);

        if (err == NJT_ESRCH) {
            return 2;
        }

        return 1;
    }

    return 0;
}

size_t
njt_utf8_length(u_char *p, size_t n)
{
    u_char  c, *last;
    size_t  len;

    last = p + n;

    for (len = 0; p < last; len++) {

        c = p;

        if (c < 0x80) {
            p++;
            continue;
        }

        if (njt_utf8_decode(&p, last - p) > 0x10ffff) {
            / invalid UTF-8 */
            return n;
        }
    }

    return len;
}

/*
 * Copyright (C) Igor Sysoev
 * Copyright (C) njet, Inc.
 * Copyright (C) TMLake, Inc.
 */

#include <njt_config.h>
#include <njt_core.h>
#include <njt_http.h>

#include <libxml/parser.h>
#include <libxml/tree.h>
#include <libxslt/xslt.h>

#if (NJT_HAVE_EXSLT)
#include <libexslt/exslt.h>
#endif

#ifndef _NJT_PROCESS_CYCLE_H_INCLUDED_
#define _NJT_PROCESS_CYCLE_H_INCLUDED_
...
#endif /* _NJT_PROCESS_CYCLE_H_INCLUDED_ */

    /*
     * gcc before 3.3 compiles the broken code for
     *     if (r->uri_changes-- == 0)
     * if the r->uri_changes is defined as
     *     unsigned  uri_changes:4
     */

/** 
 * @brief  get array or object element's size 
 *   
 * @param datas           intput array datas 
 * @param contain_key     true if element has key, else false 
 * @return int64_t        return all sub element's size 
 */
 int64_t njt_calc_array_size(njt_queue_t *datas, bool contain_key);

#define NJT_CONF_BUFFER  4096

#define njt_buf_in_memory(b)  (b->temporary || b->memory || b->mmap)

#define njt_buf_size(b)                                                      \
    (njt_buf_in_memory(b) ? (off_t) (b->last - b->pos):                      \
                            (b->file_last - b->file_pos))

#define njt_null_string  { 0, NULL }

#if (NJT_HAVE_KQUEUE)
...
#elif ((NJT_HAVE_DEVPOLL && !(NJT_TEST_BUILD_DEVPOLL)) \
       || (NJT_HAVE_EVENTPORT && !(NJT_TEST_BUILD_EVENTPORT)))
...
#elif (NJT_HAVE_EPOLL && !(NJT_TEST_BUILD_EPOLL))
...
#elif (NJT_HAVE_POLL)
...
#else /* select */
...
#endif /* NJT_HAVE_KQUEUE */

typedef struct {
    size_t      len;
    u_char     *data;
} njt_str_t;

typedef struct njt_list_part_s  njt_list_part_t;

struct njt_list_part_s {
    void             *elts;
    njt_uint_t        nelts;
    njt_list_part_t  *next;
};

typedef struct {
    njt_list_part_t  *last;
    njt_list_part_t   part;
    size_t            size;
    njt_uint_t        nalloc;
    njt_pool_t       *pool;
} njt_list_t;

typedef struct {
    njt_uint_t        hash;
    njt_str_t         key;
    njt_str_t         value;
    u_char           *lowcase_key;
} njt_table_elt_t;

typedef ssize_t (*njt_recv_pt)(njt_connection_t *c, u_char *buf, size_t size);
typedef ssize_t (*njt_recv_chain_pt)(njt_connection_t *c, njt_chain_t *in,
    off_t limit);
typedef ssize_t (*njt_send_pt)(njt_connection_t *c, u_char *buf, size_t size);
typedef njt_chain_t *(*njt_send_chain_pt)(njt_connection_t *c, njt_chain_t *in,
    off_t limit);

typedef struct {
    njt_recv_pt        recv;
    njt_recv_chain_pt  recv_chain;
    njt_recv_pt        udp_recv;
    njt_send_pt        send;
    njt_send_pt        udp_send;
    njt_send_chain_pt  udp_send_chain;
    njt_send_chain_pt  send_chain;
    njt_uint_t         flags;
} njt_os_io_t;

typedef enum {
    njt_http_fastcgi_st_version = 0,
    njt_http_fastcgi_st_type,
    ...
    njt_http_fastcgi_st_padding
} njt_http_fastcgi_state_e;

u_char                      |  | *rv, *p;
njt_conf_t                  |  | *cf;
njt_uint_t                  |  |  i, j, k;
unsigned int                |  |  len;
struct sockaddr             |  | *sa;
const unsigned char         |  | *data;
njt_peer_connection_t       |  | *pc;
njt_http_core_srv_conf_t    |  |**cscfp;
njt_http_upstream_srv_conf_t|  | *us, *uscf;
u_char                      |  |  text[NJT_SOCKADDR_STRLEN];

static njt_str_t  njt_http_memcached_key = njt_string("memcached_key");

static njt_uint_t  mday[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

static uint32_t  njt_crc32_table16[] = {
    0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac,
    ...
    0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c
};

u_char                        *rv;
njt_int_t                      rc;
njt_conf_t                    *cf;
njt_connection_t              *c;
njt_http_request_t            *r;
njt_peer_connection_t         *pc;
njt_http_upstream_srv_conf_t  *us, *uscf;

static char *njt_http_block(njt_conf_t *cf, njt_command_t *cmd, void *conf);
static njt_int_t njt_http_init_phases(njt_conf_t *cf,
    njt_http_core_main_conf_t *cmcf);

static char *njt_http_merge_servers(njt_conf_t *cf,
    njt_http_core_main_conf_t *cmcf, njt_http_module_t *module,
    njt_uint_t ctx_index);

static njt_int_t
njt_http_find_virtual_server(njt_http_request_t *r, u_char *host, size_t len)
{
    ...
}

static njt_int_t
njt_http_add_addresses(njt_conf_t *cf, njt_http_core_srv_conf_t *cscf,
    njt_http_conf_port_t *port, njt_http_listen_opt_t *lsopt)
{
    ...
}

njt_log_debug2(NJT_LOG_DEBUG_HTTP, r->connection->log, 0,
               "http header: \"%V: %V\"",
               &h->key, &h->value);

hc->busy = njt_palloc(r->connection->pool,
                  cscf->large_client_header_buffers.num * sizeof(njt_buf_t *));

static njt_inline void njt_cpuid(uint32_t i, uint32_t *buf);

width = width * 10 + (*fmt++ - '0');

ch = (u_char) ((decoded << 4) + (ch - '0'));

r->exten.data = &r->uri.data[i + 1];

len = njt_sock_ntop((struct sockaddr *) sin6, p, len, 1)

if (status == NJT_HTTP_MOVED_PERMANENTLY
    || status == NJT_HTTP_MOVED_TEMPORARILY
    || status == NJT_HTTP_SEE_OTHER
    || status == NJT_HTTP_TEMPORARY_REDIRECT
    || status == NJT_HTTP_PERMANENT_REDIRECT)
{
    ...
}

p->temp_file->warn = "an upstream response is buffered "
                     "to a temporary file";

hinit->hash = njt_pcalloc(hinit->pool, sizeof(njt_hash_wildcard_t)
                                     + size * sizeof(njt_hash_elt_t *));

if (((u->conf->cache_use_stale & NJT_HTTP_UPSTREAM_FT_UPDATING)
     || c->stale_updating) && !r->background
    && u->conf->cache_background_update)
{
    ...
}

if (ptr != NULL) {
    ...
}

if (node->left == sentinel) {
    temp = node->right;
    subst = node;

} else if (node->right == sentinel) {
    temp = node->left;
    subst = node;

} else {
    subst = njt_rbtree_min(node->right, sentinel);

    if (subst->left != sentinel) {
        temp = subst->left;

    } else {
        temp = subst->right;
    }
}

while (p < last && *p == ' ') {
    p++;
}

do {
    ctx->node = rn;
    ctx = ctx->next;
} while (ctx);

switch (ch) {
case '!':
    looked = 2;
    state = ssi_comment0_state;
    break;

case '<':
    copy_end = p;
    break;

default:
    copy_end = p;
    looked = 0;
    state = ssi_start_state;
    break;
}

for (i = 0; i < ccf->env.nelts; i++) {
    ...
}

for (q = njt_queue_head(locations);
     q != njt_queue_sentinel(locations);
     q = njt_queue_next(q))
{
    ...
}

for (i = 0; /* void */ ; i++) {
    ...
}

for (cl = *busy; cl->next; cl = cl->next) { /* void */ }

for ( ;; ) {
    ...
}

    if (i == 0) {
        u->err = "host not found";
        goto failed;
    }

    u->addrs = njt_pcalloc(pool, i * sizeof(njt_addr_t));
    if (u->addrs == NULL) {
        goto failed;
    }

    u->naddrs = i;

    ...

    return NJT_OK;

failed:

    freeaddrinfo(res);
    return NJT_ERROR;

u_char      buf[NJT_INT_T_LEN];
size_t      len;
njt_uint_t  n;

/* set n here */

len = njt_sprintf(buf, "%ui", n) — buf;

#if (NJT_PCRE)
njt_regex_t          *re;
njt_regex_compile_t   rc;

u_char                errstr[NJT_MAX_CONF_ERRSTR];

njt_str_t  value = njt_string("message (\\d\\d\\d).*Codeword is '(?<cw>\\w+)'");

njt_memzero(&rc, sizeof(njt_regex_compile_t));

rc.pattern = value;
rc.pool = cf->pool;
rc.err.len = NJT_MAX_CONF_ERRSTR;
rc.err.data = errstr;
/* rc.options can be set to NJT_REGEX_CASELESS */

if (njt_regex_compile(&rc) != NJT_OK) {
    njt_conf_log_error(NJT_LOG_EMERG, cf, 0, "%V", &rc.err);
    return NJT_CONF_ERROR;
}

re = rc.regex;
#endif

njt_int_t  n;
int        captures[(1 + rc.captures) * 3];

njt_str_t input = njt_string("This is message 123. Codeword is 'foobar'.");

n = njt_regex_exec(re, &input, captures, (1 + rc.captures) * 3);
if (n >= 0) {
    /* string matches expression /

} else if (n == NJT_REGEX_NO_MATCHED) {
    / no match was found /

} else {
    / some error */
    njt_log_error(NJT_LOG_ALERT, log, 0, njt_regex_exec_n " failed: %i", n);
}

u_char     p;
size_t      size;
njt_str_t   name, value;

/ all captures /
for (i = 0; i < n  2; i += 2) {
    value.data = input.data + captures[i];
    value.len = captures[i + 1] — captures[i];
}

/* accessing named captures /

size = rc.name_size;
p = rc.names;

for (i = 0; i < rc.named_captures; i++, p += size) {

    / capture name /
    name.data = &p[2];
    name.len = njt_strlen(name.data);

    n = 2  ((p[0] << 8) + p[1]);

    /* captured value */
    value.data = &input.data[captures[n]];
    value.len = captures[n + 1] — captures[n];
}

typedef struct {
    time_t      sec;
    njt_uint_t  msec;
    njt_int_t   gmtoff;
} njt_time_t;

typedef struct {
    void        *elts;
    njt_uint_t   nelts;
    size_t       size;
    njt_uint_t   nalloc;
    njt_pool_t  *pool;
} njt_array_t;

njt_array_t  a, b;

/ create an array of strings with preallocated memory for 10 elements /
a = njt_array_create(pool, 10, sizeof(njt_str_t));

/ initialize string array for 10 elements */
njt_array_init(&b, pool, 10, sizeof(njt_str_t));

s = njt_array_push(a);
ss = njt_array_push_n(&b, 3);

typedef struct {
    njt_list_part_t  *last;
    njt_list_part_t   part;
    size_t            size;
    njt_uint_t        nalloc;
    njt_pool_t       *pool;
} njt_list_t;

typedef struct njt_list_part_s  njt_list_part_t;

struct njt_list_part_s {
    void             *elts;
    njt_uint_t        nelts;
    njt_list_part_t  *next;
};

njt_str_t        *v;
njt_uint_t        i;
njt_list_t       *list;
njt_list_part_t  part;

list = njt_list_create(pool, 100, sizeof(njt_str_t));
if (list == NULL) { / error / }

/ add items to the list /

v = njt_list_push(list);
if (v == NULL) { / error / }
njt_str_set(v, "foo");

v = njt_list_push(list);
if (v == NULL) { / error / }
njt_str_set(v, "bar");

/ iterate over the list /

part = &list->part;
v = part->elts;

for (i = 0; / void */; i++) {

    if (i >= part->nelts) {
        if (part->next == NULL) {
            break;
        }

        part = part->next;
        v = part->elts;
        i = 0;
    }

    njt_do_smth(&v[i]);
}

typedef struct njt_queue_s  njt_queue_t;

struct njt_queue_s {
    njt_queue_t  *prev;
    njt_queue_t  *next;
};

typedef struct {
    njt_str_t    value;
    njt_queue_t  queue;
} njt_foo_t;

njt_foo_t    *f;
njt_queue_t   values, *q;

njt_queue_init(&values);

f = njt_palloc(pool, sizeof(njt_foo_t));
if (f == NULL) { /* error / }
njt_str_set(&f->value, "foo");

njt_queue_insert_tail(&values, &f->queue);

/ insert more nodes here */

for (q = njt_queue_head(&values);
     q != njt_queue_sentinel(&values);
     q = njt_queue_next(q))
{
    f = njt_queue_data(q, njt_foo_t, queue);

    njt_do_smth(&f->value);
}

typedef struct {
    njt_rbtree_t       rbtree;
    njt_rbtree_node_t  sentinel;

    /* custom per-tree data here /
} my_tree_t;

typedef struct {
    njt_rbtree_node_t  rbnode;

    / custom per-node data */
    foo_t              val;
} my_node_t;

my_tree_t  root;

njt_rbtree_init(&root.rbtree, &root.sentinel, insert_value_function);

my_node_t *
my_rbtree_lookup(njt_rbtree_t *rbtree, foo_t *val, uint32_t hash)
{
    njt_int_t           rc;
    my_node_t          *n;
    njt_rbtree_node_t  *node, *sentinel;

    node = rbtree->root;
    sentinel = rbtree->sentinel;

    while (node != sentinel) {

        n = (my_node_t *) node;

        if (hash != node->key) {
            node = (hash < node->key) ? node->left : node->right;
            continue;
        }

        rc = compare(val, node->val);

        if (rc < 0) {
            node = node->left;
            continue;
        }

        if (rc > 0) {
            node = node->right;
            continue;
        }

        return n;
    }

    return NULL;
}

void
njt_my_connection_read(njt_connection_t *c)
{
    njt_event_t  *rev;

    rev = c->read;

    njt_add_timer(rev, 1000);

    rev->handler = njt_my_read_handler;

    njt_my_read(rev);
}

void
njt_my_read_handler(njt_event_t *rev)
{
    ssize_t            n;
    njt_connection_t  *c;
    u_char             buf[256];

    if (rev->timedout) { /* timeout expired */ }

    c = rev->data;

    while (rev->ready) {
        n = c->recv(c, buf, sizeof(buf));

        if (n == NJT_AGAIN) {
            break;
        }

        if (n == NJT_ERROR) { /* error */ }

        /* process buf */
    }

    if (njt_handle_read_event(rev, 0) != NJT_OK) { /* error */ }
}

struct njt_thread_task_s {
    njt_thread_task_t   *next;
    njt_uint_t           id;
    void                *ctx;
    void               (*handler)(void *data, njt_log_t *log);
    njt_event_t          event;
};

typedef struct njt_thread_pool_s  njt_thread_pool_t;

njt_thread_pool_t *njt_thread_pool_add(njt_conf_t *cf, njt_str_t *name);
njt_thread_pool_t *njt_thread_pool_get(njt_cycle_t *cycle, njt_str_t *name);

njt_thread_task_t *njt_thread_task_alloc(njt_pool_t *pool, size_t size);
njt_int_t njt_thread_task_post(njt_thread_pool_t *tp, njt_thread_task_t *task);

typedef struct {
    int    foo;
} my_thread_ctx_t;

static void
my_thread_func(void *data, njt_log_t *log)
{
    my_thread_ctx_t *ctx = data;

    /* this function is executed in a separate thread */
}

static void
my_thread_completion(njt_event_t *ev)
{
    my_thread_ctx_t *ctx = ev->data;

    /* executed in njet event loop */
}

njt_int_t
my_task_offload(my_conf_t *conf)
{
    my_thread_ctx_t    *ctx;
    njt_thread_task_t  *task;

    task = njt_thread_task_alloc(conf->pool, sizeof(my_thread_ctx_t));
    if (task == NULL) {
        return NJT_ERROR;
    }

    ctx = task->ctx;

    ctx->foo = 42;

    task->handler = my_thread_func;
    task->event.handler = my_thread_completion;
    task->event.data = ctx;

    if (njt_thread_task_post(conf->thread_pool, task) != NJT_OK) {
        return NJT_ERROR;
    }

    return NJT_OK;
}

njt_module_type=CORE
njt_module_name=njt_foo_module
njt_module_srcs="$njt_addon_dir/njt_foo_module.c"

. auto/module

njt_addon_name=$njt_module_name

struct njt_module_s {

    /* private part is omitted */

    void                 *ctx;
    njt_command_t        *commands;
    njt_uint_t            type;

    njt_int_t           (*init_master)(njt_log_t *log);

    njt_int_t           (*init_module)(njt_cycle_t *cycle);

    njt_int_t           (*init_process)(njt_cycle_t *cycle);
    njt_int_t           (*init_thread)(njt_cycle_t *cycle);
    void                (*exit_thread)(njt_cycle_t *cycle);
    void                (*exit_process)(njt_cycle_t *cycle);

    void                (*exit_master)(njt_cycle_t *cycle);

    /* stubs for future extensions are omitted */
};

typedef struct {
    njt_str_t             name;
    void               *(*create_conf)(njt_cycle_t *cycle);
    char               *(*init_conf)(njt_cycle_t *cycle, void *conf);
} njt_core_module_t;

/*
 * Copyright (C) Author.
 */

#include <njt_config.h>
#include <njt_core.h>

typedef struct {
    njt_flag_t  enable;
} njt_foo_conf_t;

static void *njt_foo_create_conf(njt_cycle_t *cycle);
static char *njt_foo_init_conf(njt_cycle_t *cycle, void *conf);

static char *njt_foo_enable(njt_conf_t *cf, void *post, void *data);
static njt_conf_post_t  njt_foo_enable_post = { njt_foo_enable };

static njt_command_t  njt_foo_commands[] = {

    { njt_string("foo_enabled"),
      NJT_MAIN_CONF|NJT_DIRECT_CONF|NJT_CONF_FLAG,
      njt_conf_set_flag_slot,
      0,
      offsetof(njt_foo_conf_t, enable),
      &njt_foo_enable_post },

      njt_null_command
};

static njt_core_module_t  njt_foo_module_ctx = {
    njt_string("foo"),
    njt_foo_create_conf,
    njt_foo_init_conf
};

njt_module_t  njt_foo_module = {
    NJT_MODULE_V1,
    &njt_foo_module_ctx,                   /* module context */
    njt_foo_commands,                      /* module directives */
    njt_CORE_MODULE,                       /* module type */
    NULL,                                  /* init master */
    NULL,                                  /* init module */
    NULL,                                  /* init process */
    NULL,                                  /* init thread */
    NULL,                                  /* exit thread */
    NULL,                                  /* exit process */
    NULL,                                  /* exit master */
    NJT_MODULE_V1_PADDING
};

static void *
njt_foo_create_conf(njt_cycle_t *cycle)
{
    njt_foo_conf_t  *fcf;

    fcf = njt_pcalloc(cycle->pool, sizeof(njt_foo_conf_t));
    if (fcf == NULL) {
        return NULL;
    }

    fcf->enable = NJT_CONF_UNSET;

    return fcf;
}

static char *
njt_foo_init_conf(njt_cycle_t *cycle, void *conf)
{
    njt_foo_conf_t *fcf = conf;

    njt_conf_init_value(fcf->enable, 0);

    return NJT_CONF_OK;
}

static char *
njt_foo_enable(njt_conf_t *cf, void *post, void *data)
{
    njt_flag_t  *fp = data;

    if (*fp == 0) {
        return NJT_CONF_OK;
    }

    njt_log_error(NJT_LOG_NOTICE, cf->log, 0, "Foo Module is enabled");

    return NJT_CONF_OK;
}

typedef struct njt_command_s  njt_command_t;

struct njt_command_s {
    njt_str_t             name;
    njt_uint_t            type;
    char               *(*set)(njt_conf_t *cf, njt_command_t *cmd, void *conf);
    njt_uint_t            conf;
    njt_uint_t            offset;
    void                 *post;
};

auto/configure --with-cc-opt='-fsanitize=address -DNJT_DEBUG_PALLOC=1'
               --with-ld-opt=-fsanitize=address

worker_processes  24; 
events { 
    worker_connections  10240; 
} 
http { 
    include       mime.types; 
    default_type  application/octet-stream; 
    sendfile        on; 
    access_log off; 
    keepalive_timeout  120s 120s; 
    keepalive_requests 200000; 
    upstream web { 
       server 192.168.0.230:28080; 
       keepalive 400; 
    } 
    server { 
        listen       80; 
        server_name  localhost; 
        location / { 
            proxy_pass http://web; 
            proxy_http_version 1.1; 
            proxy_set_header Connection ""; 
        } 

    } 
}

{    
    "worker_processes": 24,
    "events": {
        "worker_connections": 10240
    },
    "http": {
        "include": "mime.types",
        "default_type": "application/octet-stream",
        "keepalive_timeout": "120s 120s",
        "keepalive_requests": 200000,
        "sendfile": true,
        "access_log": false,
        "upstream": [{
            "_key": "web",
            "server": ["192.168.0.230:28080"],
            "keepalive": 400
        }],
        "server": [{
            "_key": "",
            "listen": 80,
            "server_name": "localhost",
            "location": [{
                "_key": "/",
                "proxy_pass": "http://web",
                "proxy_http_version": 1.1,
                "proxy_set_header": "Connection \"\""
            }]
        }]
    }
}

Syntax	helper tag so_file conf_file;
Default	---
Context	main

参数名称	是否必须	参数说明
tag	是	指定一个名字标签
so_file	是	so文件
conf_file	是	配置文件

配置项	必须修改	配置说明
log_dest	否	日志输出方法，一般配置为文件输出，配置值为file 文件名（绝对路径）默认： $PREFIX/logs/mosquitto.log
log_type	否	日志级别： debug, error, warning, notice, information，mqtt库中的日志输出方式和java 中的不一样，配置了某个日志级别，只有该日志级别的消息才会输出到日志中，因此需要为需要的日志级别单独配置一行。默认： error
listener	否	监听端口及地址 , 默认： 0 $PREFIX/data/mosquitto.sock
allow_anonymous	否	是否允许匿名连接，目前配置为true
persistence	否	是否开启消息持久化（true, false), 默认： true
autosave_on_changes	否	是否有消息时进行自动保存默认： true
autosave_interval	否	当自动保存开启时，当新消息个数大于这个配置值时，将触发保存操作默认： 1
persistence_location	否	持久化文件保存路径，将在该路径下创建 mosquitto.db , 默认： $PREFIX/data

开发指南_文档-OpenNJet开源社区

CoPilot开发指南

1. CoPilot概述

2. CoPilot配置

3.CoPilot插件规范

4.开发实例

5.自带的CoPilot实例

CoPilot: broker 实例

broker的功能

broker的配置使用

CoPilot: njet_ctrl实例

ctrl的功能

ctrl的配置使用

6.调用其他语言编写的CoPilot

go-copilot开发

目标

主要思路

具体实现（暂时只是启动/停止一个go的webserver）

编译OpenNJet module

参考文档

7.其他问题

SSL的一致性

OpenNJet 编码规范以及新手指引

编码规范

1.简介

2.基础指引

2.1代码布局

2.2include文件

2.3整数

2.4常见返回码

2.5错误处理

3.编码规范

3.1模块目录命名

3.2一般规则

3.3文件格式

3.4注释方式

3.4.1多行注释

3.4.2单行注释

3.4.3函数注释

3.5预处理

3.6 类型定义

3.7变量定义

3.8函数定义

3.9表达式定义

3.10条件表达式与循环定义

3.11标签label的使用

4.String类型使用规范

4.1概述

4.2格式化

4.3数值转换

4.4正则表达式

5.Time 格式

6.Containers

6.1数组

6.2列表

6.3队列

6.4红黑树

6.5哈希表

6.6通配符匹配

7.内存管理

7.1堆

7.2池

7.3共享内存

8.LOG日志规范

9.Cycle

10.buffer

11.Networking

11.1Connection

12.Events

12.1事件

12.2 I/O 事件

12.3计时器事件

12.4Posted 事件

12.5事件循环

13.进程

14.线程

15.添加模块

15.1添加新模块

15.2核心模块

15.3指令配置