static int child_init(int rank)
{
struct cachedb_url *it;
cachedb_con *con;
if(rank == PROC_MAIN || rank == PROC_TCP_MAIN) {
return 0;
}
for (it = redis_script_urls; it; it=it->next) {
LM_DBG("iterating through conns - [%.*s]\n",it->url.len,it->url.s);
con = redis_init(&it->url);
if (con == NULL) {
LM_ERR("failed to open connection\n");
return -1;
}
if (cachedb_put_connection(&cache_mod_name,con) < 0) {
LM_ERR("failed to insert connection\n");
return -1;
}
}
cachedb_free_url(redis_script_urls);
return 0;
}
int main(int argc, char **argv)
{
setting = &_setting;
sigset_t signal_mask;
sigemptyset(&signal_mask);
sigaddset(&signal_mask, SIGPIPE);
pthread_sigmask(SIG_BLOCK, &signal_mask, NULL);
signal(SIGINT, clean_up);
signal(SIGQUIT, clean_up);
signal(SIGTERM, clean_up);
parse_options(argc, argv);
if (setting->daemon_mode) {
daemonize();
}
redis_init(setting->redis_addr, setting->redis_port);
event_init();
config_init();
g_httpd = evhttp_start(setting->listen_host, setting->listen_port);
evhttp_set_gencb(g_httpd, request_handler, NULL);
event_dispatch();
return 0;
}
int rediscsvmodule_init(struct state_conf *conf, UNUSED char **fields, UNUSED int fieldlens)
{
buffer = xcalloc(BUFFER_SIZE, sizeof(char*));
buffer_fill = 0;
if (conf->output_args) {
redisconf_t *rconf = redis_parse_connstr(conf->output_args);
if (rconf->type == T_TCP) {
log_info("redis-module", "{type: TCP, server: %s, "
"port: %u, list: %s}", rconf->server,
rconf->port, rconf->list_name);
} else {
log_info("redis-module", "{type: LOCAL, path: %s, "
"list: %s}", rconf->path, rconf->list_name);
}
queue_name = rconf->list_name;
} else {
queue_name = strdup("zmap");
}
// generate field names CSV list to be logged.
char *fieldstring = xcalloc(1000, fieldlens);
memset(fieldstring, 0, sizeof(fields));
for (int i=0; i < fieldlens; i++) {
if (i) {
strcat(fieldstring, ", ");
}
strcat(fieldstring, fields[i]);
}
log_info("redis-csv", "the following fields will be output to redis: %s.",
fieldstring);
free(fields);
return redis_init(conf->output_args);
}
bool init_system() {
if (logger::init_logger("./config/log.conf") == false) {
printf("[init]初始化日志系统失败");
return false;
}
DEBUG_LOG("[init]%s", "初始化日志系统成功");
if (redis_init() == false) {
printf("[init]初始化Redis失败");
return false;
}
DEBUG_LOG("[init]%s", "初始化Redis成功");
return true;
}
bool init_database(int port){
#ifdef VOLDEMORT_FOUND
if(DATABASE==VOLDEMORT) {
return voldemort_init();
}
#endif
#ifdef REDIS_FOUND
if(DATABASE==REDIS){
return redis_init(port);
}
#endif
#ifdef BDB_FOUND
if(DATABASE==BDB) {
return bdb_init();
}
#endif
}
int main(int argc, char* argv[])
{
const char* path = argv[argc - 1];
size_t len = sizeof(uint64_t);
handle = redis_init("4", false);
on_exit((void (*) (int, void *)) redis_shutdown, handle);
fd_disk = open(path, O_RDONLY);
argc -= 1;
if (redis_hash_field_get(handle, REDIS_SUPERBLOCK_SECTOR_GET, 1,
"block_size", (uint8_t*) &block_size, &len))
return -ENOENT;
if (len != 8)
return EXIT_FAILURE;
if (qemu_get_pt_offset(handle, &partition_offset, (uint64_t) 1))
return EXIT_FAILURE;
return fuse_main(argc, argv, &gammarayfs_oper, NULL);
}
static int redismodule_init(struct state_conf *conf, char **fields, int fieldlens)
{
assert(fieldlens == 1);
buffer = calloc(BUFFER_SIZE, sizeof(uint32_t));
assert(buffer);
buffer_fill = 0;
if (conf->output_args) {
redisconf_t *rconf = redis_parse_connstr(conf->output_args);
if (rconf->type == T_TCP) {
log_info("redis-module", "{type: TCP, server: %s, "
"port: %u, list: %s}", rconf->server,
rconf->port, rconf->list_name);
} else {
log_info("redis-module", "{type: LOCAL, path: %s, "
"list: %s}", rconf->path, rconf->list_name);
}
queue_name = rconf->list_name;
} else {
queue_name = "zmap_output";
}
return redis_init(conf->output_args);
}
/*
* Main
*/
int
main (int argc, char **argv)
{
/* Locals */
char starttime_str[256];
char endtime_str[256];
char getCmd[256];
treewalk_options_st opts;
treewalk_init_opts(&opts);
/* Globals */
treewalk_init_globals();
/* Set up signal handler */
treewalk_install_signal_handlers();
/* Enable logging. */
PURGER_debug_stream = stdout;
PURGER_debug_level = PURGER_LOG_DBG;
/* Init lib circle */
int rank = CIRCLE_init(argc, argv);
if(rank < 0)
exit(1);
CIRCLE_enable_logging(CIRCLE_LOG_ERR);
PURGER_global_rank = rank;
opts.rank = rank;
/* Process command line options */
treewalk_process_options(argc,argv,&opts);
/* Init redis */
if (!benchmarking_flag && redis_init(opts.redis_hostname,opts.redis_port,opts.db_number) < 0)
{
LOG(PURGER_LOG_FATAL, "Redis error: %s", REDIS->errstr);
exit(EXIT_FAILURE);
}
/* Timing */
time(&time_started);
/* Ensure it's OK to run at this time */
if(!benchmarking_flag && treewalk_check_state(opts.rank,opts.force_flag) < 0)
exit(1);
/* Read from restart files */
if(!benchmarking_flag && opts.restart_flag)
CIRCLE_read_restarts();
/* Enable sharding */
if(!benchmarking_flag && sharded_flag)
{
sharded_count = redis_shard_init(opts.redis_hostlist,opts.redis_port,opts.db_number);
redis_command_ptr = &redis_shard_command;
}
/* Parallel section */
CIRCLE_cb_create(&add_objects);
CIRCLE_cb_process(&process_objects);
CIRCLE_begin();
/* End parallel section (well, kind of) */
/* Set state */
sprintf(getCmd,"set treewalk-rank-%d 0", rank);
if(!benchmarking_flag && redis_blocking_command(getCmd,NULL,INT)<0)
{
fprintf(stderr,"Unable to %s",getCmd);
}
time(&time_finished);
struct tm * localstart = localtime( &time_started );
struct tm * localend = localtime ( &time_finished );
strftime(starttime_str, 256, "%b-%d-%Y,%H:%M:%S",localstart);
strftime(endtime_str, 256, "%b-%d-%Y,%H:%M:%S",localend);
sprintf(getCmd,"set treewalk_timestamp \"%s\"",endtime_str);
if(!benchmarking_flag && redis_blocking_command(getCmd,NULL,INT) < 0)
{
fprintf(stderr,"Unable to %s",getCmd);
}
LOG(PURGER_LOG_INFO,"Files: %d\tDirs: %d\tTotal: %d\n",file_count,dir_count,file_count+dir_count);
if(!benchmarking_flag && sharded_flag)
redis_shard_finalize();
if(!benchmarking_flag)
redis_finalize();
if(rank == 0)
{
LOG(PURGER_LOG_INFO, "treewalk run started at: %s", starttime_str);
LOG(PURGER_LOG_INFO, "treewalk run completed at: %s", endtime_str);
LOG(PURGER_LOG_INFO, "treewalk total time (seconds) for this run: %f",difftime(time_finished,time_started));
}
LOG(PURGER_LOG_INFO, "\nTotal time in process_objects: %lf\n\
\tRedis commands: %lf %lf%%\n\
\tStating: %lf %lf%%\n\
\tReaddir: %lf %lf%%\n\
\tHashing: %lf %lf%%\n",
process_objects_total[1],redis_time[1],redis_time[1]/process_objects_total[1]*100.0,stat_time[1],stat_time[1]/process_objects_total[1]*100.0,readdir_time[1],readdir_time[1]/process_objects_total[1]*100.0
,hash_time[1],hash_time[1]/process_objects_total[1]*100.0);
CIRCLE_finalize();
_exit(EXIT_SUCCESS);
}
int
main (int argc, char **argv)
{
int index;
int c;
char *redis_hostname;
char *redis_hostlist;
int redis_port;
int time_flag = 0;
int dir_flag = 0;
int force_flag = 0;
int restart_flag = 0;
int redis_hostname_flag = 0;
benchmarking_flag = 0;
sharded_flag = 0;
int redis_port_flag = 0;
process_objects_total[2] = 0;
redis_time[2] = 0;
stat_time[2] = 0;
readdir_time[2] = 0;
redis_command_ptr = &redis_command;
/* Enable logging. */
PURGER_debug_stream = stdout;
PURGER_debug_level = PURGER_LOG_DBG;
int rank = CIRCLE_init(argc, argv);
PURGER_global_rank = rank;
opterr = 0;
while((c = getopt(argc, argv, "d:h:p:ft:l:rs:b")) != -1)
{
switch(c)
{
case 'b':
benchmarking_flag = 1;
break;
case 'd':
TOP_DIR = realpath(optarg, NULL);
if(rank == 0) LOG(PURGER_LOG_INFO,"Using %s as a root path.",TOP_DIR);
dir_flag = 1;
break;
case 'l':
PURGER_debug_level = atoi(optarg);
break;
case 'h':
redis_hostname = optarg;
redis_hostname_flag = 1;
break;
case 'p':
redis_port = atoi(optarg);
redis_port_flag = 1;
break;
case 'r':
if(rank == 0) LOG(PURGER_LOG_WARN,"You have specified to use restart files.");
restart_flag = 1;
break;
case 't':
time_flag = 1;
expire_threshold = (float)SECONDS_PER_DAY * atof(optarg);
if(rank == 0) LOG(PURGER_LOG_WARN,"Changed file expiration time to %.2f days, or %.2f seconds.",expire_threshold/(60.0*60.0*24),expire_threshold);
break;
case 's':
sharded_flag = 1;
redis_hostlist = optarg;
break;
case 'f':
force_flag = 1;
if(rank == 0) LOG(PURGER_LOG_WARN,"Warning: You have chosen to force treewalk.");
break;
case '?':
if (optopt == 'd' || optopt == 'h' || optopt == 'p' || optopt == 't' || optopt == 'l' || optopt == 's')
{
print_usage(argv);
fprintf(stderr, "Option -%c requires an argument.\n", optopt);
}
else if (isprint (optopt))
{
print_usage(argv);
fprintf(stderr, "Unknown option `-%c'.\n", optopt);
}
else
{
print_usage(argv);
fprintf(stderr,
"Unknown option character `\\x%x'.\n",
optopt);
}
exit(EXIT_FAILURE);
default:
abort();
}
}
if(restart_flag && dir_flag && !benchmarking_flag)
{
if(rank == 0) LOG(PURGER_LOG_WARN, "You have told treewalk to use both checkpoint files and a directory. You cannot combine these options.\n"
"If you use a directory, treewalk will start from scratch. If you use a checkpoint file, it will start from\n"
"from the data in the checkpoint files.\n");
exit(EXIT_FAILURE);
}
if(time_flag == 0 && !benchmarking_flag)
{
if(rank == 0) LOG(PURGER_LOG_WARN, "A file timeout value was not specified. Files older than %.2f seconds (%.2f days) will be expired.",expire_threshold,expire_threshold/(60.0*60.0*24.0));
}
if(dir_flag == 0 && !restart_flag && !benchmarking_flag)
{
print_usage(argv);
if(rank == 0) LOG(PURGER_LOG_FATAL, "You must specify a starting directory");
exit(EXIT_FAILURE);
}
if(redis_hostname_flag == 0 && !benchmarking_flag)
{
if(rank == 0) LOG(PURGER_LOG_WARN, "A hostname for redis was not specified, defaulting to localhost.");
redis_hostname = "localhost";
}
if(redis_port_flag == 0 && !benchmarking_flag)
{
if(rank == 0) LOG(PURGER_LOG_WARN, "A port number for redis was not specified, defaulting to 6379.");
redis_port = 6379;
}
for (index = optind; index < argc; index++)
LOG(PURGER_LOG_WARN, "Non-option argument %s", argv[index]);
if (!benchmarking_flag && redis_init(redis_hostname,redis_port) < 0)
{
LOG(PURGER_LOG_FATAL, "Redis error: %s", REDIS->errstr);
exit(EXIT_FAILURE);
}
time(&time_started);
if(!benchmarking_flag && treewalk_check_state(rank,force_flag) < 0)
exit(1);
if(!benchmarking_flag && restart_flag)
CIRCLE_read_restarts();
if(!benchmarking_flag && sharded_flag)
{
sharded_count = redis_shard_init(redis_hostlist,redis_port);
redis_command_ptr = &redis_shard_command;
}
CIRCLE_cb_create(&add_objects);
CIRCLE_cb_process(&process_objects);
CIRCLE_begin();
CIRCLE_finalize();
char getCmd[256];
sprintf(getCmd,"set treewalk-rank-%d 0", rank);
if(!benchmarking_flag && redis_blocking_command(getCmd,NULL,INT)<0)
{
fprintf(stderr,"Unable to %s",getCmd);
exit(1);
}
time(&time_finished);
char starttime_str[256];
char endtime_str[256];
struct tm * localstart = localtime( &time_started );
struct tm * localend = localtime ( &time_finished );
strftime(starttime_str, 256, "%b-%d-%Y,%H:%M:%S",localstart);
strftime(endtime_str, 256, "%b-%d-%Y,%H:%M:%S",localend);
sprintf(getCmd,"set treewalk_timestamp \"%s\"",endtime_str);
if(!benchmarking_flag && redis_blocking_command(getCmd,NULL,INT) < 0)
{
fprintf(stderr,"Unable to %s",getCmd);
}
if(rank == 0)
{
LOG(PURGER_LOG_INFO, "treewalk run started at: %s", starttime_str);
LOG(PURGER_LOG_INFO, "treewalk run completed at: %s", endtime_str);
LOG(PURGER_LOG_INFO, "treewalk total time (seconds) for this run: %f",difftime(time_finished,time_started));
LOG(PURGER_LOG_INFO, "\nTotal time in process_objects: %lf\n\
\tRedis commands: %lf %lf\n\
\tStating: %lf %lf\n\
\tReaddir: %lf %lf\n\
\tHashing: %lf %lf\n",
process_objects_total[1],redis_time[1],redis_time[1]/process_objects_total[1]*100.0,stat_time[1],stat_time[1]/process_objects_total[1]*100.0,readdir_time[1],readdir_time[1]/process_objects_total[1]*100.0
,hash_time[1],hash_time[1]/process_objects_total[1]*100.0);
}
int
main(int argc, char **argv)
{
struct event *ev_sigint, *ev_sigterm, *ev_sigchld, *ev_sighup;
struct glougloud *ggd;
int op;
ggd = xcalloc(1, sizeof(struct glougloud));
addr_aton("127.0.0.1", &ggd->probes.serv_ip);
addr_aton("127.0.0.1", &ggd->viz.serv_ip);
ggd->probes.serv_port = GLOUGLOU_PROBE_DEFAULT_PORT;
ggd->viz.serv_port = GLOUGLOU_VIZ_DEFAULT_PORT;
ggd->daemonize = 1;
ggd->logfile = GLOUGLOUD_LOGFILE;
ggd->loglevel = LOG_WARN;
ggd->redis.socket_chrooted = "/socket/redis.sock";
ggd->redis.socket = "/var/lib/glougloud/chroot/socket/redis.sock";
while ((op = getopt(argc, argv, "Dhl:L:p:P:v")) != -1) {
switch (op) {
case 'D':
ggd->logfile = NULL;
ggd->daemonize = 0;
break;
case 'h':
usage();
/* NOTREACHED */
case 'l':
if (addr_aton(optarg, &ggd->probes.serv_ip) < 0)
err(1, "invalid probes server ip");
break;
case 'L':
if (addr_aton(optarg, &ggd->viz.serv_ip) < 0)
err(1, "invalid vizualisation server ip");
break;
case 'p':
ggd->probes.serv_port = atoi(optarg);
break;
case 'P':
ggd->viz.serv_port = atoi(optarg);
break;
case 'v':
ggd->loglevel++;
break;
default:
usage();
/* NOTREACHED */
}
}
if (geteuid() != 0)
errx(1, "must be root");
log_init(ggd->logfile, ggd->loglevel);
log_warn("glougloud startup");
if (redis_init(ggd) < 0)
log_fatal("init redis failed");
if (probes_init(ggd) < 0)
log_fatal("init probes failed");
if (viz_init(ggd) < 0)
log_fatal("init viz failed");
ev_base = event_base_new();
ev_sigint = evsignal_new(ev_base, SIGINT, sig_handler, NULL);
ev_sigterm = evsignal_new(ev_base, SIGTERM, sig_handler, NULL);
ev_sigchld = evsignal_new(ev_base, SIGCHLD, sig_handler, NULL);
ev_sighup = evsignal_new(ev_base, SIGHUP, sig_handler, NULL);
evsignal_add(ev_sigint, NULL);
evsignal_add(ev_sigterm, NULL);
evsignal_add(ev_sigchld, NULL);
evsignal_add(ev_sighup, NULL);
signal(SIGPIPE, SIG_IGN);
if (ggd->daemonize) {
ggd->pid = fork();
log_info("daemonized, pid %d", ggd->pid);
if (ggd->pid > 0)
return 0;
}
event_base_dispatch(ev_base);
viz_shutdown();
probes_shutdown();
redis_shutdown();
return 0;
}
/* main thread of execution */
int main(int argc, char* args[])
{
int fd;
char* index, *db, *stream;
FILE* indexf;
struct bitarray* bits;
fprintf_blue(stdout, "gammaray Async Queuer -- "
"By: Wolfgang Richter "
"<*****@*****.**>\n");
redis_print_version();
if (argc < 4)
{
fprintf_light_red(stderr, "Usage: %s <index file> <stream file>"
" <redis db num>\n", args[0]);
return EXIT_FAILURE;
}
index = args[1];
stream = args[2];
db = args[3];
/* ----------------- hiredis ----------------- */
struct kv_store* handle = redis_init(db, true);
if (handle == NULL)
{
fprintf_light_red(stderr, "Failed getting Redis context "
"(connection failure?).\n");
return EXIT_FAILURE;
}
fprintf_cyan(stdout, "Loading MD filter from: %s\n\n", index);
indexf = fopen(index, "r");
if (indexf == NULL)
{
fprintf_light_red(stderr, "Error opening index file to get MD "
"filter.\n");
return EXIT_FAILURE;
}
if (qemu_load_md_filter(indexf, &bits))
{
fprintf_light_red(stderr, "Error getting MD filter from BSON file.\n");
bits = bitarray_init(5242880);
bitarray_set_all(bits);
}
if (bits == NULL)
{
fprintf_light_red(stderr, "Bitarray is NULL!\n");
return EXIT_FAILURE;
}
fclose(indexf);
fprintf_cyan(stdout, "Attaching to stream: %s\n\n", stream);
on_exit((void (*) (int, void *)) redis_shutdown, handle);
if (strcmp(stream, "-") != 0)
{
fd = open(stream, O_RDONLY);
}
else
{
fd = STDIN_FILENO;
}
if (fd == -1)
{
fprintf_light_red(stderr, "Error opening stream file. "
"Does it exist?\n");
return EXIT_FAILURE;
}
read_loop(fd, handle, bits);
close(fd);
return EXIT_SUCCESS;
}
int
main (int argc, char **argv)
{
int index;
int c;
char *redis_hostname;
int redis_port;
int redis_hostname_flag = 0;
int redis_port_flag = 0;
int sharded_flag = 0;
int ldap_flag = 0;
int force_flag = 0;
int db_number = 0;
sharded_count = 0;
char * redis_host_list;
redis_command_ptr = &non_sharded_redis_command;
PURGER_debug_stream = stdout;
PURGER_debug_level = PURGER_LOG_DBG;
int PURGER_global_rank = CIRCLE_init(argc, argv);
if(PURGER_global_rank < 0)
exit(1);
opterr = 0;
CIRCLE_enable_logging(CIRCLE_LOG_ERR);
while((c = getopt(argc, argv, "h:p:l:fi:s:a:o:")) != -1)
{
switch(c)
{
case 'o':
ldap_port = atoi(optarg);
break;
case 'a':
ldap_server = optarg;
ldap_flag = 1;
break;
case 'h':
redis_hostname = optarg;
redis_hostname_flag = 1;
break;
case 'i':
db_number = atoi(optarg);
break;
case 'p':
redis_port = atoi(optarg);
redis_port_flag = 1;
break;
case 'f':
force_flag = 1;
if(PURGER_global_rank == 0) LOG(PURGER_LOG_WARN,"Warning: You have chosen to force warnusers.");
break;
case 'l':
PURGER_debug_level = atoi(optarg);
break;
case 's':
redis_host_list = optarg;
sharded_flag = 1;
redis_command_ptr = &redis_blocking_shard_command;
break;
case '?':
if (PURGER_global_rank == 0 && (optopt == 'h' || optopt == 'p' || optopt == 'l'))
{
print_usage(argv);
fprintf(stderr, "Option -%c requires an argument.\n", optopt);
exit(EXIT_FAILURE);
}
else if (isprint (optopt))
{
print_usage(argv);
fprintf(stderr, "Unknown option `-%c'.\n", optopt);
exit(EXIT_FAILURE);
}
else
{
print_usage(argv);
fprintf(stderr,
"Unknown option character `\\x%x'.\n",
optopt);
exit(EXIT_FAILURE);
}
default:
abort();
}
}
if(redis_hostname_flag == 0)
{
if(PURGER_global_rank == 0) LOG(PURGER_LOG_WARN, "A hostname for redis was not specified, defaulting to localhost.");
redis_hostname = "localhost";
}
if(redis_port_flag == 0)
{
if(PURGER_global_rank == 0) LOG(PURGER_LOG_WARN, "A port number for redis was not specified, defaulting to 6379.");
redis_port = 6379;
}
for (index = optind; index < argc; index++)
LOG(PURGER_LOG_WARN, "Non-option argument %s", argv[index]);
if(redis_init(redis_hostname, redis_port, db_number) < 0)
{
LOG(PURGER_LOG_ERR,"Unable to initialize redis.");
exit(0);
}
if(sharded_flag)
{
LOG(PURGER_LOG_INFO,"Sharding enabled.");
sharded_count = redis_shard_init(redis_host_list, redis_port, db_number);
}
if(!ldap_flag)
{
LOG(PURGER_LOG_ERR,"You must specify an ldap server.");
exit(EXIT_FAILURE);
}
else
ldap_init(ldap_server,ldap_port);
mailinfo.from = "*****@*****.**";
mailinfo.fromreal = "*****@*****.**";
mailinfo.subject = "[PURGER NOTIFICATION]";
mailinfo.defaultto = "*****@*****.**";
mailinfo.server = "mail.lanl.gov";
mailinfo.txt = "The following text file in the Turquiose network contains a list of \
your scratch files that have not been modified in the last 14+ days. \
Those files will be deleted in at least 6 days if not modified by then. \
This notification may not have up-to-the-minute information, but we \
will verify a file's actual age before purging it. For more information, \
please see our purge policy: http://hpc.lanl.gov/purge_policy. \
If you have questions or concerns, please contact ICN Consultants \
at 505-665-4444 option 3.";
time(&time_started);
if(warnusers_check_state(PURGER_global_rank,force_flag) < 0)
exit(1);
CIRCLE_cb_create(&add_objects);
CIRCLE_cb_process(&process_objects);
CIRCLE_begin();
CIRCLE_finalize();
time(&time_finished);
char starttime_str[256];
char endtime_str[256];
struct tm * localstart = localtime( &time_started );
struct tm * localend = localtime ( &time_finished );
strftime(starttime_str, 256, "%b-%d-%Y,%H:%M:%S",localstart);
strftime(endtime_str, 256, "%b-%d-%Y,%H:%M:%S",localend);
char getCmd[256];
sprintf(getCmd,"set warnusers_timestamp \"%s\"",endtime_str);
if(redis_blocking_command(getCmd,(void*)NULL,NIL)<0)
{
LOG(PURGER_LOG_ERR,"Unable to %s",getCmd);
}
sprintf(getCmd,"set warnusers-rank-%d 0", PURGER_global_rank);
if(redis_blocking_command(getCmd,(void*)NULL,NIL)<0)
{
LOG(PURGER_LOG_ERR,"Unable to %s",getCmd);
}
redis_finalize();
if(sharded_flag)
redis_shard_finalize();
if(PURGER_global_rank == 0)
{
LOG(PURGER_LOG_INFO, "Warnusers run started at: %s", starttime_str);
LOG(PURGER_LOG_INFO, "Warnusers run completed at: %s", endtime_str);
LOG(PURGER_LOG_INFO, "Warnusers total time (seconds) for this run: %f",difftime(time_finished,time_started));
}
exit(EXIT_SUCCESS);
}
int main()
{
//daemonize();
//process signal
struct sigaction sa;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sa.sa_handler = handler;
sigaction(SIGINT, &sa, NULL);
json_object *jfile = json_object_from_file("config.json");
if(!jobject_ptr_isvalid(jfile))
{
printf("open config.json failed!\n");
return -1;
}
json_object *jlog = json_util_get(jfile,"CONFIG.log");
if(!jlog) return -1;
const char *strlog = json_object_get_string(jlog);
log_open(&log_,strlog);
json_object *jlog_level = json_util_get(jfile,"CONFIG.log_level");
if(jlog_level)
{
int log_level = json_object_get_int(jlog_level);
log_level_set(log_,log_level);
}
loga(log_,"starting server!");
json_object_put(jfile);
int rv;
rv = segword_init();
if(rv < 0)
{
loga(log_,"segword_init failed!");
return -1;
}
redis_init();
rv = cm_start();
if(rv < 0)
return -1;
struct timeval delay;
while(!stop_daemon)
{
delay.tv_sec = 0;
delay.tv_usec = 100000;
int rv = select(0,NULL,NULL,NULL,&delay);
if(rv == 0)
{
continue;
}
}
cm_stop();
cm_destroy();
redis_fini();
segword_fini();
printf("Normal exit!\n");
return 0;
}
