#include <nginx.h>

#include <ngx_config.h>

#include <ngx_core.h>

#include <ngx_http.h>

#include <ngx_http_config.h>

#include "ngx_http_poller.h"

typedef struct {

ngx_http_poller_t *poller;

ngx_conf_t cf;

} ngx_http_poller_conf_ctx_t;

static void *ngx_http_poller_create_conf(ngx_conf_t *cf);

static char *ngx_http_poller_block(ngx_conf_t *cf, ngx_command_t *cmd,

void *conf);

static char *ngx_http_poller(ngx_conf_t *cf, ngx_command_t *dummy, void *conf);

static ngx_int_t ngx_http_poller_init_process(ngx_cycle_t *cycle);

static void ngx_http_poller_event(ngx_event_t *ev);

static ngx_str_t ngx_http_poller_method_get = ngx_string("GET");

static ngx_command_t ngx_http_poller_commands[] = {

{ ngx_string("poller"),

NGX_HTTP_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_TAKE1,

ngx_http_poller_block,

NGX_HTTP_MAIN_CONF_OFFSET,

0,

NULL },

ngx_null_command

};

static ngx_http_module_t ngx_http_poller_module_ctx = {

NULL, /* preconfiguration */

NULL, /* postconfiguration */

ngx_http_poller_create_conf, /* create main configuration */

NULL, /* init main configuration */

NULL, /* create server configuration */

NULL, /* merge server configuration */

NULL, /* create location configuration */

NULL /* merge location configuration */

};

ngx_module_t ngx_http_poller_module = {

NGX_MODULE_V1,

&ngx_http_poller_module_ctx, /* module context */

ngx_http_poller_commands, /* module directives */

NGX_HTTP_MODULE, /* module type */

NULL, /* init master */

NULL, /* init module */

ngx_http_poller_init_process, /* init process */

NULL, /* init thread */

NULL, /* exit thread */

NULL, /* exit process */

NULL, /* exit master */

NGX_MODULE_V1_PADDING

};

static void *

ngx_http_poller_create_conf(ngx_conf_t *cf)

{

ngx_http_poller_conf_t *pcf;

pcf = ngx_pcalloc(cf->pool, sizeof(ngx_http_poller_conf_t));

if (pcf == NULL) {

return NULL;

}

if (ngx_array_init(&pcf->pollers, cf->pool, 1, sizeof(ngx_http_poller_t))

!= NGX_OK) {

return NULL;

}

return pcf;

}

#if NGX_HTTP_SSL

/* lifted almost verbatim from ngx_http_proxy_module.c */

static ngx_int_t

ngx_http_poller_set_ssl(ngx_conf_t *cf, ngx_http_poller_t *poller)

{

ngx_pool_cleanup_t *cln;

ngx_uint_t protocols;

poller->upstream.ssl = ngx_pcalloc(cf->pool, sizeof(ngx_ssl_t));

if (poller->upstream.ssl == NULL) {

return NGX_ERROR;

}

poller->upstream.ssl->log = cf->log;

protocols = NGX_SSL_SSLv2

| NGX_SSL_SSLv3

| NGX_SSL_TLSv1

| NGX_SSL_TLSv1_1

| NGX_SSL_TLSv1_2;

if (ngx_ssl_create(poller->upstream.ssl, protocols, NULL) != NGX_OK) {

return NGX_ERROR;

}

cln = ngx_pool_cleanup_add(cf->pool, 0);

if (cln == NULL) {

return NGX_ERROR;

}

cln->handler = ngx_ssl_cleanup_ctx;

cln->data = poller->upstream.ssl;

return NGX_OK;

}

#endif /* NGX_HTTP_SSL */

static char *

ngx_http_poller_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)

