static void receive_channel_auth_check(ngx_int_t sender, channel_authcheck_data_t *d) {
memstore_channel_head_t *head;
DBG("received channel_auth_check request for channel %V privdata %p", d->shm_chid, d->privdata);
assert(memstore_slot() == memstore_channel_owner(d->shm_chid));
if(!d->cf->redis.enabled) {
head = nchan_memstore_find_chanhead(d->shm_chid);
if(head == NULL) {
d->auth_ok = !d->channel_must_exist;
}
else if (d->max_subscribers == 0) {
d->auth_ok = 1;
}
else {
assert(head->shared);
d->auth_ok = head->shared->sub_count < (ngx_uint_t )d->max_subscribers;
}
ipc_cmd(channel_auth_check_reply, sender, d);
}
else {
channel_authcheck_data_callback_t *dd = ngx_alloc(sizeof(*dd), ngx_cycle->log);
dd->d = *d;
dd->sender = sender;
nchan_store_redis.find_channel(d->shm_chid, d->cf, redis_receive_channel_auth_check_callback, dd);
}
}
static void receive_subscriber_keepalive(ngx_int_t sender, sub_keepalive_data_t *d) {
memstore_channel_head_t *head;
DBG("received SUBSCRIBER KEEPALIVE from %i for channel %V", sender, d->shm_chid);
head = nchan_memstore_find_chanhead(d->shm_chid);
if(head == NULL) {
DBG("not subscribed anymore");
d->renew = 0;
}
else {
assert(head == d->originator);
assert(head->status == READY || head->status == STUBBED);
assert(head->foreign_owner_ipc_sub == d->ipc_sub);
if(head->total_sub_count == 0) {
if(ngx_time() - head->last_subscribed_local > MEMSTORE_IPC_SUBSCRIBER_TIMEOUT) {
d->renew = 0;
DBG("No subscribers lately. Time... to die.");
}
else {
DBG("No subscribers, but there was one %i sec ago. don't unsubscribe.", ngx_time() - head->last_subscribed_local);
d->renew = 1;
}
}
else {
d->renew = 1;
}
}
ipc_cmd(subscriber_keepalive_reply, sender, d);
}
static void receive_unsubscribed(ngx_int_t sender, unsubscribed_data_t *d) {
DBG("received unsubscribed request for channel %V privdata %p", d->shm_chid, d->privdata);
if(memstore_channel_owner(d->shm_chid) != memstore_slot()) {
memstore_channel_head_t *head;
//find channel
head = nchan_memstore_find_chanhead(d->shm_chid);
if(head == NULL) {
//already deleted maybe?
DBG("already unsubscribed...");
return;
}
//gc if no subscribers
if(head->total_sub_count == 0) {
DBG("add %p to GC", head);
head->foreign_owner_ipc_sub = NULL;
chanhead_gc_add(head, "received UNSUBSCRIVED over ipc, sub_count == 0");
}
else {
//subscribe again?...
DBG("maybe subscribe again?...");
}
}
else {
ERR("makes no sense...");
}
str_shm_free(d->shm_chid);
}
static void receive_get_channel_info(ngx_int_t sender, channel_info_data_t *d) {
memstore_channel_head_t *head;
DBG("received get_channel_info request for channel %V privdata %p", d->shm_chid, d->privdata);
if(d->cf->redis.enabled && d->cf->redis.storage_mode == REDIS_MODE_BACKUP) {
channel_info_find_chanhead_backup_data_t *dd = ngx_alloc(sizeof(*dd), ngx_cycle->log);
dd->d = *d;
dd->sender = sender;
nchan_memstore_find_chanhead_with_backup(d->shm_chid, d->cf, find_chanhead_w_backup_callback, dd);
}
else {
head = nchan_memstore_find_chanhead(d->shm_chid);
receive_get_channel_info_continued(sender, d, head);
}
}
static void receive_get_channel_info(ngx_int_t sender, channel_info_data_t *d) {
memstore_channel_head_t *head;
DBG("received get_channel_info request for channel %V privdata %p", d->shm_chid, d->privdata);
head = nchan_memstore_find_chanhead(d->shm_chid);
assert(memstore_slot() == memstore_channel_owner(d->shm_chid));
if(head == NULL) {
//already deleted maybe?
DBG("channel not for for get_channel_info");
d->channel_info = NULL;
}
else {
d->channel_info = head->shared;
assert(head->latest_msgid.tagcount <= 1);
d->last_msgid = head->latest_msgid;
}
ipc_alert(nchan_memstore_get_ipc(), sender, IPC_GET_CHANNEL_INFO_REPLY, d, sizeof(*d));
}
static void receive_publish_status(ngx_int_t sender, publish_status_data_t *d) {
static ngx_str_t nullstring = ngx_null_string;
memstore_channel_head_t *chead;
if((chead = nchan_memstore_find_chanhead(d->shm_chid)) == NULL) {
if(ngx_exiting || ngx_quit) {
ERR("can't find chanhead for id %V, but it's okay.", d->shm_chid);
}
else {
ERR("Can't find chanhead for id %V while publishing status %i. This is not a big deal if you just reloaded Nchan.", d->shm_chid, d->status_code);
}
str_shm_free(d->shm_chid);
return;
}
DBG("IPC: received publish status for channel %V status %i %s", d->shm_chid, d->status_code, d->status_line == NULL ? &nullstring : d->status_line);
nchan_memstore_publish_generic(chead, NULL, d->status_code, d->status_line);
str_shm_free(d->shm_chid);
d->shm_chid=NULL;
}
static void receive_get_message(ngx_int_t sender, getmessage_data_t *d) {
memstore_channel_head_t *head;
store_message_t *msg = NULL;
assert(d->shm_chid->len>1);
assert(d->shm_chid->data!=NULL);
DBG("IPC: received get_message request for channel %V privdata %p", d->shm_chid, d->privdata);
head = nchan_memstore_find_chanhead(d->shm_chid);
if(head == NULL) {
//no such thing here. reply.
d->d.resp.getmsg_code = MSG_NOTFOUND;
d->d.resp.shm_msg = NULL;
}
else {
nchan_msg_status_t status;
msg = chanhead_find_next_message(head, &d->d.req.msgid, &status);
if(msg == NULL && head->cf && head->cf->redis.enabled) {
//messages from redis are not requested explicitly, but are delivered from oldest to newest
//by the memmstore-redis subscriber.
getmessage_data_rsub_pd_t rdata = {sender, *d};
nchan_memstore_redis_subscriber_notify_on_MSG_EXPECTED(head->redis_sub, &d->d.req.msgid, ipc_handler_notify_on_MSG_EXPECTED_callback, sizeof(rdata), &rdata);
return;
}
d->d.resp.getmsg_code = status;
d->d.resp.shm_msg = msg == NULL ? NULL : msg->msg;
}
if(d->d.resp.shm_msg) {
assert(msg_reserve(d->d.resp.shm_msg, "get_message_reply") == NGX_OK);
}
DBG("IPC: send get_message_reply for channel %V msg %p, privdata: %p", d->shm_chid, msg, d->privdata);
ipc_cmd(get_message_reply, sender, d);
}
