remove global references to main module conf, ping and long polling timeout...

remove global references to main module conf, ping and long polling timeout messages, and shared memory zones

include/ngx_http_push_stream_module.h

@@ -47,9 +47,12 @@ typedef struct {
     ngx_flag_t                      websocket;
 } ngx_http_push_stream_template_queue_t;
 
+typedef struct ngx_http_push_stream_msg_s ngx_http_push_stream_msg_t;
+typedef struct ngx_http_push_stream_shm_data_s ngx_http_push_stream_shm_data_t;
+typedef struct ngx_http_push_stream_global_shm_data_s ngx_http_push_stream_global_shm_data_t;
+
 typedef struct {
     ngx_flag_t                      enabled;
-    size_t                          shm_size;
     ngx_str_t                       channel_deleted_message_text;
     time_t                          channel_inactivity_time;
     ngx_str_t                       ping_message_text;
@@ -64,6 +67,11 @@ typedef struct {
     ngx_http_push_stream_template_queue_t  msg_templates;
     ngx_flag_t                      timeout_with_body;
     ngx_regex_t                    *backtrack_parser_regex;
+    ngx_http_push_stream_msg_t     *ping_msg;
+    ngx_http_push_stream_msg_t     *longpooling_timeout_msg;
+    ngx_shm_zone_t                 *shm_zone;
+    ngx_slab_pool_t                *shpool;
+    ngx_http_push_stream_shm_data_t*shm_data;
 } ngx_http_push_stream_main_conf_t;
 
 typedef struct {
@@ -92,9 +100,10 @@ typedef struct {
 
 // shared memory segment name
 static ngx_str_t    ngx_http_push_stream_shm_name = ngx_string("push_stream_module");
+static ngx_str_t    ngx_http_push_stream_global_shm_name = ngx_string("push_stream_module_global");
 
 // message queue
-typedef struct {
+struct ngx_http_push_stream_msg_s {
     ngx_queue_t                     queue; // this MUST be first
     time_t                          expires;
     time_t                          time;
@@ -108,7 +117,8 @@ typedef struct {
     ngx_str_t                      *event_type_message;
     ngx_str_t                      *formatted_messages;
     ngx_int_t                       workers_ref_count;
-} ngx_http_push_stream_msg_t;
+    ngx_uint_t                      qtd_templates;
+};
 
 typedef struct ngx_http_push_stream_subscriber_s ngx_http_push_stream_subscriber_t;
 
@@ -132,7 +142,6 @@ typedef struct {
     ngx_uint_t                          subscribers;
     ngx_queue_t                         workers_with_subscribers;
     ngx_queue_t                         message_queue;
-    time_t                              last_activity_time;
     time_t                              expires;
     ngx_flag_t                          deleted;
     ngx_flag_t                          wildcard;
@@ -189,6 +198,7 @@ typedef struct {
     ngx_pid_t                           pid;
     ngx_http_push_stream_channel_t     *channel; // ->shared memory
     ngx_queue_t                        *subscriptions_sentinel; // ->a worker's local pool
+    ngx_http_push_stream_main_conf_t   *mcf;
 } ngx_http_push_stream_worker_msg_t;
 
 typedef struct {
@@ -200,7 +210,13 @@ typedef struct {
 } ngx_http_push_stream_worker_data_t;
 
 // shared memory
-typedef struct {
+struct ngx_http_push_stream_global_shm_data_s {
+    ngx_http_push_stream_worker_data_t      ipc[NGX_MAX_PROCESSES]; // interprocess stuff
+    time_t                                  startup;
+    ngx_queue_t                             shm_datas_queue;
+};
+
+struct ngx_http_push_stream_shm_data_s {
     ngx_rbtree_t                            tree;
     ngx_uint_t                              channels;           // # of channels being used
     ngx_uint_t                              wildcard_channels;  // # of wildcard channels being used
@@ -217,12 +233,13 @@ typedef struct {
     time_t                                  startup;
     time_t                                  last_message_time;
     ngx_int_t                               last_message_tag;
-} ngx_http_push_stream_shm_data_t;
-
-ngx_uint_t          ngx_http_push_stream_shm_size;
-ngx_shm_zone_t     *ngx_http_push_stream_shm_zone = NULL;
+    ngx_queue_t                             shm_data_queue;
+    ngx_http_push_stream_main_conf_t       *mcf;
+    ngx_shm_zone_t                         *shm_zone;
+    ngx_slab_pool_t                        *shpool;
+};
 
-ngx_http_push_stream_main_conf_t *ngx_http_push_stream_module_main_conf = NULL;
+ngx_shm_zone_t     *ngx_http_push_stream_global_shm_zone = NULL;
 
 ngx_str_t         **ngx_http_push_stream_module_paddings_chunks = NULL;
 
@@ -336,7 +353,7 @@ static const ngx_str_t  NGX_HTTP_PUSH_STREAM_ALLOWED_HEADERS = ngx_string("If-Mo
 
 #define NGX_HTTP_PUSH_STREAM_CHECK_AND_FINALIZE_REQUEST_ON_ERROR(val, fail, r, errormessage) \
     if (val == fail) {                                                       \
-        ngx_log_error(NGX_LOG_ERR, (r)->connection->log, 0, errormessage);   \
+        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, errormessage);     \
         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);        \
         return;                                                              \
     }
@@ -344,7 +361,7 @@ static const ngx_str_t  NGX_HTTP_PUSH_STREAM_ALLOWED_HEADERS = ngx_string("If-Mo
 #define NGX_HTTP_PUSH_STREAM_CHECK_AND_FINALIZE_REQUEST_ON_ERROR_LOCKED(val, fail, r, errormessage) \
     if (val == fail) {                                                       \
         ngx_shmtx_unlock(&(shpool)->mutex);                                  \
-        ngx_log_error(NGX_LOG_ERR, (r)->connection->log, 0, errormessage);   \
+        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, errormessage);     \
         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);        \
         return;                                                              \
     }

include/ngx_http_push_stream_module_ipc.h

@@ -50,7 +50,7 @@ ngx_socket_t    ngx_http_push_stream_socketpairs[NGX_MAX_PROCESSES][2];
 
 static ngx_int_t    ngx_http_push_stream_register_worker_message_handler(ngx_cycle_t *cycle);
 
-static void    ngx_http_push_stream_wildcard(ngx_http_push_stream_channel_t *channel, ngx_http_push_stream_msg_t *msg, ngx_log_t *log);
+static void    ngx_http_push_stream_broadcast(ngx_http_push_stream_channel_t *channel, ngx_http_push_stream_msg_t *msg, ngx_log_t *log, ngx_http_push_stream_main_conf_t *mcf);
 
 static ngx_int_t        ngx_http_push_stream_alert_worker(ngx_pid_t pid, ngx_int_t slot, ngx_log_t *log, ngx_channel_t command);
 #define ngx_http_push_stream_alert_worker_check_messages(pid, slot, log) ngx_http_push_stream_alert_worker(pid, slot, log, NGX_CMD_HTTP_PUSH_STREAM_CHECK_MESSAGES)
@@ -58,12 +58,12 @@ static ngx_int_t        ngx_http_push_stream_alert_worker(ngx_pid_t pid, ngx_int
 #define ngx_http_push_stream_alert_worker_delete_channel(pid, slot, log) ngx_http_push_stream_alert_worker(pid, slot, log, NGX_CMD_HTTP_PUSH_STREAM_DELETE_CHANNEL)
 #define ngx_http_push_stream_alert_worker_shutting_down_cleanup(pid, slot, log) ngx_http_push_stream_alert_worker(pid, slot, log, NGX_CMD_HTTP_PUSH_STREAM_CLEANUP_SHUTTING_DOWN)
 
-static ngx_int_t        ngx_http_push_stream_send_worker_message_locked(ngx_http_push_stream_channel_t *channel, ngx_queue_t *subscriptions_sentinel, ngx_pid_t pid, ngx_int_t worker_slot, ngx_http_push_stream_msg_t *msg, ngx_flag_t *queue_was_empty, ngx_log_t *log);
+static ngx_int_t        ngx_http_push_stream_send_worker_message_locked(ngx_http_push_stream_channel_t *channel, ngx_queue_t *subscriptions_sentinel, ngx_pid_t pid, ngx_int_t worker_slot, ngx_http_push_stream_msg_t *msg, ngx_flag_t *queue_was_empty, ngx_log_t *log, ngx_http_push_stream_main_conf_t *mcf);
 
 static ngx_int_t        ngx_http_push_stream_init_ipc(ngx_cycle_t *cycle, ngx_int_t workers);
 static void             ngx_http_push_stream_ipc_exit_worker(ngx_cycle_t *cycle);
 static ngx_int_t        ngx_http_push_stream_ipc_init_worker();
-static void             ngx_http_push_stream_clean_worker_data();
+static void             ngx_http_push_stream_clean_worker_data(ngx_http_push_stream_shm_data_t *data);
 static void             ngx_http_push_stream_channel_handler(ngx_event_t *ev);
 static void             ngx_http_push_stream_alert_shutting_down_workers(void);
 

include/ngx_http_push_stream_module_setup.h

@@ -34,7 +34,6 @@
 #include <ngx_http_push_stream_module_subscriber.h>
 #include <ngx_http_push_stream_module_websocket.h>
 
-#define NGX_HTTP_PUSH_STREAM_DEFAULT_SHM_SIZE                               33554432 // 32 megs
 #define NGX_HTTP_PUSH_STREAM_MESSAGE_BUFFER_CLEANUP_INTERVAL                5000     // 5 seconds
 static time_t NGX_HTTP_PUSH_STREAM_DEFAULT_SHM_MEMORY_CLEANUP_OBJECTS_TTL = 10;      // 10 seconds
 static time_t NGX_HTTP_PUSH_STREAM_DEFAULT_SHM_MEMORY_CLEANUP_INTERVAL    = 4000;    // 4 seconds
@@ -65,6 +64,7 @@ static ngx_int_t    ngx_http_push_stream_init_module(ngx_cycle_t *cycle);
 static ngx_int_t    ngx_http_push_stream_init_worker(ngx_cycle_t *cycle);
 static void         ngx_http_push_stream_exit_worker(ngx_cycle_t *cycle);
 static void         ngx_http_push_stream_exit_master(ngx_cycle_t *cycle);
+static ngx_int_t    ngx_http_push_stream_preconfig(ngx_conf_t *cf);
 static ngx_int_t    ngx_http_push_stream_postconfig(ngx_conf_t *cf);
 static void *       ngx_http_push_stream_create_main_conf(ngx_conf_t *cf);
 static char *       ngx_http_push_stream_init_main_conf(ngx_conf_t *cf, void *parent);
@@ -72,7 +72,9 @@ static void *       ngx_http_push_stream_create_loc_conf(ngx_conf_t *cf);
 static char *       ngx_http_push_stream_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child);
 
 // shared memory
-static ngx_int_t    ngx_http_push_stream_set_up_shm(ngx_conf_t *cf, size_t shm_size);
-static ngx_int_t    ngx_http_push_stream_init_shm_zone(ngx_shm_zone_t *shm_zone, void *data);
+char *              ngx_http_push_stream_set_shm_size_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
+ngx_int_t           ngx_http_push_stream_init_shm_zone(ngx_shm_zone_t *shm_zone, void *data);
+ngx_int_t           ngx_http_push_stream_init_global_shm_zone(ngx_shm_zone_t *shm_zone, void *data);
+
 
 #endif /* NGX_HTTP_PUSH_STREAM_MODULE_SETUP_H_ */

include/ngx_http_push_stream_module_utils.h

@@ -225,11 +225,8 @@ static const ngx_str_t  NGX_HTTP_PUSH_STREAM_PADDING_BY_USER_AGENT_PATTERN = ngx
 ngx_event_t         ngx_http_push_stream_memory_cleanup_event;
 ngx_event_t         ngx_http_push_stream_buffer_cleanup_event;
 
-ngx_http_push_stream_msg_t *ngx_http_push_stream_ping_msg = NULL;
-ngx_http_push_stream_msg_t *ngx_http_push_stream_longpooling_timeout_msg = NULL;
-
 // general request handling
-ngx_http_push_stream_msg_t *ngx_http_push_stream_convert_char_to_msg_on_shared_locked(u_char *data, size_t len, ngx_http_push_stream_channel_t *channel, ngx_int_t id, ngx_str_t *event_id, ngx_str_t *event_type, ngx_pool_t *temp_pool);
+ngx_http_push_stream_msg_t *ngx_http_push_stream_convert_char_to_msg_on_shared_locked(ngx_http_push_stream_main_conf_t *mcf, u_char *data, size_t len, ngx_http_push_stream_channel_t *channel, ngx_int_t id, ngx_str_t *event_id, ngx_str_t *event_type, ngx_pool_t *temp_pool);
 static ngx_int_t            ngx_http_push_stream_send_only_added_headers(ngx_http_request_t *r);
 static void                 ngx_http_push_stream_add_polling_headers(ngx_http_request_t *r, time_t last_modified_time, ngx_int_t tag, ngx_pool_t *temp_pool);
 static void                 ngx_http_push_stream_get_last_received_message_values(ngx_http_request_t *r, time_t *if_modified_since, ngx_int_t *tag, ngx_str_t **last_event_id);
@@ -249,7 +246,6 @@ static void                 ngx_http_push_stream_send_response_finalize(ngx_http
 static void                 ngx_http_push_stream_send_response_finalize_for_longpolling_by_timeout(ngx_http_request_t *r);
 static ngx_int_t            ngx_http_push_stream_send_websocket_close_frame(ngx_http_request_t *r, ngx_uint_t http_status, const ngx_str_t *reason);
 static ngx_int_t            ngx_http_push_stream_memory_cleanup();
-static ngx_int_t            ngx_http_push_stream_buffer_cleanup();
 
 ngx_chain_t *               ngx_http_push_stream_get_buf(ngx_http_request_t *r);
 static void                 ngx_http_push_stream_unescape_uri(ngx_str_t *value);
@@ -272,14 +268,14 @@ static void                 ngx_http_push_stream_timer_reset(ngx_msec_t timer_in
 static void                 ngx_http_push_stream_worker_subscriber_cleanup_locked(ngx_http_push_stream_subscriber_t *worker_subscriber);
 static ngx_str_t *          ngx_http_push_stream_create_str(ngx_pool_t *pool, uint len);
 
-static void                 ngx_http_push_stream_mark_message_to_delete_locked(ngx_http_push_stream_msg_t *msg);
-static ngx_flag_t           ngx_http_push_stream_delete_channel(ngx_str_t *id, u_char *text, size_t len, ngx_pool_t *temp_pool);
-static void                 ngx_http_push_stream_collect_expired_messages(ngx_http_push_stream_shm_data_t *data, ngx_slab_pool_t *shpool, ngx_flag_t force);
-static void                 ngx_http_push_stream_collect_expired_messages_and_empty_channels(ngx_http_push_stream_shm_data_t *data, ngx_slab_pool_t *shpool, ngx_flag_t force);
+static void                 ngx_http_push_stream_mark_message_to_delete_locked(ngx_http_push_stream_msg_t *msg, ngx_http_push_stream_shm_data_t *data);
+static ngx_flag_t           ngx_http_push_stream_delete_channel(ngx_http_push_stream_main_conf_t *mcf, ngx_str_t *id, u_char *text, size_t len, ngx_pool_t *temp_pool);
+static void                 ngx_http_push_stream_collect_expired_messages_data(ngx_http_push_stream_shm_data_t *data, ngx_flag_t force);
+static void                 ngx_http_push_stream_collect_expired_messages_and_empty_channels(ngx_flag_t force);
 static void                 ngx_http_push_stream_free_message_memory_locked(ngx_slab_pool_t *shpool, ngx_http_push_stream_msg_t *msg);
 static void                 ngx_http_push_stream_free_worker_message_memory_locked(ngx_slab_pool_t *shpool, ngx_http_push_stream_worker_msg_t *worker_msg);
 static ngx_int_t            ngx_http_push_stream_free_memory_of_expired_messages_and_channels(ngx_flag_t force);
-static ngx_inline void      ngx_http_push_stream_ensure_qtd_of_messages_locked(ngx_http_push_stream_channel_t *channel, ngx_uint_t max_messages, ngx_flag_t expired);
+static ngx_inline void      ngx_http_push_stream_ensure_qtd_of_messages_locked(ngx_http_push_stream_shm_data_t *data, ngx_http_push_stream_channel_t *channel, ngx_uint_t max_messages, ngx_flag_t expired);
 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);

include/ngx_http_push_stream_rbtree_util.h

@@ -34,8 +34,8 @@
 #ifndef NGX_HTTP_PUSH_STREAM_RBTREE_UTIL_H_
 #define NGX_HTTP_PUSH_STREAM_RBTREE_UTIL_H_
 
-static ngx_http_push_stream_channel_t *     ngx_http_push_stream_get_channel(ngx_str_t *id, ngx_log_t *log, ngx_http_push_stream_loc_conf_t *cf);
-static ngx_http_push_stream_channel_t *     ngx_http_push_stream_find_channel(ngx_str_t *id, ngx_log_t *log);
+static ngx_http_push_stream_channel_t *     ngx_http_push_stream_get_channel(ngx_str_t *id, ngx_log_t *log, ngx_http_push_stream_loc_conf_t *cf, ngx_http_push_stream_main_conf_t *mcf);
+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);
 
 static void         ngx_rbtree_generic_insert(ngx_rbtree_node_t *temp, ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel, int (*compare) (const ngx_rbtree_node_t *left, const ngx_rbtree_node_t *right));
 static void         ngx_http_push_stream_rbtree_insert(ngx_rbtree_node_t *temp, ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel);

misc/spec/mix/cleanup_memory_spec.rb

@@ -437,13 +437,13 @@ describe "Cleanup Memory" do
   def create_and_delete_channel(channel, body, headers, &block)
     pub_1 = EventMachine::HttpRequest.new(nginx_address + '/pub?id=' + channel.to_s).post :body => body, :head => headers
     pub_1.callback do
-      if pub_1.response_header.status == 200
-        pub = EventMachine::HttpRequest.new(nginx_address + '/pub?id=' + channel.to_s).delete :head => headers
-        pub.callback do
+      pub = EventMachine::HttpRequest.new(nginx_address + '/pub?id=' + channel.to_s).delete :head => headers
+      pub.callback do
+        if pub_1.response_header.status == 200
           block.call((pub.response_header.status == 200) ? :success : :error)
+        else
+          block.call(:error)
         end
-      else
-        block.call(:error)
       end
     end
   end

misc/spec/mix/measure_memory_spec.rb

@@ -16,8 +16,8 @@ describe "Measure Memory" do
 
   message_estimate_size = 168
   channel_estimate_size = 270
-  subscriber_estimate_size = 160
-  subscriber_estimate_system_size = 7000
+  subscriber_estimate_size = 154
+  subscriber_estimate_system_size = 6528
 
   it "should check message size" do
     channel = 'ch_test_message_size'

misc/spec/mix/setup_parameters_spec.rb

@@ -101,4 +101,17 @@ describe "Setup Parameters" do
     nginx_test_configuration({:padding_by_user_agent => "user_agent;10;0"}).should include("padding pattern not match the value user_agent;10;0")
     nginx_test_configuration({:padding_by_user_agent => "user_agent,10,0:other_user_agent;20;0:another_user_agent,30,0"}).should include("error applying padding pattern to other_user_agent;20;0:another_user_agent,30,0")
   end
+
+  it "should not accept an invalid shared memory size" do
+    nginx_test_configuration({:shared_memory_size => nil}).should include("push_stream_shared_memory_size must be set.")
+  end
+
+  it "should not accept a small shared memory size" do
+    nginx_test_configuration({:shared_memory_size => "100k"}).should include("The push_stream_shared_memory_size value must be at least")
+  end
+
+  it "should not accept an invalid channels path value" do
+    nginx_test_configuration({:channels_path => nil}).should include("push stream module: push_stream_channels_path must be set.")
+    nginx_test_configuration({:channels_path_for_pub => nil}).should include("push stream module: push_stream_channels_path must be set.")
+  end
 end

misc/spec/nginx_configuration.rb

@@ -57,7 +57,8 @@ module NginxConfiguration
       :channels_path_for_pub => '$arg_id',
       :channels_path => '$1',
 
-      :extra_location => ''
+      :extra_location => '',
+      :extra_configuration => ''
     }
   end
 
@@ -184,6 +185,8 @@ http {
     <%= extra_location %>
   }
 }
+
+<%= extra_configuration %>
   )
   end
 end

misc/spec/subscriber/properties_spec.rb

@@ -811,4 +811,100 @@ describe "Subscriber Properties" do
       end
     end
   end
+
+  it "should accept a configuration with more than one http block" do
+    extra_config = {
+      :subscriber_connection_ttl => '1s',
+      :content_type => "text/html",
+      :extra_configuration => %(
+        http {
+          server {
+            listen #{nginx_port.to_i + 1};
+            location / {
+              return 200 "extra server configuration";
+            }
+          }
+        }
+      )
+    }
+
+    channel = 'ch_test_extra_http'
+    body = 'body'
+    actual_response = ''
+
+    nginx_run_server(config.merge(extra_config)) do |conf|
+      EventMachine.run do
+        sub_1 = EventMachine::HttpRequest.new(nginx_address + '/sub/' + channel.to_s).get :head => headers
+        sub_1.stream do |chunk|
+          actual_response += chunk
+        end
+        sub_1.callback do
+          sub_1.should be_http_status(200)
+
+          actual_response.should eql("HEADER\r\nTEMPLATE\r\n1234\r\n<script>p(1,'ch_test_extra_http','body');</script></body></html>")
+
+          req = EventMachine::HttpRequest.new("http://#{nginx_host}:#{nginx_port.to_i + 1}/").get
+          req.callback do
+            req.response.should eql("extra server configuration")
+            EventMachine.stop
+          end
+        end
+        publish_message_inline(channel, {}, body)
+      end
+    end
+  end
+
+  it "should accept a configuration with two shared memory zones without mix messages" do
+    extra_config = {
+      :subscriber_connection_ttl => '1s',
+      :content_type => "text/html",
+      :extra_configuration => %(
+        http {
+          push_stream_shared_memory_size         10m second;
+          push_stream_subscriber_connection_ttl         1s;
+          server {
+            listen #{nginx_port.to_i + 1};
+            location /pub {
+              push_stream_publisher;
+              push_stream_channels_path               $arg_id;
+            }
+
+            location ~ /sub/(.*) {
+              push_stream_subscriber;
+              push_stream_channels_path                   $1;
+            }
+          }
+        }
+      )
+    }
+
+    channel = 'ch_test_extra_http'
+    body = 'body'
+    actual_response_1 = ''
+    actual_response_2 = ''
+
+    nginx_run_server(config.merge(extra_config)) do |conf|
+      EventMachine.run do
+        sub_1 = EventMachine::HttpRequest.new("http://#{nginx_host}:#{nginx_port.to_i}/sub/" + channel.to_s).get
+        sub_1.stream do |chunk|
+          actual_response_1 += chunk
+        end
+        sub_2 = EventMachine::HttpRequest.new("http://#{nginx_host}:#{nginx_port.to_i + 1}/sub/" + channel.to_s).get
+        sub_2.stream do |chunk|
+          actual_response_2 += chunk
+        end
+        sub_2.callback do
+          sub_1.should be_http_status(200)
+          sub_2.should be_http_status(200)
+
+          actual_response_1.should eql("HEADER\r\nTEMPLATE\r\n1234\r\n<script>p(1,'ch_test_extra_http','body_1');</script></body></html>")
+          actual_response_2.should eql("body_2")
+          EventMachine.stop
+        end
+
+        EventMachine::HttpRequest.new("http://#{nginx_host}:#{nginx_port.to_i}/pub/?id=" + channel.to_s).post :body => "#{body}_1"
+        EventMachine::HttpRequest.new("http://#{nginx_host}:#{nginx_port.to_i + 1}/pub/?id=" + channel.to_s).post :body => "#{body}_2"
+      end
+    end
+  end
 end

src/ngx_http_push_stream_module.c

@@ -62,7 +62,8 @@ ngx_http_push_stream_send_response_all_channels_info_summarized(ngx_http_request
     ngx_str_t                                   *currenttime, *hostname, *format, *text;
     u_char                                      *subscribers_by_workers, *start;
     int                                          i, j, used_slots;
-    ngx_http_push_stream_shm_data_t             *data = (ngx_http_push_stream_shm_data_t *) ngx_http_push_stream_shm_zone->data;
+    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_worker_data_t          *worker_data;
     ngx_http_push_stream_content_subtype_t      *subtype;
 
@@ -114,7 +115,8 @@ ngx_http_push_stream_send_response_channels_info(ngx_http_request_t *r, ngx_queu
     ngx_chain_t                              *chain, *first = NULL, *last = NULL;
     ngx_str_t                                *currenttime, *hostname, *text, *header_response;
     ngx_queue_t                              *cur, *next;
-    ngx_http_push_stream_shm_data_t          *data = (ngx_http_push_stream_shm_data_t *) ngx_http_push_stream_shm_zone->data;
+    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);
 
     const ngx_str_t *format;
@@ -196,10 +198,12 @@ ngx_http_push_stream_send_response_channels_info(ngx_http_request_t *r, ngx_queu
 }
 
 static ngx_int_t
-ngx_http_push_stream_send_response_all_channels_info_detailed(ngx_http_request_t *r, ngx_str_t *prefix) {
+ngx_http_push_stream_send_response_all_channels_info_detailed(ngx_http_request_t *r, ngx_str_t *prefix)
+{
+    ngx_http_push_stream_main_conf_t         *mcf = ngx_http_get_module_main_conf(r, ngx_http_push_stream_module);
     ngx_queue_t                               queue_channel_info;
-    ngx_http_push_stream_shm_data_t          *data = (ngx_http_push_stream_shm_data_t *) ngx_http_push_stream_shm_zone->data;
-    ngx_slab_pool_t                          *shpool = (ngx_slab_pool_t *) ngx_http_push_stream_shm_zone->shm.addr;
+    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_http_push_stream_channel_t           *channel;
 
@@ -234,7 +238,8 @@ static ngx_int_t
 ngx_http_push_stream_send_response_channels_info_detailed(ngx_http_request_t *r, ngx_http_push_stream_requested_channel_t *requested_channels) {
     ngx_str_t                                *text;
     ngx_queue_t                               queue_channel_info;
-    ngx_slab_pool_t                          *shpool = (ngx_slab_pool_t *) ngx_http_push_stream_shm_zone->shm.addr;
+    ngx_http_push_stream_main_conf_t         *mcf = ngx_http_get_module_main_conf(r, ngx_http_push_stream_module);
+    ngx_slab_pool_t                          *shpool = mcf->shpool;
     ngx_http_push_stream_content_subtype_t   *subtype = ngx_http_push_stream_match_channel_info_format_and_content_type(r, 1);
     ngx_http_push_stream_channel_info_t      *channel_info;
     ngx_http_push_stream_channel_t           *channel = NULL;
@@ -249,7 +254,7 @@ ngx_http_push_stream_send_response_channels_info_detailed(ngx_http_request_t *r,
         requested_channel = ngx_queue_data(cur, 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);
+        channel = ngx_http_push_stream_find_channel(requested_channel->id, r->connection->log, mcf);
         if ((channel != NULL) && ((channel_info = ngx_pcalloc(r->pool, sizeof(ngx_http_push_stream_channel_info_t))) != NULL)) {
             channel_info->id.data = channel->id.data;
             channel_info->id.len = channel->id.len;
@@ -283,7 +288,8 @@ 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_template_queue_t *sentinel = &ngx_http_push_stream_module_main_conf->msg_templates;
+    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_str_t                             *aux = NULL;
 
@@ -294,7 +300,7 @@ ngx_http_push_stream_find_or_add_template(ngx_conf_t *cf,  ngx_str_t template, n
         }
     }
 
-    ngx_http_push_stream_module_main_conf->qtd_templates++;
+    mcf->qtd_templates++;
 
     cur = ngx_pcalloc(cf->pool, sizeof(ngx_http_push_stream_template_queue_t));
     aux = ngx_http_push_stream_create_str(cf->pool, template.len);
@@ -305,8 +311,8 @@ ngx_http_push_stream_find_or_add_template(ngx_conf_t *cf,  ngx_str_t template, n
     cur->template = aux;
     cur->eventsource = eventsource;
     cur->websocket = websocket;
-    cur->index = ngx_http_push_stream_module_main_conf->qtd_templates;
+    cur->index = mcf->qtd_templates;
     ngx_memcpy(cur->template->data, template.data, template.len);
-    ngx_queue_insert_tail(&ngx_http_push_stream_module_main_conf->msg_templates.queue, &cur->queue);
+    ngx_queue_insert_tail(&mcf->msg_templates.queue, &cur->queue);
     return cur->index;
 }

src/ngx_http_push_stream_module_publisher.c

@@ -32,6 +32,7 @@ static ngx_int_t
 ngx_http_push_stream_publisher_handler(ngx_http_request_t *r)
 {
     ngx_http_push_stream_channel_t     *channel = NULL;
+    ngx_http_push_stream_main_conf_t   *mcf = ngx_http_get_module_main_conf(r, ngx_http_push_stream_module);
     ngx_http_push_stream_loc_conf_t    *cf = ngx_http_get_module_loc_conf(r, ngx_http_push_stream_module);
     ngx_http_push_stream_module_ctx_t  *ctx;
 
@@ -82,21 +83,21 @@ ngx_http_push_stream_publisher_handler(ngx_http_request_t *r)
         }
 
         // could not have a large size
-        if ((ngx_http_push_stream_module_main_conf->max_channel_id_length != NGX_CONF_UNSET_UINT) && (cur->id->len > ngx_http_push_stream_module_main_conf->max_channel_id_length)) {
+        if ((mcf->max_channel_id_length != NGX_CONF_UNSET_UINT) && (cur->id->len > mcf->max_channel_id_length)) {
             ngx_log_error(NGX_LOG_WARN, r->connection->log, 0, "push stream module: channel id is larger than allowed %d", cur->id->len);
             return ngx_http_push_stream_send_only_header_response(r, NGX_HTTP_BAD_REQUEST, &NGX_HTTP_PUSH_STREAM_TOO_LARGE_CHANNEL_ID_MESSAGE);
         }
 
         if (r->method & (NGX_HTTP_POST|NGX_HTTP_PUT)) {
             // create the channel if doesn't exist
-            channel = ngx_http_push_stream_get_channel(cur->id, r->connection->log, cf);
+            channel = ngx_http_push_stream_get_channel(cur->id, r->connection->log, cf, mcf);
             if (channel == NULL) {
-                ngx_log_error(NGX_LOG_ERR, (r)->connection->log, 0, "push stream module: unable to allocate memory for new channel");
+                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "push stream module: unable to allocate memory for new channel");
                 return ngx_http_push_stream_send_only_header_response(r, NGX_HTTP_INTERNAL_SERVER_ERROR, NULL);
             }
 
             if (channel == NGX_HTTP_PUSH_STREAM_NUMBER_OF_CHANNELS_EXCEEDED) {
-                ngx_log_error(NGX_LOG_ERR, (r)->connection->log, 0, "push stream module: number of channels were exceeded");
+                ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "push stream module: number of channels were exceeded");
                 return ngx_http_push_stream_send_only_header_response(r, NGX_HTTP_FORBIDDEN, &NGX_HTTP_PUSH_STREAM_NUMBER_OF_CHANNELS_EXCEEDED_MESSAGE);
             }
         }
@@ -163,7 +164,7 @@ ngx_http_push_stream_read_request_body_to_buffer(ngx_http_request_t *r)
             if (chain->buf->in_file) {
                 n = ngx_read_file(chain->buf->file, buf->start, len, 0);
                 if (n == NGX_FILE_ERROR) {
-                    ngx_log_error(NGX_LOG_ERR, (r)->connection->log, 0, "push stream module: cannot read file with request body");
+                    ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "push stream module: cannot read file with request body");
                     return NULL;
                 }
                 buf->last = buf->last + len;
@@ -183,10 +184,11 @@ ngx_http_push_stream_read_request_body_to_buffer(ngx_http_request_t *r)
 static void
 ngx_http_push_stream_publisher_delete_handler(ngx_http_request_t *r)
 {
+    ngx_http_push_stream_main_conf_t       *mcf = ngx_http_get_module_main_conf(r, ngx_http_push_stream_module);
     ngx_http_push_stream_module_ctx_t      *ctx = ngx_http_get_module_ctx(r, ngx_http_push_stream_module);
     ngx_buf_t                              *buf = NULL;
-    u_char                                 *text = ngx_http_push_stream_module_main_conf->channel_deleted_message_text.data;
-    size_t                                  len = ngx_http_push_stream_module_main_conf->channel_deleted_message_text.len;
+    u_char                                 *text = mcf->channel_deleted_message_text.data;
+    size_t                                  len = mcf->channel_deleted_message_text.len;
     ngx_uint_t                              qtd_channels = 0;
 
     ngx_http_push_stream_requested_channel_t       *requested_channel;
@@ -206,7 +208,7 @@ ngx_http_push_stream_publisher_delete_handler(ngx_http_request_t *r)
 
     while ((cur = ngx_queue_next(cur)) != &ctx->requested_channels->queue) {
         requested_channel = ngx_queue_data(cur, ngx_http_push_stream_requested_channel_t, queue);
-        if (ngx_http_push_stream_delete_channel(requested_channel->id, text, len, r->pool)) {
+        if (ngx_http_push_stream_delete_channel(mcf, requested_channel->id, text, len, r->pool)) {
             qtd_channels++;
         }
     }
@@ -232,7 +234,7 @@ ngx_http_push_stream_publisher_body_handler(ngx_http_request_t *r)
 
     // check if body message wasn't empty
     if (r->headers_in.content_length_n <= 0) {
-        ngx_log_error(NGX_LOG_ERR, (r)->connection->log, 0, "push stream module: Post request was sent with no message");
+        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "push stream module: Post request was sent with no message");
         ngx_http_push_stream_send_only_header_response(r, NGX_HTTP_BAD_REQUEST, &NGX_HTTP_PUSH_STREAM_EMPTY_POST_REQUEST_MESSAGE);
         return;
     }
@@ -270,6 +272,7 @@ ngx_http_push_stream_publisher_body_handler(ngx_http_request_t *r)
 static ngx_int_t
 ngx_http_push_stream_channels_statistics_handler(ngx_http_request_t *r)
 {
+    ngx_http_push_stream_main_conf_t   *mcf = ngx_http_get_module_main_conf(r, ngx_http_push_stream_module);
     char                               *pos = NULL;
 
     ngx_http_push_stream_requested_channel_t       *channels_ids, *cur;
@@ -296,7 +299,7 @@ ngx_http_push_stream_channels_statistics_handler(ngx_http_request_t *r)
     cur = channels_ids;
     while ((cur = (ngx_http_push_stream_requested_channel_t *) ngx_queue_next(&cur->queue)) != channels_ids) {
         // could not have a large size
-        if ((ngx_http_push_stream_module_main_conf->max_channel_id_length != NGX_CONF_UNSET_UINT) && (cur->id->len > ngx_http_push_stream_module_main_conf->max_channel_id_length)) {
+        if ((mcf->max_channel_id_length != NGX_CONF_UNSET_UINT) && (cur->id->len > mcf->max_channel_id_length)) {
             ngx_log_error(NGX_LOG_WARN, r->connection->log, 0, "push stream module: channel id is larger than allowed %d", cur->id->len);
             return ngx_http_push_stream_send_only_header_response(r, NGX_HTTP_BAD_REQUEST, &NGX_HTTP_PUSH_STREAM_TOO_LARGE_CHANNEL_ID_MESSAGE);
         }

src/ngx_http_push_stream_module_websocket.c

@@ -34,8 +34,9 @@ ngx_http_push_stream_websocket_handler(ngx_http_request_t *r)
     ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "push stream module: sha1 support is needed to use WebSocket");
     return NGX_OK;
 #endif
-    ngx_slab_pool_t                                *shpool = (ngx_slab_pool_t *)ngx_http_push_stream_shm_zone->shm.addr;
+    ngx_http_push_stream_main_conf_t               *mcf = ngx_http_get_module_main_conf(r, ngx_http_push_stream_module);
     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_module_ctx_t              *ctx;
@@ -115,7 +116,7 @@ ngx_http_push_stream_websocket_handler(ngx_http_request_t *r)
 
     // sending response content header
     if (ngx_http_push_stream_send_response_content_header(r, cf) == NGX_ERROR) {
-        ngx_log_error(NGX_LOG_ERR, (r)->connection->log, 0, "push stream module: could not send content header to subscriber");
+        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "push stream module: could not send content header to subscriber");
         return ngx_http_push_stream_send_websocket_close_frame(r, NGX_HTTP_INTERNAL_SERVER_ERROR, &NGX_HTTP_PUSH_STREAM_EMPTY);
     }
 
@@ -130,7 +131,7 @@ 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(shpool, cf, r, cur, if_modified_since, tag, last_event_id, worker_subscriber, ctx->temp_pool) != NGX_OK) {
+        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) {
             return ngx_http_push_stream_send_websocket_close_frame(r, NGX_HTTP_INTERNAL_SERVER_ERROR, &NGX_HTTP_PUSH_STREAM_EMPTY);
         }
     }

src/ngx_http_push_stream_rbtree_util.c

@@ -73,9 +73,9 @@ ngx_http_push_stream_find_channel_on_tree(ngx_str_t *id, ngx_log_t *log, ngx_rbt
 }
 
 static void
-ngx_http_push_stream_initialize_channel(ngx_http_push_stream_channel_t *channel)
+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 = (ngx_http_push_stream_shm_data_t *) ngx_http_push_stream_shm_zone->data;
+    ngx_http_push_stream_shm_data_t    *data = mcf->shm_data;
 
     channel->channel_deleted_message = NULL;
     channel->last_message_id = 0;
@@ -84,8 +84,7 @@ ngx_http_push_stream_initialize_channel(ngx_http_push_stream_channel_t *channel)
     channel->stored_messages = 0;
     channel->subscribers = 0;
     channel->deleted = 0;
-    channel->expires = 0;
-    channel->last_activity_time = ngx_time();
+    channel->expires = ngx_time() + mcf->channel_inactivity_time;
 
     ngx_queue_init(&channel->message_queue);
 
@@ -97,9 +96,9 @@ ngx_http_push_stream_initialize_channel(ngx_http_push_stream_channel_t *channel)
 }
 
 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_find_channel(ngx_str_t *id, ngx_log_t *log, ngx_http_push_stream_main_conf_t *mcf)
 {
-    ngx_http_push_stream_shm_data_t    *data = (ngx_http_push_stream_shm_data_t *) ngx_http_push_stream_shm_zone->data;
+    ngx_http_push_stream_shm_data_t    *data = mcf->shm_data;
     ngx_http_push_stream_channel_t     *channel = NULL;
 
     if (id == NULL) {
@@ -118,15 +117,14 @@ ngx_http_push_stream_find_channel(ngx_str_t *id, ngx_log_t *log)
 
 // find a channel by id. if channel not found, make one, insert it, and return that.
 static ngx_http_push_stream_channel_t *
-ngx_http_push_stream_get_channel(ngx_str_t *id, ngx_log_t *log, ngx_http_push_stream_loc_conf_t *cf)
+ngx_http_push_stream_get_channel(ngx_str_t *id, ngx_log_t *log, ngx_http_push_stream_loc_conf_t *cf, ngx_http_push_stream_main_conf_t *mcf)
 {
-    ngx_http_push_stream_main_conf_t      *mcf = ngx_http_push_stream_module_main_conf;
-    ngx_http_push_stream_shm_data_t       *data = (ngx_http_push_stream_shm_data_t *) ngx_http_push_stream_shm_zone->data;
+    ngx_http_push_stream_shm_data_t       *data = mcf->shm_data;
     ngx_http_push_stream_channel_t        *channel;
-    ngx_slab_pool_t                       *shpool = (ngx_slab_pool_t *) ngx_http_push_stream_shm_zone->shm.addr;
+    ngx_slab_pool_t                       *shpool = mcf->shpool;
     ngx_flag_t                             is_wildcard_channel = 0;
 
-    channel = ngx_http_push_stream_find_channel(id, log);
+    channel = ngx_http_push_stream_find_channel(id, log, mcf);
     if (channel != NULL) { // we found our channel
         return channel;
     }
@@ -134,7 +132,7 @@ ngx_http_push_stream_get_channel(ngx_str_t *id, ngx_log_t *log, ngx_http_push_st
     ngx_shmtx_lock(&shpool->mutex);
 
     // check again to see if any other worker didn't create the channel
-    channel = ngx_http_push_stream_find_channel(id, log);
+    channel = ngx_http_push_stream_find_channel(id, log, mcf);
     if (channel != NULL) { // we found our channel
         ngx_shmtx_unlock(&shpool->mutex);
         return channel;
@@ -167,7 +165,7 @@ ngx_http_push_stream_get_channel(ngx_str_t *id, ngx_log_t *log, ngx_http_push_st
 
     channel->wildcard = is_wildcard_channel;
 
-    ngx_http_push_stream_initialize_channel(channel);
+    ngx_http_push_stream_initialize_channel(mcf, channel);
 
     // initialize workers_with_subscribers queues only when a channel is created
     ngx_queue_init(&channel->workers_with_subscribers);