refactor the loop on queues

include/ngx_http_push_stream_module.h

@@ -40,7 +40,7 @@ typedef struct {
 
 // template queue
 typedef struct {
-    ngx_queue_t                     queue; // this MUST be first
+    ngx_queue_t                     queue;
     ngx_str_t                      *template;
     ngx_uint_t                      index;
     ngx_flag_t                      eventsource;
@@ -64,7 +64,7 @@ typedef struct {
     ngx_uint_t                      max_subscribers_per_channel;
     ngx_uint_t                      max_messages_stored_per_channel;
     ngx_uint_t                      max_channel_id_length;
-    ngx_http_push_stream_template_queue_t  msg_templates;
+    ngx_queue_t                     msg_templates;
     ngx_flag_t                      timeout_with_body;
     ngx_regex_t                    *backtrack_parser_regex;
     ngx_http_push_stream_msg_t     *ping_msg;
@@ -94,7 +94,7 @@ typedef struct {
     ngx_http_complex_value_t       *last_event_id;
     ngx_http_complex_value_t       *user_agent;
     ngx_str_t                       padding_by_user_agent;
-    ngx_http_push_stream_padding_t *paddings;
+    ngx_queue_t                    *paddings;
     ngx_http_complex_value_t       *allowed_origins;
 } ngx_http_push_stream_loc_conf_t;
 
@@ -104,7 +104,7 @@ static ngx_str_t    ngx_http_push_stream_global_shm_name = ngx_string("push_stre
 
 // message queue
 struct ngx_http_push_stream_msg_s {
-    ngx_queue_t                     queue; // this MUST be first
+    ngx_queue_t                     queue;
     time_t                          expires;
     time_t                          time;
     ngx_flag_t                      deleted;
@@ -126,13 +126,13 @@ typedef struct {
     ngx_queue_t                         queue;
     pid_t                               pid;
     ngx_int_t                           slot;
-    ngx_queue_t                         subscriptions_queue;
+    ngx_queue_t                         subscriptions;
     ngx_uint_t                          subscribers;
 } ngx_http_push_stream_pid_queue_t;
 
 // our typecast-friendly rbtree node (channel)
 typedef struct {
-    ngx_rbtree_node_t                   node; // this MUST be first
+    ngx_rbtree_node_t                   node;
     ngx_queue_t                         queue;
     ngx_queue_t                        *queue_sentinel;
     ngx_str_t                           id;
@@ -168,14 +168,14 @@ typedef struct {
 
 struct ngx_http_push_stream_subscriber_s {
     ngx_http_request_t                         *request;
-    ngx_http_push_stream_subscription_t         subscriptions_sentinel;
+    ngx_queue_t                                 subscriptions;
     ngx_pid_t                                   worker_subscribed_pid;
     ngx_flag_t                                  longpolling;
     ngx_queue_t                                 worker_queue;
 };
 
 typedef struct {
-    ngx_queue_t                     queue; // this MUST be first
+    ngx_queue_t                     queue;
     ngx_str_t                      *id;
     ngx_uint_t                      backtrack_messages;
 } ngx_http_push_stream_requested_channel_t;

include/ngx_http_push_stream_module_ipc.h

@@ -72,6 +72,6 @@ static ngx_inline void  ngx_http_push_stream_process_worker_message(void);
 static ngx_inline void  ngx_http_push_stream_census_worker_subscribers(void);
 static ngx_inline void  ngx_http_push_stream_cleanup_shutting_down_worker(void);
 
-static ngx_int_t    ngx_http_push_stream_respond_to_subscribers(ngx_http_push_stream_channel_t *channel, ngx_queue_t *subscriptions_sentinel, ngx_http_push_stream_msg_t *msg);
+static ngx_int_t    ngx_http_push_stream_respond_to_subscribers(ngx_http_push_stream_channel_t *channel, ngx_queue_t *subscriptions, ngx_http_push_stream_msg_t *msg);
 
 #endif /* NGX_HTTP_PUSH_STREAM_MODULE_IPC_H_ */

include/ngx_http_push_stream_module_utils.h

@@ -281,12 +281,12 @@ static ngx_inline void      ngx_http_push_stream_delete_worker_channel(void);
 
 static ngx_http_push_stream_content_subtype_t *     ngx_http_push_stream_match_channel_info_format_and_content_type(ngx_http_request_t *r, ngx_uint_t default_subtype);
 
-static ngx_http_push_stream_line_t *                ngx_http_push_stream_split_by_crlf(ngx_str_t *msg, ngx_pool_t *temp_pool);
-static ngx_str_t *                                  ngx_http_push_stream_join_with_crlf(ngx_http_push_stream_line_t *lines, ngx_pool_t *temp_pool);
+static ngx_queue_t *                                ngx_http_push_stream_split_by_crlf(ngx_str_t *msg, ngx_pool_t *temp_pool);
+static ngx_str_t *                                  ngx_http_push_stream_join_with_crlf(ngx_queue_t *lines, ngx_pool_t *temp_pool);
 
 static ngx_http_push_stream_module_ctx_t *          ngx_http_push_stream_add_request_context(ngx_http_request_t *r);
 
-static ngx_http_push_stream_padding_t *             ngx_http_push_stream_parse_paddings(ngx_conf_t *cf, ngx_str_t *paddings_by_user_agent);
+static ngx_queue_t *        ngx_http_push_stream_parse_paddings(ngx_conf_t *cf, ngx_str_t *paddings_by_user_agent);
 
 static ngx_str_t *          ngx_http_push_stream_get_formatted_current_time(ngx_pool_t *pool);
 static ngx_str_t *          ngx_http_push_stream_get_formatted_hostname(ngx_pool_t *pool);

src/ngx_http_push_stream_module.c

@@ -114,7 +114,7 @@ ngx_http_push_stream_send_response_channels_info(ngx_http_request_t *r, ngx_queu
     ngx_int_t                                 rc, content_len = 0;
     ngx_chain_t                              *chain, *first = NULL, *last = NULL;
     ngx_str_t                                *currenttime, *hostname, *text, *header_response;
-    ngx_queue_t                              *cur, *next;
+    ngx_queue_t                              *q;
     ngx_http_push_stream_main_conf_t         *mcf = ngx_http_get_module_main_conf(r, ngx_http_push_stream_module);
     ngx_http_push_stream_shm_data_t          *data = mcf->shm_data;
     ngx_http_push_stream_content_subtype_t   *subtype = ngx_http_push_stream_match_channel_info_format_and_content_type(r, 1);
@@ -124,16 +124,14 @@ ngx_http_push_stream_send_response_channels_info(ngx_http_request_t *r, ngx_queu
     const ngx_str_t *tail = subtype->format_group_tail;
 
     // format content body
-    cur = ngx_queue_head(queue_channel_info);
-    while (cur != queue_channel_info) {
-        next = ngx_queue_next(cur);
-        ngx_http_push_stream_channel_info_t *channel_info = (ngx_http_push_stream_channel_info_t *) cur;
+    for (q = ngx_queue_head(queue_channel_info); q != ngx_queue_sentinel(queue_channel_info); q = ngx_queue_next(q)) {
+        ngx_http_push_stream_channel_info_t *channel_info = ngx_queue_data(q, ngx_http_push_stream_channel_info_t, queue);
         if ((chain = ngx_http_push_stream_get_buf(r)) == NULL) {
             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "push stream module: unable to allocate memory for response channels info");
             return NGX_HTTP_INTERNAL_SERVER_ERROR;
         }
 
-        format = (next != queue_channel_info) ? subtype->format_group_item : subtype->format_group_last_item;
+        format = (q != ngx_queue_last(queue_channel_info)) ? subtype->format_group_item : subtype->format_group_last_item;
         if ((text = ngx_http_push_stream_channel_info_formatted(r->pool, format, &channel_info->id, channel_info->published_messages, channel_info->stored_messages, channel_info->subscribers)) == NULL) {
             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "push stream module: unable to allocate memory to format channel info");
             return NGX_HTTP_INTERNAL_SERVER_ERROR;
@@ -157,7 +155,6 @@ ngx_http_push_stream_send_response_channels_info(ngx_http_request_t *r, ngx_queu
         }
 
         last = chain;
-        cur = next;
     }
 
     // get formatted current time
@@ -204,14 +201,14 @@ ngx_http_push_stream_send_response_all_channels_info_detailed(ngx_http_request_t
     ngx_queue_t                               queue_channel_info;
     ngx_http_push_stream_shm_data_t          *data = mcf->shm_data;
     ngx_slab_pool_t                          *shpool = mcf->shpool;
-    ngx_queue_t                              *cur = &data->channels_queue;
+    ngx_queue_t                              *q;
     ngx_http_push_stream_channel_t           *channel;
 
     ngx_queue_init(&queue_channel_info);
 
     ngx_shmtx_lock(&shpool->mutex);
-    while ((cur = ngx_queue_next(cur)) && (cur != NULL) && (cur != &data->channels_queue)) {
-        channel = ngx_queue_data(cur, ngx_http_push_stream_channel_t, queue);
+    for (q = ngx_queue_head(&data->channels_queue); q != ngx_queue_sentinel(&data->channels_queue); q = ngx_queue_next(q)) {
+        channel = ngx_queue_data(q, ngx_http_push_stream_channel_t, queue);
 
         ngx_http_push_stream_channel_info_t *channel_info;
 
@@ -244,14 +241,14 @@ ngx_http_push_stream_send_response_channels_info_detailed(ngx_http_request_t *r,
     ngx_http_push_stream_channel_info_t      *channel_info;
     ngx_http_push_stream_channel_t           *channel = NULL;
     ngx_http_push_stream_requested_channel_t *requested_channel;
-    ngx_queue_t                              *cur = &requested_channels->queue;
+    ngx_queue_t                              *q;
     ngx_uint_t                                qtd_channels = 0;
 
     ngx_queue_init(&queue_channel_info);
 
     ngx_shmtx_lock(&shpool->mutex);
-    while ((cur = ngx_queue_next(cur)) != &requested_channels->queue) {
-        requested_channel = ngx_queue_data(cur, ngx_http_push_stream_requested_channel_t, queue);
+    for (q = ngx_queue_head(&requested_channels->queue); q != ngx_queue_sentinel(&requested_channels->queue); q = ngx_queue_next(q)) {
+        requested_channel = ngx_queue_data(q, ngx_http_push_stream_requested_channel_t, queue);
 
         // search for a existing channel with this id
         channel = ngx_http_push_stream_find_channel(requested_channel->id, r->connection->log, mcf);
@@ -289,11 +286,12 @@ ngx_http_push_stream_send_response_channels_info_detailed(ngx_http_request_t *r,
 static ngx_int_t
 ngx_http_push_stream_find_or_add_template(ngx_conf_t *cf,  ngx_str_t template, ngx_flag_t eventsource, ngx_flag_t websocket) {
     ngx_http_push_stream_main_conf_t      *mcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_push_stream_module);
-    ngx_http_push_stream_template_queue_t *sentinel = &mcf->msg_templates;
-    ngx_http_push_stream_template_queue_t *cur = sentinel;
+    ngx_queue_t                           *q;
+    ngx_http_push_stream_template_queue_t *cur;
     ngx_str_t                             *aux = NULL;
 
-    while ((cur = (ngx_http_push_stream_template_queue_t *) ngx_queue_next(&cur->queue)) != sentinel) {
+    for (q = ngx_queue_head(&mcf->msg_templates); q != ngx_queue_sentinel(&mcf->msg_templates); q = ngx_queue_next(q)) {
+        cur = ngx_queue_data(q, ngx_http_push_stream_template_queue_t, queue);
         if ((ngx_memn2cmp(cur->template->data, template.data, cur->template->len, template.len) == 0) &&
             (cur->eventsource == eventsource) && (cur->websocket == websocket)) {
             return cur->index;
@@ -313,6 +311,6 @@ ngx_http_push_stream_find_or_add_template(ngx_conf_t *cf,  ngx_str_t template, n
     cur->websocket = websocket;
     cur->index = mcf->qtd_templates;
     ngx_memcpy(cur->template->data, template.data, template.len);
-    ngx_queue_insert_tail(&mcf->msg_templates.queue, &cur->queue);
+    ngx_queue_insert_tail(&mcf->msg_templates, &cur->queue);
     return cur->index;
 }

src/ngx_http_push_stream_module_setup.c

@@ -452,7 +452,7 @@ ngx_http_push_stream_create_main_conf(ngx_conf_t *cf)
     mcf->timeout_with_body = NGX_CONF_UNSET;
     mcf->ping_msg = NULL;
     mcf->longpooling_timeout_msg = NULL;
-    ngx_queue_init(&mcf->msg_templates.queue);
+    ngx_queue_init(&mcf->msg_templates);
 
     return mcf;
 }
@@ -756,8 +756,9 @@ ngx_http_push_stream_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
                 return NGX_CONF_ERROR;
             }
 
-            ngx_http_push_stream_padding_t *padding = conf->paddings;
-            while ((padding = (ngx_http_push_stream_padding_t *) ngx_queue_next(&padding->queue)) != conf->paddings) {
+            ngx_queue_t *q;
+            for (q = ngx_queue_head(conf->paddings); q != ngx_queue_sentinel(conf->paddings); q = ngx_queue_next(q)) {
+                ngx_http_push_stream_padding_t *padding = ngx_queue_data(q, ngx_http_push_stream_padding_t, queue);
                 ngx_http_push_stream_padding_max_len = ngx_max(ngx_http_push_stream_padding_max_len, padding->header_min_len);
                 ngx_http_push_stream_padding_max_len = ngx_max(ngx_http_push_stream_padding_max_len, padding->message_min_len);
             }
@@ -887,10 +888,10 @@ ngx_http_push_stream_set_shm_size_slot(ngx_conf_t *cf, ngx_command_t *cmd, void
     name = (cf->args->nelts > 2) ? &value[2] : &ngx_http_push_stream_shm_name;
     if ((ngx_http_push_stream_global_shm_zone != NULL) && (ngx_http_push_stream_global_shm_zone->data != NULL)) {
         ngx_http_push_stream_global_shm_data_t *global_data = (ngx_http_push_stream_global_shm_data_t *) ngx_http_push_stream_global_shm_zone->data;
-        ngx_queue_t                            *cur = &global_data->shm_datas_queue;
+        ngx_queue_t                            *q;
 
-        while ((cur = ngx_queue_next(cur)) != &global_data->shm_datas_queue) {
-            ngx_http_push_stream_shm_data_t *data = ngx_queue_data(cur, ngx_http_push_stream_shm_data_t, shm_data_queue);
+        for (q = ngx_queue_head(&global_data->shm_datas_queue); q != ngx_queue_sentinel(&global_data->shm_datas_queue); q = ngx_queue_next(q)) {
+            ngx_http_push_stream_shm_data_t *data = ngx_queue_data(q, ngx_http_push_stream_shm_data_t, shm_data_queue);
             if ((name->len == data->shm_zone->shm.name.len) &&
                 (ngx_strncmp(name->data, data->shm_zone->shm.name.data, name->len) == 0) &&
                 (data->shm_zone->shm.size != shm_size)) {

src/ngx_http_push_stream_module_websocket.c

@@ -40,7 +40,8 @@ ngx_http_push_stream_websocket_handler(ngx_http_request_t *r)
     ngx_http_push_stream_loc_conf_t                *cf = ngx_http_get_module_loc_conf(r, ngx_http_push_stream_module);
     ngx_slab_pool_t                                *shpool = mcf->shpool;
     ngx_http_push_stream_subscriber_t              *worker_subscriber;
-    ngx_http_push_stream_requested_channel_t       *channels_ids, *cur;
+    ngx_http_push_stream_requested_channel_t       *requested_channels, *requested_channel;
+    ngx_queue_t                                    *q;
     ngx_http_push_stream_module_ctx_t              *ctx;
     ngx_int_t                                       tag;
     time_t                                          if_modified_since;
@@ -105,14 +106,14 @@ ngx_http_push_stream_websocket_handler(ngx_http_request_t *r)
     ngx_http_push_stream_send_only_added_headers(r);
 
     //get channels ids and backtracks from path
-    channels_ids = ngx_http_push_stream_parse_channels_ids_from_path(r, ctx->temp_pool);
-    if ((channels_ids == NULL) || ngx_queue_empty(&channels_ids->queue)) {
+    requested_channels = ngx_http_push_stream_parse_channels_ids_from_path(r, ctx->temp_pool);
+    if ((requested_channels == NULL) || ngx_queue_empty(&requested_channels->queue)) {
         ngx_log_error(NGX_LOG_WARN, r->connection->log, 0, "push stream module: the push_stream_channels_path is required but is not set");
         return ngx_http_push_stream_send_only_header_response(r, NGX_HTTP_BAD_REQUEST, &NGX_HTTP_PUSH_STREAM_NO_CHANNEL_ID_MESSAGE);
     }
 
     //validate channels: name, length and quantity. check if channel exists when authorized_channels_only is on. check if channel is full of subscribers
-    if (ngx_http_push_stream_validate_channels(r, channels_ids, &status_code, &explain_error_message) == NGX_ERROR) {
+    if (ngx_http_push_stream_validate_channels(r, requested_channels, &status_code, &explain_error_message) == NGX_ERROR) {
         return ngx_http_push_stream_send_websocket_close_frame(r, status_code, explain_error_message);
     }
 
@@ -139,9 +140,9 @@ ngx_http_push_stream_websocket_handler(ngx_http_request_t *r)
     }
 
     // adding subscriber to channel(s) and send backtrack messages
-    cur = channels_ids;
-    while ((cur = (ngx_http_push_stream_requested_channel_t *) ngx_queue_next(&cur->queue)) != channels_ids) {
-        if (ngx_http_push_stream_subscriber_assign_channel(mcf, cf, r, cur, if_modified_since, tag, last_event_id, worker_subscriber, ctx->temp_pool) != NGX_OK) {
+    for (q = ngx_queue_head(&requested_channels->queue); q != ngx_queue_sentinel(&requested_channels->queue); q = ngx_queue_next(q)) {
+        requested_channel = ngx_queue_data(q, ngx_http_push_stream_requested_channel_t, queue);
+        if (ngx_http_push_stream_subscriber_assign_channel(mcf, cf, r, requested_channel, if_modified_since, tag, last_event_id, worker_subscriber, ctx->temp_pool) != NGX_OK) {
             return ngx_http_push_stream_send_websocket_close_frame(r, NGX_HTTP_INTERNAL_SERVER_ERROR, &NGX_HTTP_PUSH_STREAM_EMPTY);
         }
     }
@@ -191,8 +192,8 @@ ngx_http_push_stream_websocket_reading(ngx_http_request_t *r)
     ngx_event_t                       *rev;
     ngx_connection_t                  *c;
     uint64_t                           i;
-    ngx_queue_t                       *cur = NULL;
     ngx_buf_t                          buf;
+    ngx_queue_t                       *q;
 
     ngx_http_push_stream_set_buffer(&buf, ctx->frame->header, ctx->frame->last, 8);
 
@@ -289,9 +290,8 @@ ngx_http_push_stream_websocket_reading(ngx_http_request_t *r)
                             }
                         }
 
-                        cur = &ctx->subscriber->subscriptions_sentinel.queue;
-                        while ((cur = ngx_queue_next(cur)) != &ctx->subscriber->subscriptions_sentinel.queue) {
-                            ngx_http_push_stream_subscription_t *subscription = ngx_queue_data(cur, ngx_http_push_stream_subscription_t, queue);
+                        for (q = ngx_queue_head(&ctx->subscriber->subscriptions); q != ngx_queue_sentinel(&ctx->subscriber->subscriptions); q = ngx_queue_next(q)) {
+                            ngx_http_push_stream_subscription_t *subscription = ngx_queue_data(q, ngx_http_push_stream_subscription_t, queue);
                             if (ngx_http_push_stream_add_msg_to_channel(r, &subscription->channel->id, ctx->frame->payload, ctx->frame->payload_len, NULL, NULL, ctx->temp_pool) == NULL) {
                                 ngx_http_finalize_request(r, NGX_OK);
                                 return;

src/ngx_http_push_stream_rbtree_util.c

@@ -72,28 +72,6 @@ ngx_http_push_stream_find_channel_on_tree(ngx_str_t *id, ngx_log_t *log, ngx_rbt
     return NULL;
 }
 
-static void
-ngx_http_push_stream_initialize_channel(ngx_http_push_stream_main_conf_t *mcf, ngx_http_push_stream_channel_t *channel)
-{
-    ngx_http_push_stream_shm_data_t    *data = mcf->shm_data;
-
-    channel->channel_deleted_message = NULL;
-    channel->last_message_id = 0;
-    channel->last_message_time = 0;
-    channel->last_message_tag = 0;
-    channel->stored_messages = 0;
-    channel->subscribers = 0;
-    channel->deleted = 0;
-    channel->expires = ngx_time() + mcf->channel_inactivity_time;
-
-    ngx_queue_init(&channel->message_queue);
-
-    channel->node.key = ngx_crc32_short(channel->id.data, channel->id.len);
-    ngx_rbtree_insert(&data->tree, &channel->node);
-    ngx_queue_insert_tail(&data->channels_queue, &channel->queue);
-    channel->queue_sentinel = &data->channels_queue;
-    (channel->wildcard) ? data->wildcard_channels++ : data->channels++;
-}
 
 static ngx_http_push_stream_channel_t *
 ngx_http_push_stream_find_channel(ngx_str_t *id, ngx_log_t *log, ngx_http_push_stream_main_conf_t *mcf)
@@ -164,12 +142,24 @@ ngx_http_push_stream_get_channel(ngx_str_t *id, ngx_log_t *log, ngx_http_push_st
     channel->id.data[channel->id.len] = '\0';
 
     channel->wildcard = is_wildcard_channel;
+    channel->channel_deleted_message = NULL;
+    channel->last_message_id = 0;
+    channel->last_message_time = 0;
+    channel->last_message_tag = 0;
+    channel->stored_messages = 0;
+    channel->subscribers = 0;
+    channel->deleted = 0;
+    channel->expires = ngx_time() + mcf->channel_inactivity_time;
 
-    ngx_http_push_stream_initialize_channel(mcf, channel);
-
-    // initialize workers_with_subscribers queues only when a channel is created
+    ngx_queue_init(&channel->message_queue);
     ngx_queue_init(&channel->workers_with_subscribers);
 
+    channel->node.key = ngx_crc32_short(channel->id.data, channel->id.len);
+    ngx_rbtree_insert(&data->tree, &channel->node);
+    ngx_queue_insert_tail(&data->channels_queue, &channel->queue);
+    channel->queue_sentinel = &data->channels_queue;
+    (channel->wildcard) ? data->wildcard_channels++ : data->channels++;
+
     ngx_shmtx_unlock(&shpool->mutex);
     return channel;
 }