コード例 #1
0
static void ngx_stream_mruby_exit_worker(ngx_cycle_t *cycle)
{
  ngx_stream_mruby_main_conf_t *mmcf = ngx_stream_cycle_get_module_main_conf(cycle, ngx_stream_mruby_module);

  if (mmcf == NULL)
    return;

  if (mmcf->exit_worker_code != NGX_CONF_UNSET_PTR)
    ngx_stream_mrb_run_cycle(cycle, mmcf->ctx->mrb, mmcf->exit_worker_code);
}
コード例 #2
0
static ngx_int_t ngx_stream_mruby_init_worker(ngx_cycle_t *cycle)
{
  ngx_stream_mruby_main_conf_t *mmcf = ngx_stream_cycle_get_module_main_conf(cycle, ngx_stream_mruby_module);

  if (mmcf == NULL)
    return NGX_OK;

  if (mmcf->init_worker_code != NGX_CONF_UNSET_PTR)
    return ngx_stream_mrb_run_cycle(cycle, mmcf->ctx->mrb, mmcf->init_worker_code);

  return NGX_OK;
}
コード例 #3
0
ngx_int_t
ngx_stream_upm_init_worker(ngx_cycle_t * cycle)
{
    u_char                          *p;
    //ngx_int_t                        rc;
    ngx_connection_t                *c;
    //ngx_connection_t                *pc;
    ngx_stream_upm_ctx_t            *ctx;
    ngx_stream_session_t            *fake_session;
    ngx_stream_upstream_t           *u;
    //ngx_peer_connection_t           *peer;
    ngx_stream_upm_main_conf_t      *ummcf;
    ngx_stream_upstream_srv_conf_t  *uscf; 

    //Fake a client session
    ummcf = ngx_stream_cycle_get_module_main_conf(cycle, ngx_stream_upm_module);
    ummcf->fake_session = ngx_pcalloc(cycle->pool, sizeof(ngx_stream_session_t));
    if (ummcf->fake_session == NULL) {
        return NGX_ERROR;    
    }

    fake_session = ummcf->fake_session;
    //Fake the client fd as 254
    c = ngx_get_connection(254, cycle->log);
    if (c == NULL) {
        return NGX_ERROR;
    }
    //Set the fake conn's base items
    c->pool = cycle->pool;
    c->log = cycle->log;

    fake_session->signature = NGX_STREAM_MODULE;
    fake_session->main_conf = ((ngx_stream_conf_ctx_t *)cycle->conf_ctx)->main_conf;
    fake_session->srv_conf = ((ngx_stream_conf_ctx_t *)cycle->conf_ctx)->srv_conf;

    fake_session->connection = c;
    c->data = fake_session;

    u = ngx_pcalloc(c->pool, sizeof(ngx_stream_upstream_t));
    if (u == NULL) {
        return NGX_ERROR;
    }
    fake_session->upstream = u;
    
    //Init the upm ctx;
    fake_session->ctx = ngx_pcalloc(cycle->pool, sizeof(void *) * ngx_stream_max_module);
    if (fake_session->ctx == NULL) {
        return NGX_ERROR;
    }
    ctx = ngx_pcalloc(cycle->pool, sizeof(ngx_stream_upm_ctx_t));
    ngx_stream_set_ctx(fake_session, ctx, ngx_stream_upm_module);
    
    ctx->state = CONNECT;
    ctx->connect = ngx_stream_upm_connect;
    ctx->create_request = ngx_stream_upm_create_request;
    ctx->send_request = ngx_stream_upm_send_request;
    ctx->read_and_parse_response = ngx_stream_upm_read_and_parse_response;
    //ctx->process_response = ngx_stream_upm_process_response;

    u->peer.log = cycle->log;
    u->peer.log_error = NGX_ERROR_ERR;
    //whitout need set the local
    u->peer.local = NULL;

    uscf = ummcf->upstream;
    if (uscf->peer.init(fake_session, uscf) != NGX_OK) {
        return NGX_ERROR;
    }

    u->peer.start_time = ngx_current_msec;

    if (ummcf->next_upstream_tries
        && u->peer.tries > ummcf->next_upstream_tries)
    {
        u->peer.tries = ummcf->next_upstream_tries;
    }
    u->start_sec = ngx_time();

    //May without need alloc the downstream_buf
    p = ngx_pnalloc(c->pool, ummcf->buffer_size);
    if (p == NULL) {
        return NGX_ERROR;
    }
    
    //web use the downstream_buf to buffer the request;
    u->downstream_buf.start = p;
    u->downstream_buf.end = p + ummcf->buffer_size;
    u->downstream_buf.pos = p;
    u->downstream_buf.last = p;

    c->write->handler = ngx_stream_upm_empty_handler;
    c->read->handler = ngx_stream_upm_empty_handler;

    return ngx_stream_upm_connect(fake_session);
}