{

ngx_http_poller_conf_ctx_t ctx;

ngx_http_poller_conf_t *pcf = conf;

ngx_http_poller_t *poller;

char *rv;

ngx_str_t *value;

poller = ngx_array_push(&pcf->pollers);

if (poller == NULL) {

return NGX_CONF_ERROR;

}

ngx_memzero(poller, sizeof(ngx_http_poller_t));

if (ngx_array_init(&poller->headers, cf->pool, 1,

sizeof(ngx_http_poller_header_t)) != NGX_OK) {

return NGX_CONF_ERROR;

}

value = cf->args->elts;

poller->name = value[1];

poller->method = ngx_http_poller_method_get;

poller->upstream.buffering = 1;

poller->upstream.connect_timeout = 60000;

poller->upstream.read_timeout = 60000;

poller->upstream.send_timeout = 60000;

poller->upstream.buffer_size = NGX_CONF_UNSET_SIZE;

poller->upstream.bufs.num = 8;

poller->upstream.bufs.size = ngx_pagesize;

poller->upstream.max_temp_file_size = 0;

poller->upstream.temp_file_write_size = 0;

poller->upstream.pass_request_headers = 1;

poller->upstream.pass_request_body = 1;

poller->upstream.hide_headers = NGX_CONF_UNSET_PTR;

poller->upstream.pass_headers = NGX_CONF_UNSET_PTR;

#if NGX_HTTP_SSL

poller->upstream.ssl_session_reuse = 1;

#endif /* NGX_HTTP_SSL */

poller->pool = cf->pool;

ctx.cf = *cf;

ctx.poller = poller;

cf->ctx = &ctx;

cf->handler = ngx_http_poller;

cf->handler_conf = conf;

rv = ngx_conf_parse(cf, NULL);

if (rv != NGX_CONF_OK) {

return rv;

}

if (poller->endpoint.data == NULL) {

ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,

"[poller] %V: endpoint never declared",

&poller->name);

return NGX_CONF_ERROR;

}

/* Other required fields (uri, interval) are complex values that may

* contain variables. We don't require these to evaluate to valid

* values initially.

*/

*cf = ctx.cf;

if (poller->upstream.buffer_size == NGX_CONF_UNSET_SIZE) {

poller->upstream.buffer_size = ngx_pagesize;

}

poller->upstream.busy_buffers_size = 2 * poller->upstream.buffer_size;

return NGX_CONF_OK;

}

static char *

ngx_http_poller_set(ngx_conf_t *cf,

ngx_str_t *value,

ngx_http_complex_value_t *complex)

{

ngx_http_compile_complex_value_t ccv;

if (complex->value.data != NULL) {

ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "[poller] duplicate declaration");

return NGX_CONF_ERROR;

}

ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));

ccv.cf = cf;

ccv.value = value;

ccv.complex_value = complex;

if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {

return NGX_CONF_ERROR;

}

return NGX_CONF_OK;

}

static char *

ngx_http_poller_add_header(ngx_conf_t *cf,

ngx_http_poller_t *poller,

ngx_str_t *name,

ngx_str_t *value)

{

ngx_http_poller_header_t *header;

header = ngx_array_push(&poller->headers);

if (header == NULL) {

return NGX_CONF_ERROR;

}

if (ngx_strcasecmp(name->data, (u_char *)"Content-Length") == 0) {

ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,

"[poller] %V: Content-Length header may not be set",

&poller->name);

return NGX_CONF_ERROR;

}

header->name = *name;

ngx_memzero(&header->value, sizeof(ngx_http_complex_value_t));

return ngx_http_poller_set(cf, value, &header->value);

}

static char *

ngx_http_poller_set_endpoint(ngx_conf_t *cf,

ngx_http_poller_t *poller,

ngx_str_t *value)

{

size_t add;

u_short port;

if (poller->endpoint.data != NULL) {

ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,

"[poller] %V: endpoint already declared",

&poller->name);

return NGX_CONF_ERROR;

}

poller->endpoint = *value;

/* parse the scheme */

if (poller->endpoint.len > 7 &&

ngx_strncmp(poller->endpoint.data, "http://", 7) == 0) {

add = 7;

port = 80;

} else if (poller->endpoint.len > 8 &&

ngx_strncmp(poller->endpoint.data, "https://", 8) == 0) {

#if NGX_HTTP_SSL

add = 8;

port = 443;

if (ngx_http_poller_set_ssl(cf, poller) != NGX_OK) {

return NGX_CONF_ERROR;

}

#else /* !NGX_HTTP_SSL */

ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,

"[poller] %V: endpoint %V: requires SSL support",

&poller->name, &poller->endpoint);

