APT_DECLARE(apt_consumer_task_t*) apt_consumer_task_create(
void *obj,
apt_task_msg_pool_t *msg_pool,
apr_pool_t *pool)
{
apt_task_vtable_t *vtable;
apt_consumer_task_t *consumer_task = apr_palloc(pool,sizeof(apt_consumer_task_t));
consumer_task->obj = obj;
consumer_task->msg_queue = NULL;
if(apr_queue_create(&consumer_task->msg_queue,1024,pool) != APR_SUCCESS) {
return NULL;
}
consumer_task->base = apt_task_create(consumer_task,msg_pool,pool);
if(!consumer_task->base) {
return NULL;
}
vtable = apt_task_vtable_get(consumer_task->base);
if(vtable) {
vtable->run = apt_consumer_task_run;
vtable->signal_msg = apt_consumer_task_msg_signal;
}
return consumer_task;
}
void initialize_apr(void) {
apr_status_t rv;
apr_initialize();
atexit(deinitialize_apr);
//create mem pool / thread pool /queue.
rv = apr_pool_create(&mem_pool, NULL);
check_error(rv);
rv = apr_thread_pool_create(&thrp, 1, 1, mem_pool);
check_error(rv);
rv = apr_queue_create(&queue, QUEUE_SIZE, mem_pool);
check_error(rv);
}
int
create_queue(void) {
/*apr_status_t rv;*/
if(apr_pool_initialize()) {
return 1;
}
if(apr_pool_create(&pool, NULL)) {
return 2;
}
if(apr_queue_create(&queue, QUEUE_SIZE, pool)) {
return 3;
}
return 0;
}
LLThreadSafeQueueImplementation::LLThreadSafeQueueImplementation(apr_pool_t * pool, unsigned int capacity):
mOwnsPool(pool == 0),
mPool(pool),
mQueue(0)
{
if(mOwnsPool) {
apr_status_t status = apr_pool_create(&mPool, 0);
if(status != APR_SUCCESS) throw LLThreadSafeQueueError("failed to allocate pool");
} else {
; // No op.
}
apr_status_t status = apr_queue_create(&mQueue, capacity, mPool);
if(status != APR_SUCCESS) throw LLThreadSafeQueueError("failed to allocate queue");
}
int lua_apr_thread_queue(lua_State *L)
{
apr_status_t status;
lua_apr_queue *object;
unsigned int capacity;
capacity = luaL_optlong(L, 1, 1);
luaL_argcheck(L, capacity >= 1, 1, "capacity must be >= 1");
object = new_object(L, &lua_apr_queue_type);
status = apr_pool_create(&object->pool, NULL);
if (status == APR_SUCCESS)
status = apr_queue_create(&object->handle, capacity, object->pool);
if (status != APR_SUCCESS)
return push_error_status(L, status);
return 1;
}
/* create apr queue */
F_RET teno_mq_init_queue
(
T_MSG_QUEUE *ps_queue
)
{
T_APR_RET ret = 0;
PN_RET(ps_queue, T_ERR);
/* create apr memory pool */
ret = apr_pool_create(&(ps_queue->ps_pool), NULL);
FR_RET(ret);
/* create apr queue */
ret = apr_queue_create(&(ps_queue->ps_queue),
TENO_MQ_DEFAULT_SIZE,
ps_queue->ps_pool);
FR_RET(ret);
return T_OK;
}
SWITCH_DECLARE(switch_status_t) switch_queue_create(switch_queue_t ** queue, unsigned int queue_capacity, switch_memory_pool_t *pool)
{
return apr_queue_create(queue, queue_capacity, pool);
}
apr_status_t
procmgr_post_config(server_rec * main_server, apr_pool_t * pconf)
{
apr_status_t rv;
fcgid_server_conf *sconf = ap_get_module_config(main_server->module_config,
&fcgid_module);
/* Initialize spawn controler */
spawn_control_init(main_server, pconf);
/* Create a message queues */
if ((rv = apr_queue_create(&g_msgqueue, FCGID_MSGQUEUE_SIZE,
pconf)) != APR_SUCCESS
|| (rv = apr_queue_create(&g_notifyqueue, FCGID_MSGQUEUE_SIZE,
pconf)) != APR_SUCCESS) {
/* Fatal error */
ap_log_error(APLOG_MARK, APLOG_EMERG, rv, main_server,
"mod_fcgid: can't create message queue");
exit(1);
}
/* Create request lock */
if ((rv = apr_thread_mutex_create(&g_reqlock,
APR_THREAD_MUTEX_DEFAULT,
pconf)) != APR_SUCCESS) {
/* Fatal error */
ap_log_error(APLOG_MARK, APLOG_EMERG, rv, main_server,
"mod_fcgid: Can't create request mutex");
exit(1);
}
/* Calculate procmgr_fetch_cmd wake up interval */
g_wakeup_timeout = min(sconf->error_scan_interval,
sconf->busy_scan_interval);
g_wakeup_timeout = min(sconf->idle_scan_interval,
g_wakeup_timeout);
if (g_wakeup_timeout == 0)
g_wakeup_timeout = 1; /* Make it reasonable */
/* Create process manager worker thread */
if ((rv = apr_thread_create(&g_thread, NULL, worker_thread,
main_server, pconf)) != APR_SUCCESS) {
/* It's a fatal error */
ap_log_error(APLOG_MARK, APLOG_EMERG, rv, main_server,
"mod_fcgid: can't create process manager thread");
exit(1);
}
/* Create wake up thread */
/* XXX If there was a function such like apr_queue_pop_timedwait(),
then I don't need such an ugly thread to do the wake up job */
if ((rv = apr_thread_create(&g_wakeup_thread, NULL, wakeup_thread,
NULL, pconf)) != APR_SUCCESS) {
/* It's a fatal error */
ap_log_error(APLOG_MARK, APLOG_EMERG, rv, main_server,
"mod_fcgid: can't create wake up thread");
exit(1);
}
apr_pool_cleanup_register(pconf, main_server, procmgr_stop_procmgr,
apr_pool_cleanup_null);
return APR_SUCCESS;
}
static void setup_redisclient_child_init(apr_pool_t *pchild, server_rec *s)
{
apr_status_t rv;
redisContext *ctx;
redisReply *reply;
int i;
ap_log_perror(APLOG_MARK, APLOG_ERR, 0, pchild, "redis client initializaion.(apache child. PID:[%d])", getpid());
/*********************/
secuip_svr_config *svr_config = (secuip_svr_config *)ap_get_module_config(s->module_config, &secuip_module);
//TODO: per virtualServer(maybe next version)
//secuip_svr_config *svr_config = (secuip_svr_config *)ap_get_module_config(s->next->module_config, &secuip_module);
/*********************/
rv = apr_pool_create(&svr_config->pool, pchild);
if (rv != APR_SUCCESS) {
ap_log_perror(APLOG_MARK, APLOG_CRIT, rv, pchild, "Failed to create subpool for secuip");
return;
}
#if APR_HAS_THREADS
rv = apr_thread_mutex_create(&svr_config->mutex, APR_THREAD_MUTEX_DEFAULT, svr_config->pool);
if (rv != APR_SUCCESS) {
ap_log_perror(APLOG_MARK, APLOG_CRIT, rv, svr_config->pool,"[0]Failed to create mutex for sucuip");
return;
}
#endif
// rv = apr_queue_create(&svr_config->redis_context_queue, svr_config->redis_init_count, svr_config->pool);
rv = apr_queue_create(&redis_context_queue, svr_config->redis_init_count, svr_config->pool);
if (rv != APR_SUCCESS) {
ap_log_perror(APLOG_MARK, APLOG_CRIT, rv, svr_config->pool,"[1]Failed to create queue for secuip");
return;
}
// not using redis connection pool
if (svr_config->redis_queue_enabled != 1) {
ap_log_perror(APLOG_MARK, APLOG_ERR, 0, pchild, "svr_config->redis_queue_enabled value[%d].(apache child. PID:[%d], init count[%d])", svr_config->redis_queue_enabled, getpid(), svr_config->redis_init_count);
return;
}
for (i = 0; i < svr_config->redis_init_count; i++) {
ap_log_error(APLOG_MARK, APLOG_ERR, 0, s,"init redis for secuip:[%d], PID:[%d]", i, getpid());
ctx = init_redisclient(s, svr_config->redis_ip, svr_config->redis_port, svr_config->redis_password);
if ( ctx == NULL) {
ap_log_error(APLOG_MARK, APLOG_CRIT, 0, s, "init redisclient error.");
return;
}
// reg. cleanup
//apr_pool_cleanup_register(svr_config->pool, ctx, redisFree, apr_pool_cleanup_null) ;
// add ctx to queue.
rv = apr_queue_trypush(redis_context_queue, ctx);
if (rv != APR_SUCCESS) {
// queue full
//free
free_redis_ctx(ctx, s);
if (rv == APR_EAGAIN) {
//redisCommand(ctx, "GET trypush_queue_full(%X)", ctx);
ap_log_error(APLOG_MARK, APLOG_ERR, 0, s, "redis connection pool is full.(if this occures, there is a error of queue management.");
}
//redisCommand(ctx, "GET trypush_error(%X)", ctx);
ap_log_perror(APLOG_MARK, APLOG_ERR, rv, svr_config->pool, "[2]Failed to push queue for secuip.");
return;
}
// log (current queue size)
//redisCommand(ctx, "GET trypush_success(%X)(pid%d)(size%d)", ctx, getpid(), apr_queue_size(redis_context_queue));
//ap_log_error(APLOG_MARK, APLOG_ERR, 0, s, "redis context pushed[%d].", apr_queue_size(redis_context_queue));
}
//redisFree(ctx); // not necessary in here.
return;
}
int main(int argc, const char* const argv[])
{
apr_thread_t **t;
apr_queue_t *queue;
int i;
apr_status_t rv;
apr_getopt_t *opt;
const char *optarg;
char c;
int numconsumers=3;
int numproducers=4;
int queuesize=100;
int sleeptime=30;
char errorbuf[200];
apr_initialize();
srand((unsigned int)apr_time_now());
printf("APR Queue Test\n======================\n\n");
printf("%-60s", "Initializing the context");
if (apr_pool_create(&context, NULL) != APR_SUCCESS) {
fflush(stdout);
fprintf(stderr, "Failed.\nCould not initialize\n");
exit(-1);
}
printf("OK\n");
apr_getopt_init(&opt, context, argc, argv);
while ((rv = apr_getopt(opt, "p:c:P:C:q:s:v", &c, &optarg))
== APR_SUCCESS) {
switch (c) {
case 'c':
numconsumers = atoi( optarg);
break;
case 'p':
numproducers = atoi( optarg);
break;
case 'C':
consumer_activity = atoi( optarg);
break;
case 'P':
producer_activity = atoi( optarg);
break;
case 's':
sleeptime= atoi(optarg);
break;
case 'q':
queuesize = atoi(optarg);
break;
case 'v':
verbose= 1;
break;
default:
usage();
exit(-1);
}
}
/* bad cmdline option? then we die */
if (rv != APR_EOF || opt->ind < opt->argc) {
usage();
exit(-1);
}
printf("test stats %d consumers (rate %d/sec) %d producers (rate %d/sec) queue size %d sleep %d\n",
numconsumers,consumer_activity, numproducers, producer_activity, queuesize,sleeptime);
printf("%-60s", "Initializing the queue");
rv = apr_queue_create(&queue, queuesize, context);
if (rv != APR_SUCCESS) {
fflush(stdout);
fprintf(stderr, "Failed\nCould not create queue %d\n",rv);
apr_strerror(rv, errorbuf,200);
fprintf(stderr,"%s\n",errorbuf);
exit(-1);
}
printf("OK\n");
t = apr_palloc( context, sizeof(apr_thread_t*) * (numconsumers+numproducers));
printf("%-60s", "Starting consumers");
for (i=0;i<numconsumers;i++) {
rv = apr_thread_create(&t[i], NULL, consumer, queue, context);
if (rv != APR_SUCCESS) {
apr_strerror(rv, errorbuf,200);
fprintf(stderr, "Failed\nError starting consumer thread (%d) rv=%d:%s\n",i, rv,errorbuf);
exit(-1);
}
}
for (i=numconsumers;i<(numconsumers+numproducers);i++) {
rv = apr_thread_create(&t[i], NULL, producer, queue, context);
if (rv != APR_SUCCESS) {
apr_strerror(rv, errorbuf,200);
fprintf(stderr, "Failed\nError starting producer thread (%d) rv=%d:%s\n",i, rv,errorbuf);
exit(-1);
}
}
printf("OK\n");
printf("%-60s", "Sleeping\n");
apr_sleep( sleeptime * 1000000 ); /* sleep 10 seconds */
printf("OK\n");
printf("%-60s", "Terminating queue");
rv = apr_queue_term(queue);
if (rv != APR_SUCCESS) {
apr_strerror(rv, errorbuf,200);
fprintf( stderr, "apr_queue_term failed %d:%s\n",rv,errorbuf);
}
printf("OK\n");
printf("%-60s", "Waiting for threads to exit\n");
fflush(stdout);
for (i=0;i<numconsumers+numproducers;i++) {
apr_thread_join(&rv, t[i]);
if (rv != 0 ) {
apr_strerror(rv, errorbuf,200);
if (i<numconsumers)
fprintf( stderr, "consumer thread %d failed rv %d:%s\n",i,rv,errorbuf);
else
fprintf( stderr, "producer thread %d failed rv %d:%s\n",i,rv,errorbuf);
}
}
printf("OK\n");
apr_terminate();
return 0;
}