void uv__stream_destroy(uv_stream_t* stream) {
uv_write_t* req;
ngx_queue_t* q;
assert(stream->flags & UV_CLOSED);
while (!ngx_queue_empty(&stream->write_queue)) {
q = ngx_queue_head(&stream->write_queue);
ngx_queue_remove(q);
req = ngx_queue_data(q, uv_write_t, queue);
if (req->bufs != req->bufsml)
free(req->bufs);
if (req->cb) {
uv__set_artificial_error(req->handle->loop, UV_EINTR);
req->cb(req, -1);
}
}
while (!ngx_queue_empty(&stream->write_completed_queue)) {
q = ngx_queue_head(&stream->write_completed_queue);
ngx_queue_remove(q);
req = ngx_queue_data(q, uv_write_t, queue);
if (req->cb) {
uv__set_sys_error(stream->loop, req->error);
req->cb(req, req->error ? -1 : 0);
}
}
}
ngx_queue_t *
ngx_queue_middle(ngx_queue_t *queue)
{
ngx_queue_t *middle, *next;
middle = ngx_queue_head(queue);
if (middle == ngx_queue_last(queue)) {
return middle;
}
next = ngx_queue_head(queue);
for ( ;; ) {
middle = ngx_queue_next(middle);
next = ngx_queue_next(next);
if (next == ngx_queue_last(queue)) {
return middle;
}
next = ngx_queue_next(next);
if (next == ngx_queue_last(queue)) {
return middle;
}
}
}
// 参考：http://blog.csdn.net/livelylittlefish/article/details/6607324
// 获得队列的中间节点，(除头节点外)若队列有奇数个节点，则返回中间节点；
// 若队列有偶数个节点，则返回后半个队列的第一个节点;
ngx_queue_t *
ngx_queue_middle(ngx_queue_t *queue)
{
ngx_queue_t *middle, *next;
middle = ngx_queue_head(queue);
//若只有一个元素
if (middle == ngx_queue_last(queue)) {
return middle;
}
next = ngx_queue_head(queue);
// 此循环中，next指针每次移动两个节点，而middle指针每次移动一个节点
for ( ;; ) {
middle = ngx_queue_next(middle);
next = ngx_queue_next(next);
// 偶数个节点，在此返回后半个队列的第一个节点
if (next == ngx_queue_last(queue)) {
return middle;
}
next = ngx_queue_next(next);
// 奇数个节点，在此返回中间节点
if (next == ngx_queue_last(queue)) {
return middle;
}
}
}
static void
ngx_http_create_locations_list(ngx_queue_t *locations, ngx_queue_t *q)
{
u_char *name;
size_t len;
ngx_queue_t *x, tail;
ngx_http_location_queue_t *lq, *lx;
if (q == ngx_queue_last(locations)) {
return;
}
lq = (ngx_http_location_queue_t *) q;
if (lq->inclusive == NULL) {
ngx_http_create_locations_list(locations, ngx_queue_next(q));
return;
}
len = lq->name->len;
name = lq->name->data;
for (x = ngx_queue_next(q);
x != ngx_queue_sentinel(locations);
x = ngx_queue_next(x))
{
lx = (ngx_http_location_queue_t *) x;
if (len > lx->name->len
|| (ngx_strncmp(name, lx->name->data, len) != 0))
{
break;
}
}
q = ngx_queue_next(q);
if (q == x) {
ngx_http_create_locations_list(locations, x);
return;
}
ngx_queue_split(locations, q, &tail);
ngx_queue_add(&lq->list, &tail);
if (x == ngx_queue_sentinel(locations)) {
ngx_http_create_locations_list(&lq->list, ngx_queue_head(&lq->list));
return;
}
ngx_queue_split(&lq->list, x, &tail);
ngx_queue_add(locations, &tail);
ngx_http_create_locations_list(&lq->list, ngx_queue_head(&lq->list));
ngx_http_create_locations_list(locations, x);
}
static void
ngx_http_push_stream_send_old_messages(ngx_http_request_t *r, ngx_http_push_stream_channel_t *channel, ngx_uint_t backtrack, time_t if_modified_since, ngx_int_t tag, time_t greater_message_time, ngx_int_t greater_message_tag, ngx_str_t *last_event_id)
{
ngx_http_push_stream_module_ctx_t *ctx = ngx_http_get_module_ctx(r, ngx_http_push_stream_module);
ngx_http_push_stream_msg_t *message;
ngx_queue_t *q;
if (ngx_http_push_stream_has_old_messages_to_send(channel, backtrack, if_modified_since, tag, greater_message_time, greater_message_tag, last_event_id)) {
if (backtrack > 0) {
ngx_uint_t qtd = (backtrack > channel->stored_messages) ? channel->stored_messages : backtrack;
ngx_uint_t start = channel->stored_messages - qtd;
ngx_shmtx_lock(channel->mutex);
// positioning at first message, and send the others
for (q = ngx_queue_head(&channel->message_queue); (qtd > 0) && q != ngx_queue_sentinel(&channel->message_queue); q = ngx_queue_next(q)) {
message = ngx_queue_data(q, ngx_http_push_stream_msg_t, queue);
if (message->deleted) {
break;
}
if (start == 0) {
qtd--;
ngx_http_push_stream_send_response_message(r, channel, message, 0, ctx->message_sent);
} else {
start--;
}
}
ngx_shmtx_unlock(channel->mutex);
} else if ((last_event_id != NULL) || (if_modified_since >= 0)) {
ngx_flag_t found = 0;
ngx_shmtx_lock(channel->mutex);
for (q = ngx_queue_head(&channel->message_queue); q != ngx_queue_sentinel(&channel->message_queue); q = ngx_queue_next(q)) {
message = ngx_queue_data(q, ngx_http_push_stream_msg_t, queue);
if (message->deleted) {
break;
}
if ((!found) && (last_event_id != NULL) && (message->event_id != NULL) && (ngx_memn2cmp(message->event_id->data, last_event_id->data, message->event_id->len, last_event_id->len) == 0)) {
found = 1;
continue;
}
if ((!found) && (if_modified_since >= 0) && ((message->time > if_modified_since) || ((message->time == if_modified_since) && (tag >= 0) && (message->tag >= tag)))) {
found = 1;
if ((message->time == if_modified_since) && (message->tag == tag)) {
continue;
}
}
if (found && (((greater_message_time == 0) && (greater_message_tag == -1)) || (greater_message_time > message->time) || ((greater_message_time == message->time) && (greater_message_tag >= message->tag)))) {
ngx_http_push_stream_send_response_message(r, channel, message, 0, ctx->message_sent);
}
}
ngx_shmtx_unlock(channel->mutex);
}
}
}
int main(int argc, char *argv[])
{
ngx_int_t n;
ngx_log_t * log;
ngx_queue_t queue_container;
ngx_queue_t *q;
test_node node[5];
test_node *ele_node;
ngx_pagesize = getpagesize();
n = ngx_strerror_init();
if (n == NGX_ERROR){
return NGX_ERROR;
}
ngx_time_init();
log = ngx_log_init((u_char *)"./");
ngx_use_stderr = 0;
if (log == NULL){
ngx_log_stderr(NGX_ERROR,(const char*)"can not init log ");
return NGX_ERROR;
}
ngx_queue_init(&queue_container);
for (n = 0;n < 5;n++){
node[n].num = n;
}
ngx_queue_insert_tail(&queue_container,&node[0].queue);
ngx_queue_insert_head(&queue_container,&node[1].queue);
ngx_queue_insert_after(&queue_container,&node[2].queue);
ngx_queue_insert_head(&queue_container,&node[3].queue);
ngx_queue_insert_tail(&queue_container,&node[4].queue);
for (q = ngx_queue_head(&queue_container);
q != ngx_queue_sentinel(&queue_container);
q = ngx_queue_next(q)){
ele_node = ngx_queue_data(q,test_node,queue);
printf("%d\n",ele_node->num);
}
ngx_queue_sort(&queue_container,cmp_test_node);
for (q = ngx_queue_head(&queue_container);
q != ngx_queue_sentinel(&queue_container);
q = ngx_queue_next(q)){
ele_node = ngx_queue_data(q,test_node,queue);
printf("%d\n",ele_node->num);
}
return NGX_OK;
}
void uv__stream_destroy(uv_stream_t* stream) {
uv_write_t* req;
ngx_queue_t* q;
assert(!uv__io_active(&stream->io_watcher, UV__POLLIN | UV__POLLOUT));
assert(stream->flags & UV_CLOSED);
if (stream->connect_req) {
uv__req_unregister(stream->loop, stream->connect_req);
uv__set_artificial_error(stream->loop, UV_ECANCELED);
stream->connect_req->cb(stream->connect_req, -1);
stream->connect_req = NULL;
}
while (!ngx_queue_empty(&stream->write_queue)) {
q = ngx_queue_head(&stream->write_queue);
ngx_queue_remove(q);
req = ngx_queue_data(q, uv_write_t, queue);
uv__req_unregister(stream->loop, req);
if (req->bufs != req->bufsml)
free(req->bufs);
if (req->cb) {
uv__set_artificial_error(req->handle->loop, UV_ECANCELED);
req->cb(req, -1);
}
}
while (!ngx_queue_empty(&stream->write_completed_queue)) {
q = ngx_queue_head(&stream->write_completed_queue);
ngx_queue_remove(q);
req = ngx_queue_data(q, uv_write_t, queue);
uv__req_unregister(stream->loop, req);
if (req->cb) {
uv__set_sys_error(stream->loop, req->error);
req->cb(req, req->error ? -1 : 0);
}
}
if (stream->shutdown_req) {
uv__req_unregister(stream->loop, stream->shutdown_req);
uv__set_artificial_error(stream->loop, UV_ECANCELED);
stream->shutdown_req->cb(stream->shutdown_req, -1);
stream->shutdown_req = NULL;
}
}
static ngx_btt_peer_t *
ngx_btt_get_peer(ngx_btt_conf_t *bcf, ngx_btt_ctx_t *ctx, ngx_rbtree_t *tree,
ngx_queue_t *queue)
{
ngx_queue_t *q;
ngx_btt_peer_t *p;
p = NULL;
if (!ngx_queue_empty(&bcf->btt->free_peers)) {
q = ngx_queue_head(&bcf->btt->free_peers);
ngx_queue_remove(q);
p = ngx_queue_data(q, ngx_btt_peer_t, queue);
}
if (p == NULL) {
p = ngx_slab_alloc_locked(bcf->pool, sizeof(ngx_btt_peer_t));
if (p == NULL) {
return NULL;
}
}
/* TODO */
ngx_memcpy(&p->connection_id, &ctx->connection_id,
sizeof(ctx->connection_id));
p->node.key = ngx_crc32_short((u_char *) &ctx->connection_id,
sizeof(ctx->connection_id));
ngx_rbtree_insert(tree, &p->node);
ngx_queue_insert_head(queue, &p->queue);
return p;
}
static void uv__write_callbacks(uv_tcp_t* tcp) {
int callbacks_made = 0;
ngx_queue_t* q;
uv_write_t* req;
while (!ngx_queue_empty(&tcp->write_completed_queue)) {
/* Pop a req off write_completed_queue. */
q = ngx_queue_head(&tcp->write_completed_queue);
assert(q);
req = ngx_queue_data(q, struct uv_write_s, queue);
ngx_queue_remove(q);
/* NOTE: call callback AFTER freeing the request data. */
if (req->cb) {
req->cb(req, 0);
}
callbacks_made++;
}
assert(ngx_queue_empty(&tcp->write_completed_queue));
/* Write queue drained. */
if (!uv_write_queue_head(tcp)) {
uv__drain(tcp);
}
}
// 遍历队列，取出队列里的事件，调用对应的handler
// cycle参数只用于记录日志
void
ngx_event_process_posted(ngx_cycle_t *cycle, ngx_queue_t *posted)
{
ngx_queue_t *q;
ngx_event_t *ev;
while (!ngx_queue_empty(posted)) {
// 取队列头节点
q = ngx_queue_head(posted);
// 获取头节点元素，即事件
ev = ngx_queue_data(q, ngx_event_t, queue);
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
"posted event %p", ev);
// in ngx_event_posted.h
// 函数宏，从队列里移除
ngx_delete_posted_event(ev);
// 执行事件的回调函数
ev->handler(ev);
}
}
void
ngx_queue_sort(ngx_queue_t *queue,
ngx_int_t (*cmp)(const ngx_queue_t *, const ngx_queue_t *))
{
ngx_queue_t *q, *prev, *next;
q = ngx_queue_head(queue);
if (q == ngx_queue_last(queue)) {
return;
}
for (q = ngx_queue_next(q); q != ngx_queue_sentinel(queue); q = next) {
prev = ngx_queue_prev(q);
next = ngx_queue_next(q);
ngx_queue_remove(q);
do {
if (cmp(prev, q) <= 0) {/* 比较 */
break;
}
prev = ngx_queue_prev(prev); /* prev指针前移 */
} while (prev != ngx_queue_sentinel(queue));
ngx_queue_insert_after(prev, q);/* 将q插入prev节点之后(此处即为简单插入) */
}
}
static void uv__udp_run_completed(uv_udp_t* handle) {
uv_udp_send_t* req;
ngx_queue_t* q;
while (!ngx_queue_empty(&handle->write_completed_queue)) {
q = ngx_queue_head(&handle->write_completed_queue);
ngx_queue_remove(q);
req = ngx_queue_data(q, uv_udp_send_t, queue);
uv__req_unregister(handle->loop, req);
if (req->bufs != req->bufsml)
free(req->bufs);
req->bufs = NULL;
if (req->send_cb == NULL)
continue;
/* req->status >= 0 == bytes written
* req->status < 0 == errno
*/
if (req->status >= 0) {
req->send_cb(req, 0);
}
else {
uv__set_sys_error(handle->loop, -req->status);
req->send_cb(req, -1);
}
}
}
static void
ngx_http_gettoken_close_connection(ngx_http_gettoken_connection_t *c)
{
ngx_queue_t *q;
if (c->conn.connection) {
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0, "http_gettoken: Closing connection (fd=%d)",
c->conn.connection->fd);
ngx_close_connection(c->conn.connection);
c->conn.connection = NULL;
}
q = ngx_queue_head(&c->server->free_connections);
while (q != ngx_queue_sentinel(&c->server->free_connections)) {
if (q == &c->queue) {
ngx_queue_remove(q);
break;
}
q = ngx_queue_next(q);
}
c->rctx = NULL;
if (c->state != STATE_DISCONNECTED) {
c->state = STATE_DISCONNECTED;
ngx_add_timer(&c->reconnect_event, c->server->reconnect_timeout);
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0, "http_gettoken: Connection scheduled for reconnection in %d ms", c->server->reconnect_timeout);
}
}
void
ngx_postgres_keepalive_cleanup(void *data)
{
ngx_postgres_upstream_srv_conf_t *pgscf = data;
ngx_postgres_keepalive_cache_t *item;
ngx_queue_t *q;
dd("entering");
/* ngx_queue_empty is broken when used on unitialized queue */
if (pgscf->cache.prev == NULL) {
dd("returning");
return;
}
/* just to be on the safe-side */
pgscf->max_cached = 0;
while (!ngx_queue_empty(&pgscf->cache)) {
q = ngx_queue_head(&pgscf->cache);
ngx_queue_remove(q);
item = ngx_queue_data(q, ngx_postgres_keepalive_cache_t,
queue);
dd("postgres: disconnecting %p", item->connection);
ngx_postgres_upstream_free_connection(item->connection->log,
item->connection,
item->pgconn, pgscf);
}
dd("returning");
}
void
ngx_queue_sort(ngx_queue_t *queue,
intptr_t (*cmp)(const ngx_queue_t *, const ngx_queue_t *))
{
ngx_queue_t *q, *prev, *next;
q = ngx_queue_head(queue);
if (q == ngx_queue_last(queue)) {
return;
}
for (q = ngx_queue_next(q); q != ngx_queue_sentinel(queue); q = next) {
prev = ngx_queue_prev(q);
next = ngx_queue_next(q);
ngx_queue_remove(q);
do {
if (cmp(prev, q) <= 0) {
break;
}
prev = ngx_queue_prev(prev);
} while (prev != ngx_queue_sentinel(queue));
ngx_queue_insert_after(prev, q);
}
}
static ngx_http_push_stream_pid_queue_t *
ngx_http_push_stream_get_worker_subscriber_channel_sentinel_locked(ngx_slab_pool_t *shpool, ngx_http_push_stream_channel_t *channel, ngx_log_t *log)
{
ngx_http_push_stream_pid_queue_t *worker_sentinel;
ngx_queue_t *q;
for (q = ngx_queue_head(&channel->workers_with_subscribers); q != ngx_queue_sentinel(&channel->workers_with_subscribers); q = ngx_queue_next(q)) {
worker_sentinel = ngx_queue_data(q, ngx_http_push_stream_pid_queue_t, queue);
if (worker_sentinel->pid == ngx_pid) {
return worker_sentinel;
}
}
if ((worker_sentinel = ngx_slab_alloc(shpool, sizeof(ngx_http_push_stream_pid_queue_t))) == NULL) {
ngx_log_error(NGX_LOG_ERR, log, 0, "push stream module: unable to allocate worker subscriber queue marker in shared memory");
return NULL;
}
// initialize
ngx_queue_insert_tail(&channel->workers_with_subscribers, &worker_sentinel->queue);
worker_sentinel->subscribers = 0;
worker_sentinel->pid = ngx_pid;
worker_sentinel->slot = ngx_process_slot;
ngx_queue_init(&worker_sentinel->subscriptions);
return worker_sentinel;
}
int ngx_shmap_foreach(ngx_shm_zone_t* zone, foreach_pt func, void* args)
{
ngx_queue_t *q;
ngx_shmap_node_t *sd;
ngx_shmap_ctx_t *ctx;
assert(zone != NULL);
ctx = zone->data;
int locked = ngx_shmtx_trylock(&ctx->shpool->mutex);
if (!locked){
return -1;
}
for (q = ngx_queue_head(&ctx->sh->queue);
q != ngx_queue_sentinel(&ctx->sh->queue);
q = ngx_queue_next(q))
{
sd = ngx_queue_data(q, ngx_shmap_node_t, queue);
func(sd, args);
}
ngx_shmtx_unlock(&ctx->shpool->mutex);
return 0;
}
int ngx_shmap_flush_all(ngx_shm_zone_t* zone)
{
ngx_queue_t *q;
ngx_shmap_node_t *sd;
ngx_shmap_ctx_t *ctx;
assert(zone != NULL);
ctx = zone->data;
ngx_shmtx_lock(&ctx->shpool->mutex);
for (q = ngx_queue_head(&ctx->sh->queue);
q != ngx_queue_sentinel(&ctx->sh->queue);
q = ngx_queue_next(q))
{
sd = ngx_queue_data(q, ngx_shmap_node_t, queue);
sd->expires = 1;
}
ngx_shmap_expire(ctx, 0);
ngx_shmtx_unlock(&ctx->shpool->mutex);
return 0;
}
void uv__udp_finish_close(uv_udp_t* handle) {
uv_udp_send_t* req;
ngx_queue_t* q;
assert(!ev_is_active(&handle->write_watcher));
assert(!ev_is_active(&handle->read_watcher));
assert(handle->fd == -1);
uv__udp_run_completed(handle);
while (!ngx_queue_empty(&handle->write_queue)) {
q = ngx_queue_head(&handle->write_queue);
ngx_queue_remove(q);
req = ngx_queue_data(q, uv_udp_send_t, queue);
if (req->send_cb) {
/* FIXME proper error code like UV_EABORTED */
uv__set_artificial_error(handle->loop, UV_EINTR);
req->send_cb(req, -1);
}
}
/* Now tear down the handle. */
handle->flags = 0;
handle->recv_cb = NULL;
handle->alloc_cb = NULL;
/* but _do not_ touch close_cb */
}
ngx_int_t
ngx_http_drizzle_keepalive_get_peer_single(ngx_peer_connection_t *pc,
ngx_http_upstream_drizzle_peer_data_t *dp,
ngx_http_upstream_drizzle_srv_conf_t *dscf)
{
ngx_http_drizzle_keepalive_cache_t *item;
ngx_queue_t *q;
ngx_connection_t *c;
if (! ngx_queue_empty(&dscf->cache)) {
q = ngx_queue_head(&dscf->cache);
ngx_queue_remove(q);
item = ngx_queue_data(q, ngx_http_drizzle_keepalive_cache_t, queue);
c = item->connection;
ngx_queue_insert_head(&dscf->free, q);
c->idle = 0;
c->log = pc->log;
c->read->log = pc->log;
c->write->log = pc->log;
pc->connection = c;
pc->cached = 1;
dp->name = &item->name;
dp->drizzle_con = item->drizzle_con;
return NGX_DONE;
}
return NGX_DECLINED;
}
void uv__udp_finish_close(uv_udp_t* handle) {
uv_udp_send_t* req;
ngx_queue_t* q;
assert(!uv__io_active(&handle->io_watcher, UV__POLLIN | UV__POLLOUT));
assert(handle->io_watcher.fd == -1);
uv__udp_run_completed(handle);
while (!ngx_queue_empty(&handle->write_queue)) {
q = ngx_queue_head(&handle->write_queue);
ngx_queue_remove(q);
req = ngx_queue_data(q, uv_udp_send_t, queue);
uv__req_unregister(handle->loop, req);
if (req->bufs != req->bufsml)
free(req->bufs);
req->bufs = NULL;
if (req->send_cb) {
uv__set_artificial_error(handle->loop, UV_ECANCELED);
req->send_cb(req, -1);
}
}
/* Now tear down the handle. */
handle->flags = 0;
handle->recv_cb = NULL;
handle->alloc_cb = NULL;
/* but _do not_ touch close_cb */
}
void uv__cf_loop_cb(void* arg) {
uv_loop_t* loop;
ngx_queue_t* item;
ngx_queue_t split_head;
uv__cf_loop_signal_t* s;
loop = arg;
uv_mutex_lock(&loop->cf_mutex);
ngx_queue_init(&split_head);
if (!ngx_queue_empty(&loop->cf_signals)) {
ngx_queue_t* split_pos = ngx_queue_next(&loop->cf_signals);
ngx_queue_split(&loop->cf_signals, split_pos, &split_head);
}
uv_mutex_unlock(&loop->cf_mutex);
while (!ngx_queue_empty(&split_head)) {
item = ngx_queue_head(&split_head);
s = ngx_queue_data(item, uv__cf_loop_signal_t, member);
s->cb(s->arg);
ngx_queue_remove(item);
free(s);
}
}
// cmp 指向函数的指针
// 队列排序采用的是稳定的简单插入排序方法，即从第一个节点开始遍历，依次将节点(q)插入前面已经排序好的队列(链表)中
// prev 为已经排序好的queue
void
ngx_queue_sort(ngx_queue_t *queue,
ngx_int_t (*cmp)(const ngx_queue_t *, const ngx_queue_t *))
{
ngx_queue_t *q, *prev, *next;
q = ngx_queue_head(queue);
// 若只有一个元素，则无须排序
if (q == ngx_queue_last(queue)) {
return;
}
for (q = ngx_queue_next(q); q != ngx_queue_sentinel(queue); q = next) {
prev = ngx_queue_prev(q);
// 也充当了循环条件
next = ngx_queue_next(q);
ngx_queue_remove(q);
do {
// 指针函数调用
if (cmp(prev, q) <= 0) {
break;
}
prev = ngx_queue_prev(prev);
} while (prev != ngx_queue_sentinel(queue));
ngx_queue_insert_after(prev, q);
}
}
void EIO_AfterWrite(uv_work_t* req) {
QueuedWrite* queuedWrite = static_cast<QueuedWrite*>(req->data);
WriteBaton* data = static_cast<WriteBaton*>(queuedWrite->baton);
v8::Handle<v8::Value> argv[2];
if(data->errorString[0]) {
argv[0] = v8::Exception::Error(v8::String::New(data->errorString));
argv[1] = v8::Undefined();
} else {
argv[0] = v8::Undefined();
argv[1] = v8::Int32::New(data->result);
}
v8::Function::Cast(*data->callback)->Call(v8::Context::GetCurrent()->Global(), 2, argv);
uv_mutex_lock(&write_queue_mutex);
ngx_queue_remove(&queuedWrite->queue);
if (!ngx_queue_empty(&write_queue)) {
// Always pull the next work item from the head of the queue
ngx_queue_t* head = ngx_queue_head(&write_queue);
QueuedWrite* nextQueuedWrite = ngx_queue_data(head, QueuedWrite, queue);
uv_queue_work(uv_default_loop(), &nextQueuedWrite->req, EIO_Write, EIO_AfterWrite);
}
uv_mutex_unlock(&write_queue_mutex);
data->buffer.Dispose();
data->callback.Dispose();
delete data;
delete queuedWrite;
}
static void uv__write_callbacks(uv_stream_t* stream) {
uv_write_t* req;
ngx_queue_t* q;
while (!ngx_queue_empty(&stream->write_completed_queue)) {
/* Pop a req off write_completed_queue. */
q = ngx_queue_head(&stream->write_completed_queue);
req = ngx_queue_data(q, uv_write_t, queue);
ngx_queue_remove(q);
uv__req_unregister(stream->loop, req);
/* NOTE: call callback AFTER freeing the request data. */
if (req->cb) {
uv__set_sys_error(stream->loop, req->error);
req->cb(req, req->error ? -1 : 0);
}
}
assert(ngx_queue_empty(&stream->write_completed_queue));
/* Write queue drained. */
if (!uv_write_queue_head(stream)) {
uv__drain(stream);
}
}
static void uv__write_callbacks(uv_stream_t* stream) {
int callbacks_made = 0;
ngx_queue_t* q;
uv_write_t* req;
while (!ngx_queue_empty(&stream->write_completed_queue)) {
/* Pop a req off write_completed_queue. */
q = ngx_queue_head(&stream->write_completed_queue);
assert(q);
req = ngx_queue_data(q, struct uv_write_s, queue);
ngx_queue_remove(q);
/* NOTE: call callback AFTER freeing the request data. */
if (req->cb) {
uv__set_artificial_error(stream->loop, req->error);
req->cb(req, req->error ? -1 : 0);
}
callbacks_made++;
}
assert(ngx_queue_empty(&stream->write_completed_queue));
/* Write queue drained. */
if (!uv_write_queue_head(stream)) {
uv__drain(stream);
}
}
/* Note: must be called with the mutex locked */
static ngx_buffer_cache_entry_t*
ngx_buffer_cache_get_free_entry(ngx_buffer_cache_sh_t *cache)
{
ngx_buffer_cache_entry_t* entry;
if (!ngx_queue_empty(&cache->free_queue))
{
// return the free queue head
return container_of(ngx_queue_head(&cache->free_queue), ngx_buffer_cache_entry_t, queue_node);
}
if ((u_char*)(cache->entries_end + 1) < cache->buffers_start)
{
// enlarge the entries buffer
entry = cache->entries_end;
cache->entries_end++;
// initialize the state and add to free queue
entry->state = CES_FREE;
ngx_queue_insert_tail(&cache->free_queue, &entry->queue_node);
return entry;
}
return ngx_buffer_cache_free_oldest_entry(cache, 0);
}
static void _listen_cb(uv_stream_t* server, int status) {
TRACE("got client connection...\n");
luv_object_t* self = container_of(server, luv_object_t, h);
if (luvL_object_is_waiting(self)) {
ngx_queue_t* q = ngx_queue_head(&self->rouse);
luv_state_t* s = ngx_queue_data(q, luv_state_t, cond);
lua_State* L = s->L;
TRACE("is waiting..., lua_State*: %p\n", L);
luaL_checktype(L, 2, LUA_TUSERDATA);
luv_object_t* conn = (luv_object_t*)lua_touserdata(L, 2);
TRACE("got client conn: %p\n", conn);
luvL_object_init(s, conn);
int rv = uv_accept(&self->h.stream, &conn->h.stream);
TRACE("accept returned ok\n");
if (rv) {
uv_err_t err = uv_last_error(self->h.stream.loop);
TRACE("ERROR: %s\n", uv_strerror(err));
lua_settop(L, 0);
lua_pushnil(L);
lua_pushstring(L, uv_strerror(err));
}
self->flags &= ~LUV_OWAITING;
luvL_cond_signal(&self->rouse);
}
else {
TRACE("increment backlog count\n");
self->count++;
}
}
int
ngx_tcp_lua_ffi_shdict_flush_all(ngx_shm_zone_t *zone)
{
ngx_queue_t *q;
ngx_tcp_lua_shdict_node_t *sd;
ngx_tcp_lua_shdict_ctx_t *ctx;
ctx = zone->data;
ngx_shmtx_lock(&ctx->shpool->mutex);
for (q = ngx_queue_head(&ctx->sh->queue);
q != ngx_queue_sentinel(&ctx->sh->queue);
q = ngx_queue_next(q))
{
sd = ngx_queue_data(q, ngx_tcp_lua_shdict_node_t, queue);
sd->expires = 1;
}
ngx_tcp_lua_shdict_expire(ctx, 0);
ngx_shmtx_unlock(&ctx->shpool->mutex);
return NGX_OK;
}
int main(int argc, char const *argv[])
{
ngx_queue_t queueContainer;
ngx_queue_init(&queueContainer);
int i = 0;
my_queue node[5];
for(;i < 5;++i){
node[i].num = i;
}
ngx_queue_insert_tail(&queueContainer,&node[0].que);
ngx_queue_insert_head(&queueContainer,&node[1].que);
ngx_queue_insert_tail(&queueContainer,&node[2].que);
ngx_queue_insert_after(&queueContainer,&node[3].que);
ngx_queue_insert_tail(&queueContainer,&node[4].que);
ngx_queue_sort(&queueContainer,compTestNode);
ngx_queue_t *q;
for(q = ngx_queue_head(&queueContainer);q != ngx_queue_sentinel(&queueContainer)
;q = ngx_queue_next(q)){
my_queue* eleNode = ngx_queue_data(q,my_queue,que);
printf("%d\n",eleNode -> num );
}
return 0;
}
