static lagopus_result_t
s_test_thread_main(const lagopus_thread_t *tptr, void *arg) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
lagopus_chrono_t *dates = NULL;
(void)arg;
if (tptr != NULL) {
test_thread_t tt = (test_thread_t)*tptr;
if (tt != NULL) {
ssize_t i;
lagopus_chrono_t now;
dates = (lagopus_chrono_t *)
malloc(sizeof(lagopus_chrono_t) * (size_t)tt->m_n_puts);
if (dates == NULL) {
goto done;
}
/*
* Ready, steady,
*/
(void)lagopus_mutex_lock(&(tt->m_start_lock));
/*
* go.
*/
(void)lagopus_mutex_unlock(&(tt->m_start_lock));
for (i = 0; i < tt->m_n_puts; i++) {
WHAT_TIME_IS_IT_NOW_IN_NSEC(dates[i]);
}
if (lagopus_bbq_put_n(&(tt->m_q), (void **)dates,
(size_t)tt->m_n_puts,
lagopus_chrono_t, -1LL, NULL) !=
(lagopus_result_t)tt->m_n_puts) {
goto done;
}
now = -1LL;
if (lagopus_bbq_put(&(tt->m_q), &now, lagopus_chrono_t, -1LL) !=
LAGOPUS_RESULT_OK) {
goto done;
}
ret = tt->m_n_puts;
lagopus_msg_debug(1, "Done, ret = " PFSZS(020, d)
", req = " PFSZS(020, u) ".\n",
(size_t)ret, (size_t)tt->m_n_puts);
}
}
done:
free((void *)dates);
return ret;
}
static lagopus_result_t
s_parse_snmp(datastore_interp_t *iptr,
datastore_interp_state_t state,
size_t argc, const char *const argv[],
lagopus_hashmap_t *hptr,
datastore_update_proc_t u_proc,
datastore_enable_proc_t e_proc,
datastore_serialize_proc_t s_proc,
datastore_destroy_proc_t d_proc,
lagopus_dstring_t *result) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
size_t i;
(void)iptr;
(void)state;
(void)argc;
(void)hptr;
(void)u_proc;
(void)e_proc;
(void)s_proc;
(void)d_proc;
for (i = 0; i < argc; i++) {
lagopus_msg_debug(1, "argv[" PFSZS(4, u) "]:\t'%s'\n", i, argv[i]);
}
argv++;
if (IS_VALID_STRING(*argv) == false) {
ret = s_parse_snmp_show(result);
} else {
ret = s_parse_snmp_internal(argv, result);
}
return ret;
}
static lagopus_result_t
s_parse(datastore_interp_t *iptr,
datastore_interp_state_t state,
size_t argc, const char *const argv[],
lagopus_hashmap_t *hptr,
datastore_update_proc_t u_proc,
datastore_enable_proc_t e_proc,
datastore_serialize_proc_t s_proc,
datastore_destroy_proc_t d_proc,
lagopus_dstring_t *result) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
size_t i;
(void)iptr;
(void)state;
(void)hptr;
(void)u_proc;
(void)e_proc;
(void)s_proc;
(void)d_proc;
(void)result;
for (i = 0; i < argc; i++) {
fprintf(stderr, "argv[" PFSZS(4, u) "]:\t'%s'\n", i, argv[i]);
}
ret = LAGOPUS_RESULT_OK;
return ret;
}
static inline lagopus_result_t
s_parse_datastore(datastore_interp_t *iptr,
datastore_interp_state_t state,
size_t argc, const char *const argv[],
lagopus_hashmap_t *hptr,
datastore_update_proc_t u_proc,
datastore_enable_proc_t e_proc,
datastore_serialize_proc_t s_proc,
datastore_destroy_proc_t d_proc,
lagopus_dstring_t *result) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
size_t i;
(void)iptr;
(void)argc;
(void)hptr;
(void)u_proc;
(void)e_proc;
(void)s_proc;
(void)d_proc;
for (i = 0; i < argc; i++) {
lagopus_msg_debug(1, "argv[" PFSZS(4, u) "]:\t'%s'\n", i, argv[i]);
}
argv++;
if (argc == 1) {
return s_current_all(result);
} else {
while (IS_VALID_STRING(*argv) == true) {
if (strcmp(*argv, "-addr") == 0) {
argv++;
if (IS_VALID_STRING(*argv) == true) {
ret = s_opt_parse_addr(state, argv, result);
if (ret != LAGOPUS_RESULT_OK) {
return ret;
}
} else {
return s_current_addr(result);
}
} else if (strcmp(*argv, "-port") == 0) {
argv++;
if (IS_VALID_STRING(*argv) == true) {
ret = s_opt_parse_port(state, argv, result);
if (ret != LAGOPUS_RESULT_OK) {
return ret;
}
} else {
return s_current_port(result);
}
} else if (strcmp(*argv, "-protocol") == 0) {
argv++;
if (IS_VALID_STRING(*argv) == true) {
ret = s_opt_parse_protocol(state, argv, result);
if (ret != LAGOPUS_RESULT_OK) {
return ret;
}
} else {
return s_current_protocol(result);
}
} else if (strcmp(*argv, "-tls") == 0) {
argv++;
if (IS_VALID_STRING(*argv) == true) {
ret = s_opt_parse_tls(state, argv, result);
if (ret != LAGOPUS_RESULT_OK) {
return ret;
}
} else {
return s_current_tls(result);
}
} else {
return datastore_json_result_string_setf(result,
LAGOPUS_RESULT_INVALID_ARGS,
"Unknown option '%s'",
*argv);
}
argv++;
}
// setter result
return datastore_json_result_set(result, ret, NULL);
}
}
STATIC lagopus_result_t
flow_cmd_parse(datastore_interp_t *iptr,
datastore_interp_state_t state,
size_t argc, const char *const argv[],
lagopus_hashmap_t *hptr,
datastore_update_proc_t u_proc,
datastore_enable_proc_t e_proc,
datastore_serialize_proc_t s_proc,
datastore_destroy_proc_t d_proc,
lagopus_dstring_t *result) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
lagopus_result_t ret_for_json = LAGOPUS_RESULT_ANY_FAILURES;
size_t i;
void *sub_cmd_proc;
char *name = NULL;
char *fullname = NULL;
char *str = NULL;
flow_conf_t conf = {NULL, OFPTT_ALL};
configs_t out_configs = {false, false};
lagopus_dstring_t conf_result = NULL;
(void) u_proc;
(void) e_proc;
(void) s_proc;
(void) d_proc;
for (i = 0; i < argc; i++) {
lagopus_msg_debug(1, "argv[" PFSZS(4, u) "]:\t'%s'\n", i, argv[i]);
}
if (iptr != NULL && argv != NULL && result != NULL) {
if ((ret = lagopus_dstring_create(&conf_result)) == LAGOPUS_RESULT_OK) {
argv++;
if (IS_VALID_STRING(*argv) == true) {
if ((ret = lagopus_hashmap_find(
&sub_cmd_not_name_table,
(void *)(*argv),
&sub_cmd_proc)) == LAGOPUS_RESULT_OK) {
/* parse sub cmd. */
if (sub_cmd_proc != NULL) {
ret_for_json =
((sub_cmd_proc_t) sub_cmd_proc)(iptr, state,
argc, argv,
NULL, hptr,
u_proc,
(void *) &out_configs,
result);
}
}
if (ret == LAGOPUS_RESULT_NOT_FOUND &&
ret_for_json != LAGOPUS_RESULT_OK) {
if ((ret = lagopus_str_unescape(*argv, "\"'", &name)) < 0) {
goto done;
} else {
argv++;
if ((ret = namespace_get_fullname(name, &fullname))
== LAGOPUS_RESULT_OK) {
if (IS_VALID_STRING(*argv) == true) {
if ((ret = lagopus_hashmap_find(
&sub_cmd_table,
(void *)(*argv),
&sub_cmd_proc)) == LAGOPUS_RESULT_OK) {
/* parse sub cmd. */
if (sub_cmd_proc != NULL) {
ret_for_json =
((sub_cmd_proc_t) sub_cmd_proc)(iptr, state,
argc, argv,
fullname, hptr,
u_proc,
(void *) &out_configs,
result);
} else {
ret = LAGOPUS_RESULT_NOT_FOUND;
lagopus_perror(ret);
goto done;
}
} else if (ret == LAGOPUS_RESULT_NOT_FOUND) {
/* parse dump cmd. */
ret_for_json = dump_sub_cmd_parse(iptr, argv, fullname, &conf,
&out_configs, result);
} else {
ret_for_json = datastore_json_result_string_setf(
result, LAGOPUS_RESULT_INVALID_ARGS,
"sub_cmd = %s.", *argv);
}
} else {
/* parse dump cmd. */
ret_for_json = dump_sub_cmd_parse(iptr, argv, fullname, &conf,
&out_configs, result);
}
} else {
ret_for_json = datastore_json_result_string_setf(
result, ret, "Can't get fullname %s.", name);
}
}
}
} else {
/* parse dump all cmd. */
ret_for_json = dump_sub_cmd_parse(iptr, argv, NULL, &conf,
&out_configs, result);
}
/* create jsno for LAGOPUS_RESULT_OK. */
if (ret_for_json == LAGOPUS_RESULT_OK &&
out_configs.is_dump == false) {
ret = lagopus_dstring_str_get(result, &str);
if (ret != LAGOPUS_RESULT_OK) {
goto done;
}
if (IS_VALID_STRING(str) == true) {
ret = datastore_json_result_set(result, LAGOPUS_RESULT_OK, str);
} else {
ret = datastore_json_result_set(result, LAGOPUS_RESULT_OK, NULL);
}
} else {
ret = ret_for_json;
}
}
done:
/* free. */
free(name);
free(fullname);
free(str);
lagopus_dstring_destroy(&conf_result);
} else {
ret = LAGOPUS_RESULT_INVALID_ARGS;
}
return ret;
}
static inline lagopus_result_t
s_parse_load(datastore_interp_t *iptr,
datastore_interp_state_t state,
size_t argc, const char *const argv[],
lagopus_hashmap_t *hptr,
datastore_update_proc_t u_proc,
datastore_enable_proc_t e_proc,
datastore_serialize_proc_t s_proc,
datastore_destroy_proc_t d_proc,
lagopus_dstring_t *result) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
size_t i;
const char *cname = NULL;
char *filepath = NULL;
(void)state;
(void)argc;
(void)hptr;
(void)u_proc;
(void)e_proc;
(void)s_proc;
(void)d_proc;
for (i = 0; i < argc; i++) {
lagopus_msg_debug(1, "argv[" PFSZS(4, u) "]:\t'%s'\n", i, argv[i]);
}
argv++;
if (IS_VALID_STRING(*argv) == false) {
ret = datastore_json_result_set(result,
LAGOPUS_RESULT_OK,
NULL);
} else {
if (IS_VALID_STRING(*argv) == true) {
if ((ret = lagopus_str_unescape(*argv, "\"'", &filepath)) > 0) {
if (s_is_readable(filepath) == LAGOPUS_RESULT_OK) {
ret = datastore_interp_get_current_configurater(iptr, &cname);
if (ret == LAGOPUS_RESULT_OK && IS_VALID_STRING(cname) == true) {
ret = datastore_interp_load_file(iptr, cname, filepath, result);
if (ret == LAGOPUS_RESULT_OK) {
ret = datastore_json_result_set(result, ret, NULL);
}
} else {
ret = datastore_json_result_string_setf(result,
ret,
CMD_ERR_MSG_LOAD_FAILED,
"internal error.");
}
} else {
ret = datastore_json_result_string_setf(result,
LAGOPUS_RESULT_INVALID_ARGS,
CMD_ERR_MSG_UNREADABLE,
filepath);
}
} else {
ret = datastore_json_result_string_setf(result,
LAGOPUS_RESULT_INVALID_ARGS,
CMD_ERR_MSG_INVALID_OPT_VALUE,
*argv);
}
} else {
ret = datastore_json_result_string_setf(result,
LAGOPUS_RESULT_INVALID_ARGS,
CMD_ERR_MSG_INVALID_OPT,
*argv);
}
}
free((void *) filepath);
return ret;
}
static int
do_run(size_t nthds, ssize_t nputs) {
int ret = 1;
lagopus_result_t r;
size_t i;
size_t j;
char thdname[16];
lagopus_chrono_t *put_dates = NULL;
size_t n_need_watch = 0;
size_t n_valid_polls = 0;
ssize_t qsz;
test_thread_t tt;
lagopus_bbq_t bbq;
lagopus_chrono_t t_begin;
lagopus_chrono_t t_end;
lagopus_chrono_t p_begin;
lagopus_chrono_t p_t;
ssize_t n_gets = 0;
lagopus_chrono_t p_min = LLONG_MAX;
lagopus_chrono_t p_max = LLONG_MIN;
double p_sum = 0.0;
double p_sum2 = 0.0;
double p_avg;
double p_sd;
lagopus_chrono_t t_total = 0;
double t_avg;
/*
* This is only for choking clang/scan-build.
*/
WHAT_TIME_IS_IT_NOW_IN_NSEC(t_begin);
put_dates = (lagopus_chrono_t *)
malloc(sizeof(lagopus_chrono_t) * (size_t)nputs);
if (put_dates == NULL) {
goto done;
}
if ((r = lagopus_mutex_create(&start_lock)) != LAGOPUS_RESULT_OK) {
lagopus_perror(r);
goto done;
}
if ((r = lagopus_mutex_create(&stop_lock)) != LAGOPUS_RESULT_OK) {
lagopus_perror(r);
goto done;
}
/*
* Create the qmuxer.
*/
if ((r = lagopus_qmuxer_create(&qmx)) != LAGOPUS_RESULT_OK) {
lagopus_perror(r);
goto done;
}
/*
* Then create queues.
*/
bbqs = (lagopus_bbq_t *)malloc(sizeof(lagopus_bbq_t) * nthds);
if (bbqs == NULL) {
goto done;
}
for (i = 0; i < nthds; i++) {
if ((r = lagopus_bbq_create(&(bbqs[i]), lagopus_chrono_t,
1000LL * 1000LL,
NULL)) != LAGOPUS_RESULT_OK) {
lagopus_perror(r);
goto done;
}
n_created_bbqs++;
}
if (n_created_bbqs == 0) {
goto done;
}
/*
* Then create poll objects for the each queue.
*/
polls = (lagopus_qmuxer_poll_t *)malloc(sizeof(lagopus_qmuxer_poll_t) *
n_created_bbqs);
if (polls == NULL) {
goto done;
}
for (i = 0; i < n_created_bbqs; i++) {
if ((r = lagopus_qmuxer_poll_create(&(polls[i]),
bbqs[i],
LAGOPUS_QMUXER_POLL_READABLE)) !=
LAGOPUS_RESULT_OK) {
lagopus_perror(r);
goto done;
}
n_created_polls++;
}
if (n_created_polls == 0) {
goto done;
}
/*
* Then create threads for the each poll objects/queues.
*/
tts = (test_thread_record *)malloc(sizeof(test_thread_record) *
n_created_polls);
if (tts == NULL) {
goto done;
}
for (i = 0; i < n_created_polls; i++) {
snprintf(thdname, sizeof(thdname), "putter " PFSZS(4, u), i);
tt = &(tts[i]);
if (test_thread_create(&tt, start_lock, bbqs[i], nputs,
(const char *)thdname) != true) {
goto done;
}
n_created_thds++;
}
if (n_created_thds == 0) {
goto done;
}
/*
* Let the initiation begin.
*/
/*
* Ready, note that all the created threads do this lock.
*/
(void)lagopus_mutex_lock(&start_lock);
/*
* Steady,
*/
for (i = 0; i < n_created_thds; i++) {
tt = &(tts[i]);
if (lagopus_thread_start((lagopus_thread_t *)&tt, false) !=
LAGOPUS_RESULT_OK) {
(void)lagopus_mutex_unlock(&start_lock);
goto done;
}
}
fprintf(stdout, "Test for " PFSZ(u) " threads " PFSZ(u)
" events/thdread start.\n", n_created_thds, (size_t)nputs);
/*
* Go.
*/
(void)lagopus_mutex_unlock(&start_lock);
WHAT_TIME_IS_IT_NOW_IN_NSEC(t_begin);
while (true) {
/*
* Like the select(2)/poll(2), initialize poll objects before
* checking events.
*/
n_need_watch = 0;
n_valid_polls = 0;
for (i = 0; i < n_created_thds; i++) {
/*
* Check if the poll has a valid queue.
*/
bbq = NULL;
if ((r = lagopus_qmuxer_poll_get_queue(&(polls[i]), &bbq)) !=
LAGOPUS_RESULT_OK) {
lagopus_perror(r);
break;
}
if (bbq != NULL) {
n_valid_polls++;
}
/*
* Reset the poll status.
*/
if ((r = lagopus_qmuxer_poll_reset(&(polls[i]))) != LAGOPUS_RESULT_OK) {
lagopus_perror(r);
break;
}
n_need_watch++;
}
/*
* If there are no valid queues, exit.
*/
if (n_valid_polls == 0) {
break;
}
/*
* Wait for an event.
*
* Note that we better set timeout, not waiting forever.
*/
r = lagopus_qmuxer_poll(&qmx, (lagopus_qmuxer_poll_t *const)polls,
n_need_watch,
100LL * 1000LL * 1000LL);
if (r > 0) {
/*
* Check which poll got an event. Actually, check all the queues
* in this sample.
*/
size_t n_actual_get = 0LL;
for (i = 0; i < n_created_thds; i++) {
if ((qsz = lagopus_bbq_size(&(bbqs[i]))) > 0) {
lagopus_msg_debug(1, "Got " PFSZS(8, u) " events from the Q"
PFSZS(03, u) ".\n",
(size_t)qsz, (size_t)i);
if ((r = lagopus_bbq_get_n(&(bbqs[i]), (void **)put_dates,
(size_t)nputs, 1LL,
lagopus_chrono_t,
1000LL * 1000LL * 1000LL,
&n_actual_get)) > 0) {
#if 1
WHAT_TIME_IS_IT_NOW_IN_NSEC(p_begin);
#endif
for (j = 0; j < n_actual_get; j++) {
/*
* In this sample, -1LL is kinda 'EOF'. Check if we got
* the EOF.
*/
if (put_dates[j] == -1LL) {
/*
* The queue is kinda 'closed'. From now on we don't
* check this queue anymore. To specify this:
*/
lagopus_msg_debug(1, "Got an EOF from the Q" PFSZS(04, u)
".\n", i);
goto nullify;
}
#if 0
WHAT_TIME_IS_IT_NOW_IN_NSEC(p_begin);
#endif
p_t = p_begin - put_dates[j];
if (p_t < p_min) {
p_min = p_t;
}
if (p_t > p_max) {
p_max = p_t;
}
p_sum += (double)p_t;
p_sum2 += ((double)p_t * (double)p_t);
n_gets++;
}
} else {
/*
* Something wrong for the queue. But we must not exit
* here. Keep on checking other queues. In order to do
* this, set NULL as the queue into the poll object for
* the queue.
*/
lagopus_perror(r);
nullify:
if ((r = lagopus_qmuxer_poll_set_queue(&(polls[i]), NULL)) ==
LAGOPUS_RESULT_OK) {
lagopus_msg_debug(1, "Q" PFSZS(04, u) " is not valid "
"anymore, ignore the queue.\n", i);
break;
} else {
/*
* There is nothing we can do now.
*/
lagopus_perror(r);
goto done;
}
}
}
}
} else if (r == LAGOPUS_RESULT_TIMEDOUT) {
lagopus_msg_debug(1, "Timedout. continue.\n");
continue;
} else {
lagopus_perror(r);
lagopus_msg_debug(1, "Break the loop due to error(s).\n");
goto done;
}
}
ret = 0;
done:
WHAT_TIME_IS_IT_NOW_IN_NSEC(t_end);
if (is_signaled == false) {
fprintf(stdout, "Done.\n");
} else {
fprintf(stdout, "Stopped.\n");
}
fprintf(stdout, "Total # of the events:\t" PFSZS(22, u) "\n\n", n_gets);
p_avg = p_sum / (double)n_gets;
p_sd = (p_sum2 -
2.0 * p_avg * p_sum +
p_avg * p_avg * (double)n_gets) / (double)(n_gets - 1);
p_sd = sqrt(p_sd);
fprintf(stdout, "Queue stats:\n");
fprintf(stdout, "wait time min =\t" PFSZS(22, d) " nsec.\n", p_min);
fprintf(stdout, "wait time max =\t" PFSZS(22, d) " nsec.\n", p_max);
fprintf(stdout, "wait time avg =\t%25.2f nsec.\n", p_avg);
fprintf(stdout, "wait time sd =\t%25.2f.\n\n", p_sd);
t_total = t_end - t_begin;
t_avg = (double)t_total / (double)n_gets;
fprintf(stdout, "Throughput:\n");
fprintf(stdout, "total time:\t" PFSZS(22, d) " msec.\n",
(size_t)(t_total / 1000LL / 1000LL));
fprintf(stdout, "total avg:\t%25.2f nsec/event.\n", t_avg);
s_destroy_all();
free((void *)put_dates);
return ret;
}
static inline lagopus_result_t
s_parse_dryrun(datastore_interp_t *iptr,
datastore_interp_state_t state,
size_t argc, const char *const argv[],
lagopus_hashmap_t *hptr,
datastore_update_proc_t u_proc,
datastore_enable_proc_t e_proc,
datastore_serialize_proc_t s_proc,
datastore_destroy_proc_t d_proc,
lagopus_dstring_t *result) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
size_t i;
(void)iptr;
(void)hptr;
(void)u_proc;
(void)e_proc;
(void)s_proc;
(void)d_proc;
for (i = 0; i < argc; i++) {
lagopus_msg_debug(1, "argv[" PFSZS(4, u) "]:\t'%s'\n", i, argv[i]);
}
if (argc == 1) {
(void)lagopus_dstring_clear(result);
ret = lagopus_dstring_appendf(result,
"{\"ret\":\"OK\",\n"
"\"data\":{\"dryrun\": ");
if (ret == LAGOPUS_RESULT_OK) {
if (state == DATASTORE_INTERP_STATE_DRYRUN) {
ret = lagopus_dstring_appendf(result, "true}}");
} else {
ret = lagopus_dstring_appendf(result, "false}}");
}
if (ret != LAGOPUS_RESULT_OK) {
ret = datastore_json_result_string_setf(result,
LAGOPUS_RESULT_ANY_FAILURES,
"dstring append failed.");
}
} else {
ret = datastore_json_result_string_setf(result,
LAGOPUS_RESULT_ANY_FAILURES,
"dstring append failed.");
}
} else if (argc == 2) {
argv++;
if (strcmp(*argv, "begin") == 0) {
ret = dryrun_begin();
if (ret != LAGOPUS_RESULT_OK) {
ret = datastore_json_result_string_setf(result,
ret,
"dryrun begin failed.");
}
} else if (strcmp(*argv, "end") == 0) {
ret = dryrun_end();
if (ret != LAGOPUS_RESULT_OK) {
ret = datastore_json_result_string_setf(result,
ret,
"dryrun end failed.");
}
} else {
ret = datastore_json_result_string_setf(result,
LAGOPUS_RESULT_INVALID_ARGS,
"Unknown option '%s'.",
*argv);
}
if (ret != LAGOPUS_RESULT_DATASTORE_INTERP_ERROR) {
ret = datastore_json_result_set(result, ret, NULL);
}
} else {
ret = datastore_json_result_string_setf(result,
LAGOPUS_RESULT_INVALID_ARGS,
"Unknown option.");
}
return ret;
}
static lagopus_result_t
s_parse_shutdown(datastore_interp_t *iptr,
datastore_interp_state_t state,
size_t argc, const char *const argv[],
lagopus_hashmap_t *hptr,
datastore_update_proc_t u_proc,
datastore_enable_proc_t e_proc,
datastore_serialize_proc_t s_proc,
datastore_destroy_proc_t d_proc,
lagopus_dstring_t *result) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
size_t i;
(void)state;
(void)argc;
(void)hptr;
(void)u_proc;
(void)e_proc;
(void)s_proc;
(void)d_proc;
(void)result;
for (i = 0; i < argc; i++) {
lagopus_msg_debug(1, "argv[" PFSZS(4, u) "]:\t'%s'\n", i, argv[i]);
}
if (iptr != NULL && argv != NULL && result != NULL) {
argv++;
if (IS_VALID_STRING(*argv) == true) {
if (strcmp(*argv, OPT_GRACE_LEVEL) == 0) {
argv++;
if (IS_VALID_STRING(*argv) == true) {
if (strcmp(*argv, OPT_GRACE_LEVEL_RIGHT_NOW) == 0) {
/* shutdown (right_now) */
s_shutdown(SHUTDOWN_RIGHT_NOW);
ret = LAGOPUS_RESULT_OK;
} else if (strcmp(*argv, OPT_GRACE_LEVEL_GRACEFULLY) == 0) {
/* shutdown (gracefully) */
s_shutdown(SHUTDOWN_GRACEFULLY);
ret = LAGOPUS_RESULT_OK;
} else {
ret = LAGOPUS_RESULT_INVALID_ARGS;
lagopus_msg_warning(
CMD_ERR_MSG_INVALID_OPT_VALUE". (%s)\n",
*argv, lagopus_error_get_string(ret));
}
} else {
if (*argv == NULL) {
ret = LAGOPUS_RESULT_INVALID_ARGS;
lagopus_msg_warning("Bad opt value. (%s)\n",
lagopus_error_get_string(ret));
} else {
ret = LAGOPUS_RESULT_INVALID_ARGS;
lagopus_msg_warning(
CMD_ERR_MSG_INVALID_OPT_VALUE". (%s)\n",
*argv, lagopus_error_get_string(ret));
}
}
} else {
ret = LAGOPUS_RESULT_INVALID_ARGS;
lagopus_msg_warning(
CMD_ERR_MSG_INVALID_OPT". (%s)\n",
*argv, lagopus_error_get_string(ret));
}
} else {
if (*argv == NULL) {
/* shutdown (default) */
s_shutdown(GRACE_LEVEL_DEFAULT);
} else {
ret = LAGOPUS_RESULT_INVALID_ARGS;
lagopus_msg_warning(
CMD_ERR_MSG_INVALID_OPT". (%s)\n",
*argv, lagopus_error_get_string(ret));
}
}
} else {
ret = LAGOPUS_RESULT_INVALID_ARGS;
}
return ret;
}
static inline lagopus_result_t
s_parse_atomic(datastore_interp_t *iptr,
datastore_interp_state_t state,
size_t argc, const char *const argv[],
lagopus_hashmap_t *hptr,
datastore_update_proc_t u_proc,
datastore_enable_proc_t e_proc,
datastore_serialize_proc_t s_proc,
datastore_destroy_proc_t d_proc,
lagopus_dstring_t *result) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
bool is_show = false;
size_t i;
(void)state;
(void)argc;
(void)hptr;
(void)u_proc;
(void)e_proc;
(void)s_proc;
(void)d_proc;
for (i = 0; i < argc; i++) {
lagopus_msg_debug(1, "argv[" PFSZS(4, u) "]:\t'%s'\n", i, argv[i]);
}
argv++;
if (IS_VALID_STRING(*argv) == false) {
return datastore_json_result_set(result,
LAGOPUS_RESULT_OK,
NULL);
} else {
if (strcmp(*argv, "begin") == 0) {
ret = s_parse_begin(iptr, state, argc, argv, &is_show, result);
} else if (strcmp(*argv, "abort") == 0) {
if (state == DATASTORE_INTERP_STATE_DRYRUN) {
ret = LAGOPUS_RESULT_OK;
} else {
ret = datastore_interp_atomic_abort(iptr, result);
}
} else if (strcmp(*argv, "commit") == 0) {
if (state == DATASTORE_INTERP_STATE_DRYRUN) {
ret = LAGOPUS_RESULT_OK;
} else {
ret = datastore_interp_atomic_commit(iptr, result);
}
} else if (strcmp(*argv, "rollback-force") == 0) {
if (state == DATASTORE_INTERP_STATE_DRYRUN) {
ret = LAGOPUS_RESULT_OK;
} else {
ret = datastore_interp_atomic_rollback(iptr, result, true);
}
} else {
return datastore_json_result_string_setf(result,
LAGOPUS_RESULT_INVALID_ARGS,
"Unknown option '%s'",
*argv);
}
if (ret != LAGOPUS_RESULT_DATASTORE_INTERP_ERROR &&
is_show == false) {
ret = datastore_json_result_set(result, ret, NULL);
}
return ret;
}
}