return NGX_CONF_ERROR;

#endif /* NGX_HTTP_SSL */

} else {

ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,

"[poller] %V: endpoint %V: invalid scheme",

&poller->name, &poller->endpoint);

return NGX_CONF_ERROR;

}

poller->scheme.len = add;

poller->scheme.data = poller->endpoint.data;

poller->url.url.len = poller->endpoint.len - add;

poller->url.url.data = poller->endpoint.data + add;

poller->url.default_port = port;

poller->url.uri_part = 1;

poller->url.no_resolve = 1;

poller->upstream.upstream = ngx_http_upstream_add(cf, &poller->url, 0);

if (poller->upstream.upstream == NULL) {

return NGX_CONF_ERROR;

}

return NGX_CONF_OK;

}

static char *

ngx_http_poller_set_method(ngx_conf_t *cf,

ngx_http_poller_t *poller,

ngx_str_t *value)

{

if (poller->method.data != NULL &&

poller->method.data != ngx_http_poller_method_get.data) {

ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,

"[poller] %V: method already declared",

&poller->name);

return NGX_CONF_ERROR;

}

if (ngx_strcmp(value->data, "GET") != 0 &&

ngx_strcmp(value->data, "HEAD") != 0 &&

ngx_strcmp(value->data, "POST") != 0 &&

ngx_strcmp(value->data, "PUT") != 0) {

ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,

"[poller] %V: method '%V' invalid",

&poller->name, value);

return NGX_CONF_ERROR;

}

if (ngx_strcmp(value->data, "POST") == 0 ||

ngx_strcmp(value->data, "PUT") == 0) {

poller->body_ok = 1;

}

poller->method = *value;

return NGX_CONF_OK;

}

static char *

ngx_http_poller(ngx_conf_t *cf, ngx_command_t *dummy, void *conf)

{

ngx_http_poller_conf_ctx_t *ctx;

ngx_http_poller_t *poller;

ngx_str_t *value;

char *rv;

ctx = cf->ctx;

poller = ctx->poller;

value = cf->args->elts;

if (cf->args->nelts == 3 &&

ngx_strcmp(value[0].data, "header") == 0) {

rv = ngx_http_poller_add_header(&ctx->cf, poller, &value[1], &value[2]);

} else if (cf->args->nelts != 2) {

ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,

"invalid number of poller parameters");

rv = NGX_CONF_ERROR;

} else if (ngx_strcmp(value[0].data, "include") == 0) {

rv = ngx_conf_include(cf, dummy, conf);

} else if (ngx_strcmp(value[0].data, "endpoint") == 0) {

rv = ngx_http_poller_set_endpoint(&ctx->cf, poller, &value[1]);

} else if (ngx_strcmp(value[0].data, "method") == 0) {

rv = ngx_http_poller_set_method(&ctx->cf, poller, &value[1]);

} else if (ngx_strcmp(value[0].data, "uri") == 0) {

rv = ngx_http_poller_set(&ctx->cf, &value[1], &poller->uri);

} else if (ngx_strcmp(value[0].data, "body") == 0) {

rv = ngx_http_poller_set(&ctx->cf, &value[1], &poller->body);

} else if (ngx_strcmp(value[0].data, "interval") == 0) {

rv = ngx_http_poller_set(&ctx->cf, &value[1], &poller->interval);

} else {

ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,

"invalid poller directive '%V'", &value[0]);

rv = NGX_CONF_ERROR;

}

return rv;

}

/* this should be called after the poller was found in the config. */

ngx_int_t

ngx_http_poller_set_handler(ngx_http_poller_conf_t *conf,

ngx_str_t *name,

ngx_http_poller_handler_t *handler)

