int
main(int argc, char **argv)
{
int port_no = DEFAULT_PORT, daemon = 0;
const char *max_threads_string = NULL, *port_string = NULL;
const char *address;
const char *send_endpoint = NULL, *recv_endpoint = NULL, *log_base_path = NULL;
int n_processed_args, flags = RUN_MODE_ENABLE_MAX_FD_CHECK;
run_mode mode = run_mode_none;
if (!(default_max_threads = get_core_number())) {
default_max_threads = DEFAULT_MAX_THREADS;
}
/* parse options */
{
static grn_str_getopt_opt opts[] = {
{'c', NULL, NULL, 0, getopt_op_none}, /* deprecated */
{'t', "n-threads", NULL, 0, getopt_op_none},
{'h', "help", NULL, run_mode_usage, getopt_op_update},
{'p', "port", NULL, 0, getopt_op_none},
{'\0', "bind-address", NULL, 0, getopt_op_none}, /* not supported yet */
{'s', "send-endpoint", NULL, 0, getopt_op_none},
{'r', "receive-endpoint", NULL, 0, getopt_op_none},
{'l', "log-base-path", NULL, 0, getopt_op_none},
{'d', "daemon", NULL, run_mode_daemon, getopt_op_update},
{'\0', "disable-max-fd-check", NULL, RUN_MODE_ENABLE_MAX_FD_CHECK,
getopt_op_off},
{'\0', NULL, NULL, 0, 0}
};
opts[0].arg = &max_threads_string;
opts[1].arg = &max_threads_string;
opts[3].arg = &port_string;
opts[4].arg = &address;
opts[5].arg = &send_endpoint;
opts[6].arg = &recv_endpoint;
opts[7].arg = &log_base_path;
n_processed_args = grn_str_getopt(argc, argv, opts, &flags);
}
/* main */
mode = (flags & RUN_MODE_MASK);
if (n_processed_args < 0 ||
(argc - n_processed_args) != 1 ||
mode == run_mode_error) {
usage(stderr);
return EXIT_FAILURE;
} else if (mode == run_mode_usage) {
usage(stdout);
return EXIT_SUCCESS;
} else {
grn_ctx ctx;
void *zmq_ctx;
int max_threads;
if (max_threads_string) {
max_threads = atoi(max_threads_string);
if (max_threads > MAX_THREADS) {
print_error("too many threads. limit to %d.", MAX_THREADS);
max_threads = MAX_THREADS;
}
} else {
max_threads = default_max_threads;
}
if (port_string) {
port_no = atoi(port_string);
}
if (flags & RUN_MODE_ENABLE_MAX_FD_CHECK) {
/* check environment */
struct rlimit rlim;
if (!getrlimit(RLIMIT_NOFILE, &rlim)) {
if (rlim.rlim_max < MIN_MAX_FDS) {
print_error("too small max fds. %d required.", MIN_MAX_FDS);
return -1;
}
rlim.rlim_cur = rlim.rlim_cur;
setrlimit(RLIMIT_NOFILE, &rlim);
}
}
if (mode == run_mode_daemon) {
daemonize();
}
grn_init();
grn_ctx_init(&ctx, 0);
if ((db = grn_db_open(&ctx, argv[n_processed_args]))) {
if ((zmq_ctx = zmq_init(1))) {
signal(SIGTERM, signal_handler);
signal(SIGINT, signal_handler);
signal(SIGQUIT, signal_handler);
serve_threads(max_threads, port_no, argv[n_processed_args], zmq_ctx,
send_endpoint, recv_endpoint, log_base_path);
zmq_term(zmq_ctx);
} else {
print_error("cannot create zmq context.");
}
grn_obj_close(&ctx, db);
} else {
print_error("cannot open db.");
}
grn_ctx_fin(&ctx);
grn_fin();
}
return 0;
}
int
main(int argc, char **argv)
{
const char *db_path;
const char *dataset_name;
grn_ctx ctx_, *ctx;
grn_obj *db;
grn_bool success = GRN_TRUE;
int parsed_argc, rest_argc;
int flags = MODE_NONE;
const char *default_tokenizer = NULL;
static grn_str_getopt_opt opts[] = {
{'\0', "default-tokenizer", NULL, 0, GETOPT_OP_NONE},
{'h', "help", NULL, MODE_USAGE, GETOPT_OP_UPDATE}
};
opts[0].arg = &default_tokenizer;
parsed_argc = grn_str_getopt(argc, argv, opts, &flags);
if (parsed_argc < 0) {
usage(stderr, argc, argv);
return EXIT_FAILURE;
}
if (flags & MODE_USAGE) {
usage(stdout, argc, argv);
return EXIT_SUCCESS;
}
rest_argc = argc - parsed_argc;
if (rest_argc != 2) {
usage(stderr, argc, argv);
return EXIT_FAILURE;
}
db_path = argv[parsed_argc];
dataset_name = argv[parsed_argc + 1];
grn_init();
ctx = &ctx_;
grn_ctx_init(ctx, 0);
db = grn_db_open(ctx, db_path);
if (!db) {
if (ctx->rc == GRN_NO_SUCH_FILE_OR_DIRECTORY) {
db = grn_db_create(ctx, db_path, NULL);
if (!db) {
fprintf(stderr, "DB create failed (%s): %s\n", db_path, ctx->errbuf);
}
} else {
fprintf(stderr, "DB open failed (%s): %s\n", db_path, ctx->errbuf);
}
}
if (db) {
grn_obj text;
GRN_TEXT_INIT(&text, 0);
#define SEND(string) send_command(ctx, &text, string, dataset_name)
SEND("register suggest/suggest");
SEND("table_create event_type TABLE_HASH_KEY ShortText");
{
grn_obj query;
GRN_TEXT_INIT(&query, 0);
GRN_TEXT_PUTS(ctx, &query,
"table_create bigram TABLE_PAT_KEY ShortText "
"--default_tokenizer ");
if (default_tokenizer) {
GRN_TEXT_PUTS(ctx, &query, default_tokenizer);
} else {
GRN_TEXT_PUTS(ctx, &query, DEFAULT_DEFAULT_TOKENIZER);
}
GRN_TEXT_PUTS(ctx, &query, " --normalizer NormalizerAuto");
GRN_TEXT_PUTC(ctx, &query, '\0');
SEND(GRN_TEXT_VALUE(&query));
GRN_OBJ_FIN(ctx, &query);
}
SEND("table_create kana TABLE_PAT_KEY ShortText "
"--normalizer NormalizerAuto");
SEND("table_create item_${DATASET} TABLE_PAT_KEY "
"ShortText --default_tokenizer TokenDelimit "
"--normalizer NormalizerAuto");
SEND("column_create bigram item_${DATASET}_key "
"COLUMN_INDEX|WITH_POSITION item_${DATASET} _key");
SEND("column_create item_${DATASET} kana COLUMN_VECTOR kana");
SEND("column_create kana item_${DATASET}_kana COLUMN_INDEX "
"item_${DATASET} kana");
SEND("column_create item_${DATASET} freq COLUMN_SCALAR Int32");
SEND("column_create item_${DATASET} last COLUMN_SCALAR Time");
SEND("column_create item_${DATASET} boost COLUMN_SCALAR Int32");
SEND("column_create item_${DATASET} freq2 COLUMN_SCALAR Int32");
SEND("column_create item_${DATASET} buzz COLUMN_SCALAR Int32");
SEND("table_create pair_${DATASET} TABLE_HASH_KEY UInt64");
SEND("column_create pair_${DATASET} pre COLUMN_SCALAR item_${DATASET}");
SEND("column_create pair_${DATASET} post COLUMN_SCALAR item_${DATASET}");
SEND("column_create pair_${DATASET} freq0 COLUMN_SCALAR Int32");
SEND("column_create pair_${DATASET} freq1 COLUMN_SCALAR Int32");
SEND("column_create pair_${DATASET} freq2 COLUMN_SCALAR Int32");
SEND("column_create item_${DATASET} co COLUMN_INDEX pair_${DATASET} pre");
SEND("table_create sequence_${DATASET} TABLE_HASH_KEY ShortText");
SEND("table_create event_${DATASET} TABLE_NO_KEY");
SEND("column_create sequence_${DATASET} events "
"COLUMN_VECTOR|RING_BUFFER event_${DATASET}");
SEND("column_create event_${DATASET} type COLUMN_SCALAR event_type");
SEND("column_create event_${DATASET} time COLUMN_SCALAR Time");
SEND("column_create event_${DATASET} item COLUMN_SCALAR item_${DATASET}");
SEND("column_create event_${DATASET} sequence COLUMN_SCALAR "
"sequence_${DATASET}");
SEND("table_create configuration TABLE_HASH_KEY ShortText");
SEND("column_create configuration weight COLUMN_SCALAR UInt32");
SEND("load --table configuration");
SEND("[");
SEND("{\"_key\": \"${DATASET}\", \"weight\": 1}");
SEND("]");
#undef SEND
success = ctx->rc == GRN_SUCCESS;
GRN_OBJ_FIN(ctx, &text);
GRN_OBJ_FIN(ctx, db);
} else {
success = GRN_FALSE;
}
grn_ctx_fin(ctx);
grn_fin();
return success ? EXIT_SUCCESS : EXIT_FAILURE;
}
