apr_status_t procmgr_stop_procmgr(void *server)
{
apr_status_t status;
fcgid_server_conf *conf;
/* Tell the world to die */
g_must_exit = 1;
if (g_msgqueue)
apr_queue_push(g_msgqueue, NULL);
/* Wait */
if (g_thread && apr_thread_join(&status, g_thread) == APR_SUCCESS) {
/* Free the memory left in queue */
fcgid_command *peakcmd = NULL;
while (apr_queue_trypop(g_msgqueue, (void **)&peakcmd) == APR_SUCCESS) {
if (peakcmd)
free(peakcmd);
}
}
/* Clean up the Job object if present */
conf = ap_get_module_config(((server_rec*)server)->module_config,
&fcgid_module);
if (conf->hJobObjectForAutoCleanup != NULL) {
CloseHandle(conf->hJobObjectForAutoCleanup);
}
if (g_wakeup_thread)
return apr_thread_join(&status, g_wakeup_thread);
return APR_SUCCESS;
}
/* push teno message to the queue. */
F_RET teno_mq_push_queue
(
T_MSG_QUEUE *ps_queue,
T_VOID *p_data
)
{
return apr_queue_push(ps_queue->ps_queue, p_data);
}
apr_status_t procmgr_send_spawn_cmd(fcgid_command * command,
request_rec * r)
{
if (g_thread && g_msgqueue && !g_must_exit
&& g_reqlock && g_notifyqueue) {
apr_status_t rv;
/*
Prepare the message send to another thread
destroy the message if I can't push to message
*/
fcgid_command *postcmd =
(fcgid_command *) malloc(sizeof(fcgid_command));
if (!postcmd)
return APR_ENOMEM;
memcpy(postcmd, command, sizeof(*command));
/* Get request lock first */
if ((rv = apr_thread_mutex_lock(g_reqlock)) != APR_SUCCESS) {
ap_log_rerror(APLOG_MARK, APLOG_EMERG, rv, r,
"mod_fcgid: can't get request lock");
return rv;
}
/* Try push the message */
if ((rv = apr_queue_push(g_msgqueue, postcmd)) != APR_SUCCESS) {
apr_thread_mutex_unlock(g_reqlock);
free(postcmd);
ap_log_rerror(APLOG_MARK, APLOG_EMERG, rv, r,
"mod_fcgid: can't push request message");
return rv;
} else {
/* Wait the respond from process manager */
char *notifybyte = NULL;
if ((rv =
apr_queue_pop(g_notifyqueue,
(void **)¬ifybyte)) != APR_SUCCESS) {
apr_thread_mutex_unlock(g_reqlock);
ap_log_rerror(APLOG_MARK, APLOG_EMERG, rv, r,
"mod_fcgid: can't pop notify message");
return rv;
}
}
/* Release the lock now */
if ((rv = apr_thread_mutex_unlock(g_reqlock)) != APR_SUCCESS) {
/* It's a fatal error */
ap_log_rerror(APLOG_MARK, APLOG_EMERG, rv, r,
"mod_fcgid: can't release request lock");
exit(1);
}
}
return APR_SUCCESS;
}
SWITCH_DECLARE(switch_status_t) switch_queue_push(switch_queue_t *queue, void *data)
{
apr_status_t s;
do {
s = apr_queue_push(queue, data);
} while (s == APR_EINTR);
return s;
}
apr_status_t procmgr_finish_notify(server_rec * main_server)
{
apr_status_t rv;
char *notify = NULL;
if ((rv = apr_queue_push(g_notifyqueue, notify)) != APR_SUCCESS) {
ap_log_error(APLOG_MARK, APLOG_EMERG, rv, main_server,
"mod_fcgid: can't send spawn notify");
}
return rv;
}
void LLThreadSafeQueueImplementation::pushFront(void * element)
{
apr_status_t status = apr_queue_push(mQueue, element);
if(status == APR_EINTR) {
throw LLThreadSafeQueueInterrupt();
} else if(status != APR_SUCCESS) {
throw LLThreadSafeQueueError("push failed");
} else {
; // Success.
}
}
int push_queue(struct seed_cmd cmd) {
#ifdef USE_FORK
struct msg_cmd mcmd;
mcmd.mtype = 1;
mcmd.cmd = cmd;
if (msgsnd(msqid, &mcmd, sizeof(struct seed_cmd), 0) == -1) {
printf("failed to push tile %d %d %d\n",cmd.z,cmd.y,cmd.x);
return APR_EGENERAL;
}
return APR_SUCCESS;
#else
struct seed_cmd *pcmd = calloc(1,sizeof(struct seed_cmd));
*pcmd = cmd;
return apr_queue_push(work_queue,pcmd);
#endif
}
static void * APR_THREAD_FUNC producer(apr_thread_t *thd, void *data)
{
int i=0;
long sleeprate;
apr_queue_t *q = (apr_queue_t*)data;
apr_status_t rv;
int *val;
char current_thread_str[30];
apr_os_thread_t current_thread = apr_os_thread_current();
apr_snprintf(current_thread_str, sizeof current_thread_str,
"%pT", ¤t_thread);
sleeprate = 1000000/producer_activity;
apr_sleep( (rand() % 4 ) * 1000000 ); /* sleep random seconds */
while(1) {
val = apr_palloc(context, sizeof(int));
*val=i;
if (verbose)
fprintf(stderr, "%s\tpush %d\n", current_thread_str, *val);
do {
rv = apr_queue_push(q, val);
if (rv == APR_EINTR)
fprintf(stderr, "%s\tproducer intr\n", current_thread_str);
} while (rv == APR_EINTR);
if (rv != APR_SUCCESS) {
if (rv == APR_EOF) {
fprintf(stderr, "%s\tproducer: queue terminated APR_EOF\n", current_thread_str);
rv = APR_SUCCESS;
}
else
fprintf(stderr, "%s\tproducer thread exit rv %d\n", current_thread_str, rv);
apr_thread_exit(thd, rv);
return NULL;
}
i++;
apr_sleep( sleeprate ); /* sleep this long to acheive our rate */
}
/* not reached */
return NULL;
}
static apt_bool_t apt_consumer_task_msg_signal(apt_task_t *task, apt_task_msg_t *msg)
{
apt_consumer_task_t *consumer_task = apt_task_object_get(task);
return (apr_queue_push(consumer_task->msg_queue,msg) == APR_SUCCESS) ? TRUE : FALSE;
}