{

ngx_http_poller_t *poller;

ngx_int_t found;

ngx_uint_t i;

found = 0;

poller = conf->pollers.elts;

for (i = 0; i < conf->pollers.nelts; ++i) {

if (poller[i].name.len == name->len &&

ngx_strncmp(poller[i].name.data, name->data, name->len) == 0) {

poller[i].handler = *handler;

found = 1;

break;

}

}

return (found) ? NGX_OK : NGX_ERROR;

}

static ngx_int_t

ngx_http_poller_init_process(ngx_cycle_t *cycle)

{

ngx_http_poller_conf_t *pcf;

ngx_http_poller_t *poller;

ngx_log_t *log;

ngx_event_t *ev;

ngx_uint_t i;

pcf = ngx_http_cycle_get_module_main_conf(cycle, ngx_http_poller_module);

if (pcf == NULL) {

ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,

"[poller] no module context");

return NGX_ERROR;

}

poller = pcf->pollers.elts;

for (i = 0; i < pcf->pollers.nelts; ++i) {

log = &poller[i].log;

log->action = "initializing";

log->file = cycle->new_log.file;

/* only install the poll event if the endpoint is defined. */

if (poller[i].endpoint.data != NULL) {

ev = &poller[i].poll_event;

ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0,

"[poller] %V: activated (endpoint %V)",

&poller[i].name, &poller[i].endpoint);

ev->data = &poller[i];

ev->log = log;

ev->handler = ngx_http_poller_event;

ngx_add_timer(ev, 0);

} else {

ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0,

"[poller] %V: inactive (no endpoint)",

&poller[i].name);

}

}

return NGX_OK;

}

static ngx_int_t

ngx_http_poller_create_request(ngx_http_request_t *r)

{

ngx_http_poller_t *poller;

ngx_http_poller_header_t *header;

ngx_str_t *value;

ngx_buf_t *b;

ngx_chain_t *cl;

ngx_uint_t i;

size_t len;

ngx_str_t uri;

ngx_str_t body;

ngx_array_t headers;

poller = ngx_http_get_module_ctx(r, ngx_http_poller_module);

if (ngx_http_complex_value(r, &poller->uri, &uri) != NGX_OK) {

return NGX_ERROR;

}

body.len = 0;

body.data = NULL;

if (poller->body_ok) {

if (ngx_http_complex_value(r, &poller->body, &body) != NGX_OK) {

return NGX_ERROR;

}

}

len = poller->method.len;

len += sizeof(" ") - 1;

len += uri.len;

len += sizeof(" HTTP/1.0") - 1;

len += sizeof(CRLF) - 1;

if (poller->headers.nelts > 0) {

if (ngx_array_init(&headers, r->pool, poller->headers.nelts,

sizeof(ngx_str_t)) != NGX_OK) {

return NGX_ERROR;

}

header = poller->headers.elts;

for (i = 0; i < poller->headers.nelts; ++i) {

value = ngx_array_push(&headers);

if (value == NULL) {

return NGX_ERROR;

}

if (ngx_http_complex_value(r, &header[i].value, value) != NGX_OK) {

return NGX_ERROR;

}

len += header[i].name.len;

len += sizeof(": ") - 1;

len += value->len;

len += sizeof(CRLF) - 1;

}

}

if (poller->body_ok) {

len += sizeof("Content-Length: ") - 1 + NGX_OFF_T_LEN + 2;

}

len += sizeof(CRLF) - 1;

b = ngx_create_temp_buf(r->pool, len);

if (b == NULL) {

return NGX_ERROR;

}

#define DO_CPYMEM(x, y) x = ngx_cpymem(x, y, sizeof(y) - 1)

#define DO_CPYSTR(x, y) x = ngx_cpymem(x, y.data, y.len)

DO_CPYSTR(b->last, poller->method);

DO_CPYMEM(b->last, " ");

DO_CPYSTR(b->last, uri);

DO_CPYMEM(b->last, " HTTP/1.0");

DO_CPYMEM(b->last, CRLF);

if (poller->headers.nelts > 0) {

header = poller->headers.elts;

value = headers.elts;

for (i = 0; i < poller->headers.nelts; ++i) {

DO_CPYSTR(b->last, header[i].name);

DO_CPYMEM(b->last, ": ");

DO_CPYSTR(b->last, value[i]);

DO_CPYMEM(b->last, CRLF);

}

}

if (poller->body_ok) {

b->last = ngx_sprintf(b->last, "Content-Length: %O", (off_t)body.len);

DO_CPYMEM(b->last, CRLF);

}

DO_CPYMEM(b->last, CRLF);

if (poller->body_ok && body.len > 0) {

DO_CPYSTR(b->last, body);

}

#undef DO_CPYMEM

#undef DO_CPYSTR

cl = ngx_alloc_chain_link(r->pool);

if (cl == NULL) {

return NGX_ERROR;

}

cl->buf = b;

cl->next = NULL;

r->upstream->request_bufs = cl;

r->subrequest_in_memory = 1;

b->last_buf = 1;

return NGX_OK;

}

static ngx_int_t

ngx_http_poller_process_header(ngx_http_request_t *r)

{

static ngx_str_t content_length = ngx_string("Content-Length");

ngx_http_poller_t *poller;

ngx_http_upstream_t *u;

ngx_int_t rc;

ngx_str_t name;

ngx_str_t value;

poller = ngx_http_get_module_ctx(r, ngx_http_poller_module);

if (poller == NULL) {

return NGX_ERROR;

}

u = r->upstream;

for ( ;; ) {

rc = ngx_http_parse_header_line(r, &r->upstream->buffer, 1);

if (rc == NGX_OK) {

name.len = r->header_name_end - r->header_name_start;

name.data = r->header_name_start;

value.len = r->header_end - r->header_start;

value.data = r->header_start;

if (name.len == content_length.len &&

ngx_strncasecmp(name.data, content_length.data, name.len) == 0) {

u->headers_in.content_length_n = ngx_atoof(value.data, value.len);

}

if (poller->handler.header != NULL) {

poller->handler.header(r, &name, &value);

}

continue;

}

if (rc == NGX_HTTP_PARSE_HEADER_DONE) {

return NGX_OK;

}

if (rc == NGX_AGAIN) {

return NGX_AGAIN;

}

ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,

"upstream sent invalid header");

return NGX_HTTP_UPSTREAM_INVALID_HEADER;

}

}

static ngx_int_t

ngx_http_poller_process_status_line(ngx_http_request_t *r)

{

ngx_int_t rc;

ngx_http_upstream_t *u;

ngx_http_poller_t *poller;

poller = ngx_http_get_module_ctx(r, ngx_http_poller_module);

if (poller == NULL) {

return NGX_ERROR;

}

u = r->upstream;

rc = ngx_http_parse_status_line(r, &u->buffer, &poller->status);

if (rc == NGX_AGAIN) {

return rc;

}

if (rc == NGX_ERROR) {

if (u->state) {

u->state->status = NGX_HTTP_OK;

}

u->headers_in.connection_close = 1;

return NGX_OK;

}

if (u->state) {

u->state->status = poller->status.code;

}

u->headers_in.connection_close = 1;

if (poller->handler.status != NULL) {

poller->handler.status(r, &poller->status);

}

ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,

"[poller] %V: status = %uD",

&poller->name, (uint32_t)poller->status.code);

r->upstream->process_header = ngx_http_poller_process_header;

return ngx_http_poller_process_header(r);

}

static ngx_int_t

ngx_http_poller_reinit_request(ngx_http_request_t *r)

{

ngx_http_poller_t *poller;

poller = ngx_http_get_module_ctx(r, ngx_http_poller_module);

if (poller == NULL) {

return NGX_OK;

}

ngx_memzero(&poller->status, sizeof(ngx_http_status_t));

r->upstream->process_header = ngx_http_poller_process_status_line;

return NGX_OK;

}

static ngx_int_t

ngx_http_poller_filter_init(void *data)

{

ngx_http_request_t *r = data;

ngx_http_upstream_t *u;

ngx_http_poller_t *poller;

u = r->upstream;

u->length = u->headers_in.content_length_n;

poller = ngx_http_get_module_ctx(r, ngx_http_poller_module);

if (poller == NULL) {

return NGX_ERROR;

}

ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,

"[poller] %V: response length = %d",

&poller->name, (int)u->length);

return NGX_OK;

}

static ngx_int_t

ngx_http_poller_filter(void *data, ssize_t bytes)

{

ngx_http_request_t *r = data;

ngx_http_upstream_t *u;

ngx_http_poller_t *poller;

ngx_str_t body;

poller = ngx_http_get_module_ctx(r, ngx_http_poller_module);

if (poller == NULL) {

return NGX_ERROR;

}

u = r->upstream;

ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,

"[poller] %V: received %d bytes, length = %d",

&poller->name, (int)bytes, (int)u->length);

if (bytes > 0) {

if (poller->handler.body != NULL) {

body.data = u->buffer.last;

body.len = bytes;

poller->handler.body(r, &body);

}

}

if (u->length == -1) {

return NGX_OK;

}

u->length -= bytes;

return NGX_OK;

}

static void

ngx_http_poller_abort_request(ngx_http_request_t *r)

{

ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,

"[poller] aborted upstream request");

return;

}

static void

ngx_http_poller_finalize_request(ngx_http_request_t *r, ngx_int_t rc)

{

ngx_http_poller_t *poller;

ngx_str_t interval;

ngx_time_t *tp;

ngx_msec_t msec;

uint64_t now;

poller = ngx_http_get_module_ctx(r, ngx_http_poller_module);

if (poller->handler.finalize != NULL) {

poller->handler.finalize(r, rc);

}

if (ngx_http_complex_value(r, &poller->interval, &interval) != NGX_OK) {

return;

}

msec = ngx_parse_time(&interval, 0);

if (msec == (ngx_msec_t)NGX_ERROR) {

return;

}

tp = ngx_timeofday();

now = tp->sec * 1000 + tp->msec;

if (now > poller->poll_start) {

if (now - poller->poll_start < msec) {

msec -= (now - poller->poll_start);

} else {

msec = 0;

}

}

ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,

"[poller] %V: calling again in %uD ms",

&poller->name, (uint32_t)msec);

ngx_add_timer(&poller->poll_event, msec);

r->connection->log->log_level = NGX_LOG_EMERG;

}

static void *

ngx_http_poller_destroy_pools(ngx_pool_t *cpool, ngx_pool_t *rpool)

{

if (cpool != NULL) {

ngx_destroy_pool(cpool);

}

if (rpool != NULL) {

ngx_destroy_pool(rpool);

}

return NULL;

}

static ngx_http_request_t *

ngx_http_poller_request(ngx_http_poller_t *poller)

{

ngx_connection_t *c;

ngx_http_request_t *r;

ngx_http_upstream_t *u;

ngx_log_t *log;

ngx_http_log_ctx_t *ctx;

ngx_http_core_main_conf_t *cmcf;

ngx_http_conf_ctx_t *cctx;

ngx_pool_t *cpool = NULL;

ngx_pool_t *rpool = NULL;

ngx_time_t *tp;

struct sockaddr_in *sin;

log = &poller->log;

log->log_level = NGX_LOG_DEBUG_CONNECTION | NGX_LOG_DEBUG_ALL;

/* using connection_pool_size default */

cpool = ngx_create_pool(256, log);

if (cpool == NULL) {

return ngx_http_poller_destroy_pools(cpool, rpool);

}

c = ngx_pcalloc(poller->pool, sizeof(ngx_connection_t));

if (c == NULL) {

return ngx_http_poller_destroy_pools(cpool, rpool);

}

c->read = ngx_pcalloc(cpool, sizeof(ngx_event_t));

if (c->read == NULL) {

return ngx_http_poller_destroy_pools(cpool, rpool);

}

c->write = ngx_pcalloc(cpool, sizeof(ngx_event_t));

if (c->write == NULL) {

return ngx_http_poller_destroy_pools(cpool, rpool);

}

c->local_sockaddr = ngx_pcalloc(cpool, sizeof(struct sockaddr_in));

if (c->local_sockaddr == NULL) {

return ngx_http_poller_destroy_pools(cpool, rpool);

}

c->pool = cpool;

c->log = log;

c->local_sockaddr->sa_family = AF_INET;

sin = (struct sockaddr_in *)c->local_sockaddr;

sin->sin_addr.s_addr = 0x0100007f;

c->read->log = log;

c->write->log = log;

c->log->log_level = NGX_LOG_DEBUG_CONNECTION | NGX_LOG_DEBUG_ALL;

c->requests++;

/* using request_pool_size default */

rpool = ngx_create_pool(4096, log);

if (rpool == NULL) {

return ngx_http_poller_destroy_pools(cpool, rpool);

}

r = ngx_pcalloc(rpool, sizeof(ngx_http_request_t));

if (r == NULL) {

return ngx_http_poller_destroy_pools(cpool, rpool);

}

r->pool = rpool;

r->connection = c;

cctx = (ngx_http_conf_ctx_t *)ngx_cycle->conf_ctx[ngx_http_module.index];

r->main_conf = cctx->main_conf;

r->srv_conf = cctx->srv_conf;

r->loc_conf = cctx->loc_conf;

if (ngx_list_init(&r->headers_out.headers, r->pool, 20,

sizeof(ngx_table_elt_t)) != NGX_OK) {

return ngx_http_poller_destroy_pools(cpool, rpool);

}

r->ctx = ngx_pcalloc(r->pool, sizeof(void *) * ngx_http_max_module);

if (r->ctx == NULL) {

return ngx_http_poller_destroy_pools(cpool, rpool);

}

cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

r->variables = ngx_pcalloc(r->pool, cmcf->variables.nelts

* sizeof(ngx_http_variable_value_t));

if (r->variables == NULL) {

return ngx_http_poller_destroy_pools(cpool, rpool);

}

r->main = r;

r->count = 1;

tp = ngx_timeofday();

r->start_sec = tp->sec;

r->start_msec = tp->msec;

ctx = ngx_palloc(c->pool, sizeof(ngx_http_log_ctx_t));

if (ctx == NULL) {

return ngx_http_poller_destroy_pools(cpool, rpool);

}

ctx->connection = c;

ctx->request = r;

ctx->current_request = r;

c->log->data = ctx;

c->log->action = "polling";

c->log_error = NGX_ERROR_INFO;

c->write->active = 1;

c->fd = -1;

c->data = r;

if (ngx_http_upstream_create(r) != NGX_OK) {

return ngx_http_poller_destroy_pools(cpool, rpool);

}

ngx_http_set_ctx(r, poller, ngx_http_poller_module);

u = r->upstream;

#if (NGX_HTTP_SSL)

if (conf->upstream.ssl != NULL) {

u->ssl = 1;

}

#endif

u->output.tag = (ngx_buf_tag_t)&ngx_http_poller_module;

u->headers_in.content_length_n = -1;

u->conf = &poller->upstream;

ngx_memzero(&poller->status, sizeof(ngx_http_status_t));

u->create_request = ngx_http_poller_create_request;

u->reinit_request = ngx_http_poller_reinit_request;

u->process_header = ngx_http_poller_process_status_line;

u->abort_request = ngx_http_poller_abort_request;

u->finalize_request = ngx_http_poller_finalize_request;

u->buffering = 1;

u->input_filter_init = ngx_http_poller_filter_init;

u->input_filter = ngx_http_poller_filter;

u->input_filter_ctx = r;

return r;

}

static void

ngx_http_poller_event(ngx_event_t *ev)

{

ngx_http_poller_t *poller = ev->data;

ngx_http_request_t *r;

ngx_time_t *tp;

if (ngx_exiting) {

return;

}

tp = ngx_timeofday();

poller->poll_start = tp->sec * 1000 + tp->msec;

r = ngx_http_poller_request(poller);

if (r != NULL) {

ngx_http_upstream_init(r);

}

}