/* This file is part of TALER Copyright (C) 2014-2017 GNUnet e.V. TALER is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. TALER is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with TALER; see the file COPYING. If not, see */ /** * @file exchangedb/perf_taler_exchangedb_interpreter.c * @brief Interpreter library for exchange database performance analysis * @author Nicolas Fournier */ #include "platform.h" #include "perf_taler_exchangedb_interpreter.h" #include "perf_taler_exchangedb_init.h" #include "gauger.h" /** * Represents the state of the interpreter */ struct PERF_TALER_EXCHANGEDB_interpreter_state { /** * State of the commands */ struct PERF_TALER_EXCHANGEDB_Cmd *cmd; /** * Database plugin */ struct TALER_EXCHANGEDB_Plugin *plugin; /** * Current database session */ struct TALER_EXCHANGEDB_Session *session; /** * The current index of the interpreter */ unsigned int i; }; /** * Free the memory of @a data */ static void data_free (struct PERF_TALER_EXCHANGEDB_Data *data) { switch (data->type) { case PERF_TALER_EXCHANGEDB_TIME: if (NULL == data->data.time) break; GNUNET_free (data->data.time); data->data.time = NULL; break; case PERF_TALER_EXCHANGEDB_DEPOSIT: if (NULL == data->data.deposit) break; PERF_TALER_EXCHANGEDB_deposit_free (data->data.deposit); data->data.deposit = NULL; break; case PERF_TALER_EXCHANGEDB_COIN: if (NULL == data->data.coin) break; GNUNET_free (data->data.coin); data->data.coin = NULL; break; case PERF_TALER_EXCHANGEDB_RESERVE: if (NULL == data->data.reserve) break; PERF_TALER_EXCHANGEDB_reserve_free (data->data.reserve); data->data.reserve = NULL; break; case PERF_TALER_EXCHANGEDB_DENOMINATION_INFO: if (NULL == data->data.dki) break; PERF_TALER_EXCHANGEDB_denomination_free (data->data.dki); data->data.dki = NULL; break; case PERF_TALER_EXCHANGEDB_REFRESH_HASH: break; case PERF_TALER_EXCHANGEDB_NONE: break; } } /** * Copies @a data into @a copy * * @param data the data to be copied * @param[out] copy the copy made */ static void data_copy (const struct PERF_TALER_EXCHANGEDB_Data *data, struct PERF_TALER_EXCHANGEDB_Data *copy) { copy->type = data->type; switch (data->type) { case PERF_TALER_EXCHANGEDB_TIME: copy->data.time = GNUNET_new (struct GNUNET_TIME_Absolute); *copy->data.time = *data->data.time; return; case PERF_TALER_EXCHANGEDB_DEPOSIT: copy->data.deposit = PERF_TALER_EXCHANGEDB_deposit_copy (data->data.deposit); return; case PERF_TALER_EXCHANGEDB_COIN: copy->data.coin = PERF_TALER_EXCHANGEDB_coin_copy (data->data.coin); return; case PERF_TALER_EXCHANGEDB_RESERVE: copy->data.reserve = PERF_TALER_EXCHANGEDB_reserve_copy (data->data.reserve); return; case PERF_TALER_EXCHANGEDB_DENOMINATION_INFO: copy->data.dki = PERF_TALER_EXCHANGEDB_denomination_copy (data->data.dki); return; case PERF_TALER_EXCHANGEDB_REFRESH_HASH: copy->data.rc = data->data.rc; break; case PERF_TALER_EXCHANGEDB_NONE: break; } } /** * Finds the first command in cmd with the name search * * @return the index of the first command with name search * #GNUNET_SYSERR if none found */ static int cmd_find (const struct PERF_TALER_EXCHANGEDB_Cmd *cmd, const char *search) { unsigned int i; for (i=0; PERF_TALER_EXCHANGEDB_CMD_END != cmd[i].command; i++) if (0 == strcmp (cmd[i].label, search)) return i; return GNUNET_SYSERR; } /** * Initialization of a command array * and check for the type of the label * * @param cmd the comand array initialized * @return #GNUNET_OK if the initialization was sucessful * #GNUNET_SYSERR if there was a probleb. See the log for details */ static int cmd_init (struct PERF_TALER_EXCHANGEDB_Cmd cmd[]) { unsigned int i; for (i=0; PERF_TALER_EXCHANGEDB_CMD_END != cmd[i].command; i++) { switch (cmd[i].command) { case PERF_TALER_EXCHANGEDB_CMD_END_LOOP: { int ret; ret = cmd_find (cmd, cmd[i].details.end_loop.label_loop); if (GNUNET_SYSERR == ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Undefined reference to %s\n", i, cmd[i].details.end_loop.label_loop); return GNUNET_SYSERR; } if (PERF_TALER_EXCHANGEDB_CMD_LOOP != cmd[ret].command) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Wrong type reference to %s at %s\n", i, cmd[i].details.end_loop.label_loop, cmd[i].label); return GNUNET_SYSERR; } cmd[i].details.end_loop.index_loop = ret; } break; case PERF_TALER_EXCHANGEDB_CMD_SAVE_ARRAY: { int ret; ret = cmd_find (cmd, cmd[i].details.save_array.label_save); if (GNUNET_SYSERR == ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Undefined reference to %s at %s\n", i, cmd[i].details.save_array.label_save, cmd[i].label); return GNUNET_SYSERR; } if (PERF_TALER_EXCHANGEDB_NONE == cmd[ret].exposed.type) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Wrong type reference to %s at %s\n", i, cmd[i].details.save_array.label_save, cmd[i].label); return GNUNET_SYSERR; } cmd[i].details.save_array.index_save = ret; ret = cmd_find (cmd, cmd[i].details.save_array.label_loop); if (GNUNET_SYSERR == ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Undefined reference to %s at %s\n", i, cmd[i].details.save_array.label_loop, cmd[i].label); return GNUNET_SYSERR; } if (PERF_TALER_EXCHANGEDB_CMD_LOOP != cmd[ret].command) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Wrong type reference to %s at %s\n", i, cmd[i].details.save_array.label_loop, cmd[i].label); return GNUNET_SYSERR; } cmd[i].details.save_array.index_loop = ret; GNUNET_assert (NULL == cmd[i].details.save_array.data_saved); cmd[i].details.save_array.data_saved = GNUNET_new_array (cmd[i].details.save_array.nb_saved, struct PERF_TALER_EXCHANGEDB_Data); cmd[i].details.save_array.type_saved = cmd[cmd[i].details.save_array.index_save].exposed.type; } break; case PERF_TALER_EXCHANGEDB_CMD_LOAD_ARRAY: { int ret; ret = cmd_find (cmd, cmd[i].details.load_array.label_save); if (GNUNET_SYSERR == ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Undefined reference to %s at %s\n", i, cmd[i].details.load_array.label_save, cmd[i].label); return GNUNET_SYSERR; } if (PERF_TALER_EXCHANGEDB_CMD_SAVE_ARRAY != cmd[ret].command) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Wrong type reference to %s at %s\n", i, cmd[i].details.load_array.label_save, cmd[i].label); return GNUNET_SYSERR; } cmd[i].details.load_array.index_save = ret; ret = cmd_find (cmd, cmd[i].details.load_array.label_loop); if (GNUNET_SYSERR == ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Undefined reference to %s\n", i, cmd[i].details.load_array.label_loop); return GNUNET_SYSERR; } if (PERF_TALER_EXCHANGEDB_CMD_LOOP != cmd[ret].command) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Wrong type reference to %s\n", i, cmd[i].details.load_array.label_loop); return GNUNET_SYSERR; } cmd[i].details.load_array.index_loop = ret; cmd[i].details.load_array.permutation = GNUNET_CRYPTO_random_permute ( GNUNET_CRYPTO_QUALITY_WEAK, cmd[cmd[i].details.load_array.index_save].details.save_array.nb_saved); GNUNET_assert (NULL != cmd[i].details.load_array.permutation); cmd[i].exposed.type = cmd[cmd[i].details.load_array.index_save].details.save_array.type_saved; } break; case PERF_TALER_EXCHANGEDB_CMD_LOAD_RANDOM: { int ret; ret = cmd_find (cmd, cmd[i].details.load_random.label_save); if (GNUNET_SYSERR == ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Undefined reference to %s\n", i, cmd[i].details.load_random.label_save); return GNUNET_SYSERR; } if (PERF_TALER_EXCHANGEDB_CMD_SAVE_ARRAY != cmd[ret].command) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Wrong type reference to %s\n", i, cmd[i].details.load_random.label_save); return GNUNET_SYSERR; } cmd[i].details.load_random.index_save = ret; } break; case PERF_TALER_EXCHANGEDB_CMD_GAUGER: { int ret; ret = cmd_find (cmd, cmd[i].details.gauger.label_start); if (GNUNET_SYSERR == ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Undefined reference to %s\n", i, cmd[i].details.gauger.label_start); return GNUNET_SYSERR; } if (PERF_TALER_EXCHANGEDB_TIME != cmd[ret].exposed.type) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Wrong type reference to %s\n", i, cmd[i].details.gauger.label_start); return GNUNET_SYSERR; } cmd[i].details.gauger.index_start = ret; ret = cmd_find (cmd, cmd[i].details.gauger.label_stop); if (GNUNET_SYSERR == ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Undefined reference to %s\n", i, cmd[i].details.gauger.label_stop); return GNUNET_SYSERR; } if (PERF_TALER_EXCHANGEDB_TIME != cmd[ret].exposed.type) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Wrong type reference to %s\n", i, cmd[i].details.gauger.label_stop); return GNUNET_SYSERR; } cmd[i].details.gauger.index_stop = ret; } break; case PERF_TALER_EXCHANGEDB_CMD_INSERT_DENOMINATION: { int ret; ret = cmd_find (cmd, cmd[i].details.insert_denomination.label_denom); if (GNUNET_SYSERR == ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Undefined reference to %s\n", i, cmd[i].details.insert_denomination.label_denom); return GNUNET_SYSERR; } if (PERF_TALER_EXCHANGEDB_DENOMINATION_INFO != cmd[ret].exposed.type) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Wrong type reference to %s\n", i, cmd[i].details.insert_denomination.label_denom); return GNUNET_SYSERR; } cmd[i].details.insert_denomination.index_denom = ret; } break; case PERF_TALER_EXCHANGEDB_CMD_GET_DENOMINATION: { int ret; ret = cmd_find (cmd, cmd[i].details.get_denomination.label_denom); if (GNUNET_SYSERR == ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Undefined reference to %s\n", i, cmd[i].details.get_denomination.label_denom); return GNUNET_SYSERR; } if (PERF_TALER_EXCHANGEDB_DENOMINATION_INFO != cmd[ret].exposed.type) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Wrong type reference to %s\n", i, cmd[i].details.get_denomination.label_denom); return GNUNET_SYSERR; } cmd[i].details.get_denomination.index_denom = ret; } break; case PERF_TALER_EXCHANGEDB_CMD_INSERT_RESERVE: { int ret; ret = cmd_find (cmd, cmd[i].details.insert_reserve.label_reserve); if (GNUNET_SYSERR == ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Undefined reference to %s\n", i, cmd[i].details.insert_reserve.label_reserve); return GNUNET_SYSERR; } if (PERF_TALER_EXCHANGEDB_RESERVE != cmd[ret].exposed.type) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Wrong type reference to %s\n", i, cmd[i].details.insert_reserve.label_reserve); return GNUNET_SYSERR; } cmd[i].details.insert_reserve.index_reserve = ret; } break; case PERF_TALER_EXCHANGEDB_CMD_GET_RESERVE: { int ret; ret = cmd_find (cmd, cmd[i].details.get_reserve.label_reserve); if (GNUNET_SYSERR == ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Undefined reference to %s\n", i, cmd[i].details.get_reserve.label_reserve); return GNUNET_SYSERR; } if (PERF_TALER_EXCHANGEDB_RESERVE != cmd[ret].exposed.type) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Wrong type reference to %s\n", i, cmd[i].details.get_reserve.label_reserve); return GNUNET_SYSERR; } cmd[i].details.get_reserve.index_reserve = ret; } break; case PERF_TALER_EXCHANGEDB_CMD_GET_RESERVE_HISTORY: { int ret; ret = cmd_find (cmd, cmd[i].details.get_reserve_history.label_reserve); if (GNUNET_SYSERR == ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Undefined reference to %s\n", i, cmd[i].details.get_reserve_history.label_reserve); return GNUNET_SYSERR; } if (PERF_TALER_EXCHANGEDB_RESERVE != cmd[ret].exposed.type) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Wrong type reference to %s\n", i, cmd[i].details.get_reserve_history.label_reserve); return GNUNET_SYSERR; } cmd[i].details.get_reserve_history.index_reserve = ret; } break; case PERF_TALER_EXCHANGEDB_CMD_CREATE_WITHDRAW: { int ret; ret = cmd_find (cmd, cmd[i].details.create_withdraw.label_dki); { if (GNUNET_SYSERR == ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Undefined reference to %s\n", i, cmd[i].details.create_withdraw.label_dki); return GNUNET_SYSERR; } if (PERF_TALER_EXCHANGEDB_DENOMINATION_INFO != cmd[ret].exposed.type) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Wrong type reference to %s\n", i, cmd[i].details.create_withdraw.label_dki); return GNUNET_SYSERR; } } cmd[i].details.create_withdraw.index_dki = ret; ret = cmd_find (cmd, cmd[i].details.create_withdraw.label_reserve); { if (GNUNET_SYSERR == ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Undefined reference to %s\n", i, cmd[i].details.create_withdraw.label_reserve); return GNUNET_SYSERR; } if (PERF_TALER_EXCHANGEDB_RESERVE != cmd[ret].exposed.type) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Wrong type reference to %s\n", i, cmd[i].details.create_withdraw.label_reserve); return GNUNET_SYSERR; } } cmd[i].details.create_withdraw.index_reserve = ret; } break; case PERF_TALER_EXCHANGEDB_CMD_INSERT_WITHDRAW: { int ret; ret = cmd_find (cmd, cmd[i].details.insert_withdraw.label_coin); if (GNUNET_SYSERR == ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Undefined reference to %s\n", i, cmd[i].details.insert_withdraw.label_coin); return GNUNET_SYSERR; } if (PERF_TALER_EXCHANGEDB_COIN != cmd[ret].exposed.type) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Wrong type reference to %s\n", i, cmd[i].details.insert_withdraw.label_coin); return GNUNET_SYSERR; } cmd[i].details.insert_withdraw.index_coin = ret; } break; case PERF_TALER_EXCHANGEDB_CMD_GET_WITHDRAW: { int ret; ret = cmd_find (cmd, cmd[i].details.get_withdraw.label_coin); if (GNUNET_SYSERR == ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Undefined reference to %s\n", i, cmd[i].details.get_withdraw.label_coin); return GNUNET_SYSERR; } if (PERF_TALER_EXCHANGEDB_COIN != cmd[ret].exposed.type) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Wrong type reference to %s\n", i, cmd[i].details.get_withdraw.label_coin); return GNUNET_SYSERR; } cmd[i].details.get_withdraw.index_coin = ret; } break; case PERF_TALER_EXCHANGEDB_CMD_GET_COIN_TRANSACTION: { int ret; ret = cmd_find (cmd, cmd[i].details.get_coin_transaction.label_coin); if (GNUNET_SYSERR == ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Undefined reference to %s\n", i, cmd[i].details.get_coin_transaction.label_coin); return GNUNET_SYSERR; } if (PERF_TALER_EXCHANGEDB_COIN != cmd[ret].exposed.type) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Wrong type reference to %s\n", i, cmd[i].details.get_coin_transaction.label_coin); return GNUNET_SYSERR; } cmd[i].details.get_coin_transaction.index_coin = ret; } break; case PERF_TALER_EXCHANGEDB_CMD_CREATE_DEPOSIT: { int ret; ret = cmd_find (cmd, cmd[i].details.create_deposit.label_coin); if (GNUNET_SYSERR == ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Undefined reference to %s\n", i, cmd[i].details.create_deposit.label_coin); return GNUNET_SYSERR; } if (PERF_TALER_EXCHANGEDB_COIN != cmd[ret].exposed.type) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Wrong type reference to %s\n", i, cmd[i].details.create_deposit.label_coin); return GNUNET_SYSERR; } cmd[i].details.create_deposit.index_coin = ret; } break; case PERF_TALER_EXCHANGEDB_CMD_INSERT_DEPOSIT: { int ret; ret = cmd_find( cmd, cmd[i].details.insert_deposit.label_deposit); if (GNUNET_SYSERR == ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Undefined reference to %s\n", i, cmd[i].details.insert_deposit.label_deposit); return GNUNET_SYSERR; } if (PERF_TALER_EXCHANGEDB_DEPOSIT != cmd[ret].exposed.type) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Wrong type reference to %s\n", i, cmd[i].details.insert_deposit.label_deposit); return GNUNET_SYSERR; } cmd[i].details.insert_deposit.index_deposit = ret; } break; case PERF_TALER_EXCHANGEDB_CMD_GET_DEPOSIT: { int ret; ret = cmd_find (cmd, cmd[i].details.get_deposit.label_deposit); if (GNUNET_SYSERR == ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Undefined reference to %s\n", i, cmd[i].details.get_deposit.label_deposit); return GNUNET_SYSERR; } if (PERF_TALER_EXCHANGEDB_DEPOSIT != cmd[ret].exposed.type) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Wrong type reference to %s\n", i, cmd[i].details.get_deposit.label_deposit); return GNUNET_SYSERR; } cmd[i].details.get_deposit.index_deposit = ret; } break; case PERF_TALER_EXCHANGEDB_CMD_CREATE_REFRESH_SESSION: { int ret; ret = cmd_find (cmd, cmd[i].details.create_refresh_session.label_coin); if (GNUNET_SYSERR == ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Undefined reference to %s at %s\n", i, cmd[i].details.create_refresh_session.label_coin, cmd[i].label); return GNUNET_SYSERR; } if (PERF_TALER_EXCHANGEDB_COIN != cmd[ret].exposed.type) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Wrong type reference to %s at %s\n", i, cmd[i].details.create_refresh_session.label_coin, cmd[i].label); return GNUNET_SYSERR; } cmd[i].details.create_refresh_session.index_coin = ret; } break; case PERF_TALER_EXCHANGEDB_CMD_GET_REFRESH_SESSION: { int ret; ret = cmd_find (cmd, cmd[i].details.get_refresh_session.label_hash); if (GNUNET_SYSERR == ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Undefined reference to %s at %s\n", i, cmd[i].details.get_refresh_session.label_hash, cmd[i].label); return GNUNET_SYSERR; } if (PERF_TALER_EXCHANGEDB_REFRESH_HASH != cmd[ret].exposed.type) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Wrong type reference to %s at %s\n", i, cmd[i].details.get_refresh_session.label_hash, cmd[i].label); return GNUNET_SYSERR; } cmd[i].details.get_refresh_session.index_hash = ret; } break; case PERF_TALER_EXCHANGEDB_CMD_INSERT_REFRESH_REVEAL: { int ret; ret = cmd_find (cmd, cmd[i].details.insert_refresh_reveal.label_hash); if (GNUNET_SYSERR == ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Undefined reference to %s\n", i, cmd[i].details.insert_refresh_reveal.label_hash); return GNUNET_SYSERR; } if (PERF_TALER_EXCHANGEDB_REFRESH_HASH != cmd[ret].exposed.type) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Wrong type reference to %s\n", i, cmd[i].details.insert_refresh_reveal.label_hash); return GNUNET_SYSERR; } cmd[i].details.insert_refresh_reveal.index_hash = ret; ret = cmd_find (cmd, cmd[i].details.insert_refresh_reveal.label_denom); if (GNUNET_SYSERR == ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Undefined reference to %s\n", i, cmd[i].details.insert_refresh_reveal.label_denom); return GNUNET_SYSERR; } if (PERF_TALER_EXCHANGEDB_DENOMINATION_INFO != cmd[ret].exposed.type) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Wrong type reference to %s\n", i, cmd[i].details.insert_refresh_reveal.label_denom); return GNUNET_SYSERR; } cmd[i].details.insert_refresh_reveal.index_denom = ret; } break; case PERF_TALER_EXCHANGEDB_CMD_GET_REFRESH_REVEAL: { int ret; ret = cmd_find (cmd, cmd[i].details.get_refresh_reveal.label_hash); if (GNUNET_SYSERR == ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Undefined reference to %s\n", i, cmd[i].details.get_refresh_reveal.label_hash); return GNUNET_SYSERR; } if (PERF_TALER_EXCHANGEDB_REFRESH_HASH != cmd[ret].exposed.type) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Wrong type reference to %s\n", i, cmd[i].details.get_refresh_reveal.label_hash); return GNUNET_SYSERR; } cmd[i].details.get_refresh_reveal.index_hash = ret; } break; case PERF_TALER_EXCHANGEDB_CMD_GET_LINK_DATA: { int ret; ret = cmd_find (cmd, cmd[i].details.get_link_data_list.label_hash); if (GNUNET_SYSERR == ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Undefined reference to %s\n", i, cmd[i].details.get_link_data_list.label_hash); return GNUNET_SYSERR; } if (PERF_TALER_EXCHANGEDB_REFRESH_HASH != cmd[ret].exposed.type) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%d:Wrong type reference to %s\n", i, cmd[i].details.get_link_data_list.label_hash); return GNUNET_SYSERR; } cmd[i].details.get_link_data_list.index_hash = ret; } break; case PERF_TALER_EXCHANGEDB_CMD_END: case PERF_TALER_EXCHANGEDB_CMD_DEBUG: case PERF_TALER_EXCHANGEDB_CMD_LOOP: case PERF_TALER_EXCHANGEDB_CMD_NEW_SESSION: case PERF_TALER_EXCHANGEDB_CMD_START_TRANSACTION: case PERF_TALER_EXCHANGEDB_CMD_COMMIT_TRANSACTION: case PERF_TALER_EXCHANGEDB_CMD_ABORT_TRANSACTION: case PERF_TALER_EXCHANGEDB_CMD_GET_TIME: case PERF_TALER_EXCHANGEDB_CMD_CREATE_DENOMINATION: case PERF_TALER_EXCHANGEDB_CMD_CREATE_RESERVE: break; } } return GNUNET_OK; } /** * Free the memory of the command chain */ static int cmd_clean (struct PERF_TALER_EXCHANGEDB_Cmd cmd[]) { unsigned int i; for (i=0; PERF_TALER_EXCHANGEDB_CMD_END != cmd[i].command; i++) { switch (cmd[i].command) { case PERF_TALER_EXCHANGEDB_CMD_SAVE_ARRAY: { unsigned int j; for (j = 0; j < cmd[i].details.save_array.nb_saved; j++) { data_free (&cmd[i].details.save_array.data_saved[j]); } GNUNET_free (cmd[i].details.save_array.data_saved); cmd[i].details.save_array.data_saved = NULL; } break; case PERF_TALER_EXCHANGEDB_CMD_LOAD_ARRAY: GNUNET_free (cmd[i].details.load_array.permutation); cmd[i].details.load_array.permutation = NULL; break; default: break; } data_free (&cmd[i].exposed); } return GNUNET_OK; } /** * Handles the command #PERF_TALER_EXCHANGEDB_CMD_END_LOOP for the interpreter * Cleans the memory at the end of the loop */ static void interpret_end_loop (struct PERF_TALER_EXCHANGEDB_interpreter_state *state) { int jump; jump = state->cmd[state->i].details.end_loop.index_loop; // Cleaning up the memory in the loop for (unsigned int i = jump; i < state->i; i++) data_free (&state->cmd[i].exposed); state->cmd[jump].details.loop.curr_iteration++; /* If the loop is not finished */ if (state->cmd[jump].details.loop.max_iterations > state->cmd[jump].details.loop.curr_iteration) { /* jump back to the start */ state->i = jump; } else { /* Reset the loop counter and continue running */ state->cmd[jump].details.loop.curr_iteration = 0; } } /** * Part of the interpreter specific to * #PERF_TALER_EXCHANGEDB_CMD_SAVE_ARRAY * Saves the data exposed by another command into * an array in the command specific struct. */ static void interpret_save_array (struct PERF_TALER_EXCHANGEDB_interpreter_state *state) { struct PERF_TALER_EXCHANGEDB_Cmd *cmd = &state->cmd[state->i]; struct PERF_TALER_EXCHANGEDB_Cmd *save_ref; struct PERF_TALER_EXCHANGEDB_Cmd *loop_ref; int loop_index; int save_index; unsigned int selection_chance; loop_index = cmd->details.save_array.index_loop; save_index = cmd->details.save_array.index_save; loop_ref = &state->cmd[loop_index]; save_ref = &state->cmd[save_index]; /* Array initialization on first loop iteration Alows for nested loops */ if (0 == cmd->details.loop.curr_iteration) { cmd->details.save_array.index = 0; } /* The probability distribution of the saved items will be a little biased against the few last items but it should not be a big problem. */ selection_chance = loop_ref->details.loop.max_iterations / cmd->details.save_array.nb_saved; /* * If the remaining space is equal to the remaining number of * iterations, the item is automaticly saved. * * Else it is saved only if the random numbre generated is 0 */ if ( (0 < (cmd->details.save_array.nb_saved - cmd->details.save_array.index) ) && ( ((loop_ref->details.loop.max_iterations - loop_ref->details.loop.curr_iteration) == (cmd->details.save_array.nb_saved - cmd->details.save_array.index)) || (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, selection_chance)) ) ) { struct PERF_TALER_EXCHANGEDB_Data *save_location; struct PERF_TALER_EXCHANGEDB_Data *item_saved; save_location = &cmd->details.save_array.data_saved[cmd->details.save_array.index]; item_saved = &save_ref->exposed; data_copy (item_saved, save_location); cmd->details.save_array.index++; } } /** * Part of the interpreter specific to * #PERF_TALER_EXCHANGEDB_CMD_LOAD_ARRAY * Gets data from a #PERF_TALER_EXCHANGEDB_CMD_SAVE_ARRAY and exposes a copy */ static void interpret_load_array (struct PERF_TALER_EXCHANGEDB_interpreter_state *state) { struct PERF_TALER_EXCHANGEDB_Cmd *cmd = &state->cmd[state->i]; unsigned int loop_iter; int loop_index; int save_index; struct PERF_TALER_EXCHANGEDB_Data *loaded_data; loop_index = cmd->details.load_array.index_loop; save_index = cmd->details.load_array.index_save; loop_iter = state->cmd[loop_index].details.loop.curr_iteration; { unsigned int i; unsigned int quotient; /* In case the iteration number is higher than the amount saved, * the number is run several times in the permutation array */ quotient = loop_iter / state->cmd[save_index].details.save_array.nb_saved; loop_iter = loop_iter % state->cmd[save_index].details.save_array.nb_saved; for (i=0; i<=quotient; i++) loop_iter = cmd->details.load_array.permutation[loop_iter]; } /* Extracting the data from the loop_indexth indice in save_index * array. */ loaded_data = &state->cmd[save_index].details.save_array.data_saved[loop_iter]; data_copy (loaded_data, &cmd->exposed); } /** * Part of the interpreter specific to * #PERF_TALER_EXCHANGEDB_CMD_LOAD_RANDOM * Get a random element from a #PERF_TALER_EXCHANGEDB_CMD_SAVE_ARRAY and exposes it */ static void interprete_load_random (struct PERF_TALER_EXCHANGEDB_interpreter_state *state) { struct PERF_TALER_EXCHANGEDB_Cmd *cmd = &state->cmd[state->i]; unsigned int index; int save_index; save_index = cmd->details.load_random.index_save; index = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, state->cmd[save_index].details.save_array.nb_saved); data_copy (&state->cmd[save_index].details.save_array.data_saved[index], &cmd->exposed); } /** * Function called with information about a refresh order. * * @param cls closure * @param rowid unique serial ID for the row in our database * @param num_newcoins size of the @a rrcs array * @param rrcs array of @a num_newcoins information about coins to be created * @param num_tprivs number of entries in @a tprivs, should be #TALER_CNC_KAPPA - 1 * @param tprivs array of @e num_tprivs transfer private keys * @param tp transfer public key information */ static void refresh_reveal_cb (void *cls, uint32_t num_newcoins, const struct TALER_EXCHANGEDB_RefreshRevealedCoin *rrcs, unsigned int num_tprivs, const struct TALER_TransferPrivateKeyP *tprivs, const struct TALER_TransferPublicKeyP *tp) { /* intentionally empty */ } /** * Iterate over the commands, acting accordingly at each step * * @param state the current state of the interpreter */ static int interpret (struct PERF_TALER_EXCHANGEDB_interpreter_state *state) { for (state->i=0; PERF_TALER_EXCHANGEDB_CMD_END != state->cmd[state->i].command; state->i++) { switch (state->cmd[state->i].command) { case PERF_TALER_EXCHANGEDB_CMD_END: return GNUNET_YES; case PERF_TALER_EXCHANGEDB_CMD_DEBUG: GNUNET_log (GNUNET_ERROR_TYPE_INFO, "%s\n", state->cmd[state->i].label); break; case PERF_TALER_EXCHANGEDB_CMD_LOOP: break; case PERF_TALER_EXCHANGEDB_CMD_END_LOOP: interpret_end_loop (state); break; case PERF_TALER_EXCHANGEDB_CMD_GET_TIME: state->cmd[state->i].exposed.data.time = GNUNET_new (struct GNUNET_TIME_Absolute); *state->cmd[state->i].exposed.data.time = GNUNET_TIME_absolute_get (); break; case PERF_TALER_EXCHANGEDB_CMD_GAUGER: { unsigned int start_index; unsigned int stop_index; float ips; struct GNUNET_TIME_Absolute start; struct GNUNET_TIME_Absolute stop; struct GNUNET_TIME_Relative elapsed; start_index = state->cmd[state->i].details.gauger.index_start; stop_index = state->cmd[state->i].details.gauger.index_stop; start = *state->cmd[start_index].exposed.data.time; stop = *state->cmd[stop_index].exposed.data.time; elapsed = GNUNET_TIME_absolute_get_difference (start, stop); ips = (1.0 * state->cmd[state->i].details.gauger.divide) / (elapsed.rel_value_us/1000000.0); GAUGER (state->cmd[state->i].details.gauger.category, state->cmd[state->i].details.gauger.description, ips, state->cmd[state->i].details.gauger.unit); } break; case PERF_TALER_EXCHANGEDB_CMD_NEW_SESSION: state->session = state->plugin->get_session (state->plugin->cls); break; case PERF_TALER_EXCHANGEDB_CMD_START_TRANSACTION: GNUNET_break (GNUNET_OK == state->plugin->start (state->plugin->cls, state->session, "perf-interpreter")); break; case PERF_TALER_EXCHANGEDB_CMD_COMMIT_TRANSACTION: GNUNET_break (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS == state->plugin->commit (state->plugin->cls, state->session)); break; case PERF_TALER_EXCHANGEDB_CMD_ABORT_TRANSACTION: state->plugin->rollback (state->plugin->cls, state->session); break; case PERF_TALER_EXCHANGEDB_CMD_SAVE_ARRAY: interpret_save_array (state); break; case PERF_TALER_EXCHANGEDB_CMD_LOAD_ARRAY: interpret_load_array (state); break; case PERF_TALER_EXCHANGEDB_CMD_LOAD_RANDOM: interprete_load_random (state); break; case PERF_TALER_EXCHANGEDB_CMD_CREATE_DEPOSIT: { int coin_index; struct TALER_EXCHANGEDB_Deposit *deposit; coin_index = state->cmd[state->i].details.create_deposit.index_coin; deposit = PERF_TALER_EXCHANGEDB_deposit_init (state->cmd[coin_index].exposed.data.coin); GNUNET_assert (NULL != deposit); state->cmd[state->i].exposed.data.deposit = deposit; } break; case PERF_TALER_EXCHANGEDB_CMD_INSERT_DEPOSIT: { int deposit_index; enum GNUNET_DB_QueryStatus qs; struct TALER_EXCHANGEDB_Deposit *deposit; deposit_index = state->cmd[state->i].details.insert_deposit.index_deposit; deposit = state->cmd[deposit_index].exposed.data.deposit; qs = state->plugin->ensure_coin_known (state->plugin->cls, state->session, &deposit->coin); GNUNET_assert (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT == qs); qs = state->plugin->insert_deposit (state->plugin->cls, state->session, deposit); GNUNET_assert (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT == qs); state->cmd[state->i].exposed.data.deposit = PERF_TALER_EXCHANGEDB_deposit_copy (deposit); } break; case PERF_TALER_EXCHANGEDB_CMD_GET_DEPOSIT: { unsigned int source_index; enum GNUNET_DB_QueryStatus ret; struct PERF_TALER_EXCHANGEDB_Data *data; source_index = state->cmd[state->i].details.get_deposit.index_deposit; data = &state->cmd[source_index].exposed; ret = state->plugin->have_deposit (state->plugin->cls, state->session, data->data.deposit); GNUNET_assert (0 >= ret); } break; case PERF_TALER_EXCHANGEDB_CMD_CREATE_RESERVE: { struct PERF_TALER_EXCHANGEDB_Reserve *reserve; reserve = PERF_TALER_EXCHANGEDB_reserve_init (); state->cmd[state->i].exposed.data.reserve = reserve; } break; case PERF_TALER_EXCHANGEDB_CMD_INSERT_RESERVE: { unsigned int reserve_index; int ret; struct PERF_TALER_EXCHANGEDB_Reserve *reserve; char *sndr; uint32_t uid; struct GNUNET_TIME_Absolute now; reserve_index = state->cmd[state->i].details.insert_reserve.index_reserve; reserve = state->cmd[reserve_index].exposed.data.reserve; GNUNET_asprintf (&sndr, "payto://x-taler-test/localhost:8080/%u", (unsigned int) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, UINT32_MAX)); uid = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, UINT32_MAX); now = GNUNET_TIME_absolute_get (); (void) GNUNET_TIME_round_abs (&now); ret = state->plugin->reserves_in_insert (state->plugin->cls, state->session, &reserve->reserve.pub, &reserve->reserve.balance, now, sndr, "account-1", &uid, sizeof (uid)); GNUNET_assert (GNUNET_SYSERR != ret); GNUNET_free (sndr); } break; case PERF_TALER_EXCHANGEDB_CMD_GET_RESERVE: { unsigned int reserve_index; int ret; struct PERF_TALER_EXCHANGEDB_Data *data; reserve_index = state->cmd[state->i].details.get_reserve.index_reserve; data = &state->cmd[reserve_index].exposed; ret = state->plugin->reserve_get (state->plugin->cls, state->session, &data->data.reserve->reserve); GNUNET_assert (GNUNET_OK == ret); } break; case PERF_TALER_EXCHANGEDB_CMD_GET_RESERVE_HISTORY: { unsigned int reserve_index; struct TALER_EXCHANGEDB_ReserveHistory *history; struct PERF_TALER_EXCHANGEDB_Data *data; enum GNUNET_DB_QueryStatus qs; reserve_index = state->cmd[state->i].details.get_reserve_history.index_reserve; data = &state->cmd[reserve_index].exposed; qs = state->plugin->get_reserve_history (state->plugin->cls, state->session, &data->data.reserve->reserve.pub, &history); GNUNET_assert (0 >= qs); GNUNET_assert (NULL != history); state->plugin->free_reserve_history (state->plugin->cls, history); } break; case PERF_TALER_EXCHANGEDB_CMD_CREATE_DENOMINATION: { struct TALER_EXCHANGEDB_DenominationKeyIssueInformation *dki = PERF_TALER_EXCHANGEDB_denomination_init (); GNUNET_assert (NULL != dki); state->cmd[state->i].exposed.data.dki = dki; } break; case PERF_TALER_EXCHANGEDB_CMD_INSERT_DENOMINATION: { unsigned int denom_index; enum GNUNET_DB_QueryStatus ret; struct TALER_EXCHANGEDB_DenominationKeyIssueInformation *dki ; denom_index = state->cmd[state->i].details.insert_denomination.index_denom; dki = state->cmd[denom_index].exposed.data.dki; ret = state->plugin->insert_denomination_info (state->plugin->cls, state->session, &dki->denom_pub, &dki->issue); GNUNET_assert (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT == ret); } break; case PERF_TALER_EXCHANGEDB_CMD_GET_DENOMINATION: { unsigned int denom_index; enum GNUNET_DB_QueryStatus qs; struct PERF_TALER_EXCHANGEDB_Data *data; denom_index = state->cmd[state->i].details.get_denomination.index_denom; data = &state->cmd[denom_index].exposed; qs = state->plugin->get_denomination_info (state->plugin->cls, state->session, &data->data.dki->denom_pub, &data->data.dki->issue); GNUNET_assert (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT == qs); } break; case PERF_TALER_EXCHANGEDB_CMD_CREATE_WITHDRAW: { unsigned int dki_index; unsigned int reserve_index; struct PERF_TALER_EXCHANGEDB_Coin *coin; dki_index = state->cmd[state->i].details.create_withdraw.index_dki; reserve_index = state->cmd[state->i].details.create_withdraw.index_reserve; coin = PERF_TALER_EXCHANGEDB_coin_init (state->cmd[dki_index].exposed.data.dki, state->cmd[reserve_index].exposed.data.reserve); GNUNET_assert (NULL != coin); state->cmd[state->i].exposed.data.coin = coin; } break; case PERF_TALER_EXCHANGEDB_CMD_INSERT_WITHDRAW: { unsigned int coin_index; enum GNUNET_DB_QueryStatus qs; struct PERF_TALER_EXCHANGEDB_Coin *coin; coin_index = state->cmd[state->i].details.insert_withdraw.index_coin; coin = state->cmd[coin_index].exposed.data.coin; qs = state->plugin->insert_withdraw_info (state->plugin->cls, state->session, &coin->blind); GNUNET_assert (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT == qs); } break; case PERF_TALER_EXCHANGEDB_CMD_GET_WITHDRAW: { unsigned int source_index; enum GNUNET_DB_QueryStatus qs; struct PERF_TALER_EXCHANGEDB_Data *data; source_index = state->cmd[state->i].details.get_denomination.index_denom; data = &state->cmd[source_index].exposed; qs = state->plugin->get_withdraw_info (state->plugin->cls, state->session, &data->data.coin->blind.h_coin_envelope, &data->data.coin->blind); GNUNET_assert (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT == qs); } break; case PERF_TALER_EXCHANGEDB_CMD_GET_COIN_TRANSACTION: { unsigned int coin_index; struct PERF_TALER_EXCHANGEDB_Coin *coin; struct TALER_EXCHANGEDB_TransactionList *transactions; enum GNUNET_DB_QueryStatus qs; coin_index = state->cmd[state->i].details.get_coin_transaction.index_coin; coin = state->cmd[coin_index].exposed.data.coin; qs = state->plugin->get_coin_transactions (state->plugin->cls, state->session, &coin->public_info.coin_pub, &transactions); GNUNET_assert (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT == qs); GNUNET_assert (transactions != NULL); state->plugin->free_coin_transaction_list (state->plugin->cls, transactions); } break; case PERF_TALER_EXCHANGEDB_CMD_CREATE_REFRESH_SESSION: { struct TALER_EXCHANGEDB_RefreshSession refresh_session; unsigned int coin_index; struct PERF_TALER_EXCHANGEDB_Coin *coin; coin_index = state->cmd[state->i].details.create_refresh_session.index_coin; coin = state->cmd[coin_index].exposed.data.coin; refresh_session.coin = coin->public_info; GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, &refresh_session.coin_sig, sizeof (refresh_session.coin_sig)); GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &refresh_session.rc.session_hash); GNUNET_assert (GNUNET_OK == TALER_string_to_amount (CURRENCY ":1.1", &refresh_session.amount_with_fee)); refresh_session.noreveal_index = 1; GNUNET_assert (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT == state->plugin->ensure_coin_known (state->plugin->cls, state->session, &refresh_session.coin)); GNUNET_assert (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT == state->plugin->insert_melt (state->plugin->cls, state->session, &refresh_session)); state->cmd[state->i].exposed.data.rc = refresh_session.rc; } break; case PERF_TALER_EXCHANGEDB_CMD_GET_REFRESH_SESSION: { unsigned int hash_index; const struct TALER_RefreshCommitmentP *rc; struct TALER_EXCHANGEDB_RefreshMelt refresh; hash_index = state->cmd[state->i].details.get_refresh_session.index_hash; rc = &state->cmd[hash_index].exposed.data.rc; state->plugin->get_melt (state->plugin->cls, state->session, rc, &refresh); } break; case PERF_TALER_EXCHANGEDB_CMD_INSERT_REFRESH_REVEAL: { unsigned int hash_index; unsigned int denom_index; const struct TALER_RefreshCommitmentP *rc; struct TALER_EXCHANGEDB_DenominationKeyIssueInformation *denom; struct TALER_TransferPublicKeyP tpub; struct TALER_TransferPrivateKeyP tprivs[2]; struct TALER_EXCHANGEDB_RefreshRevealedCoin rrc; hash_index = state->cmd[state->i].details.insert_refresh_reveal.index_hash; denom_index = state->cmd[state->i].details.insert_refresh_reveal.index_denom; rc = &state->cmd[hash_index].exposed.data.rc; denom = state->cmd[denom_index].exposed.data.dki; rrc.denom_pub = denom->denom_pub; rrc.coin_ev = "coin_ev"; rrc.coin_ev_size = strlen (rrc.coin_ev) + 1; GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, &rrc.coin_sig, sizeof (struct TALER_CoinSpendSignatureP)); GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, tprivs, sizeof (struct TALER_TransferPrivateKeyP) * 2); GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, &tpub, sizeof (struct TALER_TransferPublicKeyP)); GNUNET_assert (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT == state->plugin->insert_refresh_reveal (state->plugin->cls, state->session, rc, 1, &rrc, 2, tprivs, &tpub)); } break; case PERF_TALER_EXCHANGEDB_CMD_GET_REFRESH_REVEAL: { int hash_index; const struct TALER_RefreshCommitmentP *rc; hash_index = state->cmd[state->i].details.get_refresh_reveal.index_hash; rc = &state->cmd[hash_index].exposed.data.rc; state->plugin->get_refresh_reveal (state->plugin->cls, state->session, rc, &refresh_reveal_cb, state); } break; case PERF_TALER_EXCHANGEDB_CMD_GET_LINK_DATA: break; } } return GNUNET_OK; } /** * Runs the commands given in @a cmd, working with * the database referenced by @a db_plugin * * @param db_plugin the connection to the database * @param cmd the commands to run */ int PERF_TALER_EXCHANGEDB_interpret (struct TALER_EXCHANGEDB_Plugin *db_plugin, struct PERF_TALER_EXCHANGEDB_Cmd cmd[]) { int ret; struct PERF_TALER_EXCHANGEDB_interpreter_state state = {.i = 0, .cmd = cmd, .plugin = db_plugin}; ret = cmd_init (cmd); if (GNUNET_SYSERR == ret) return ret; state.session = db_plugin->get_session (db_plugin->cls); if (NULL == state.session) return GNUNET_SYSERR; GNUNET_assert (NULL != state.session); ret = interpret (&state); cmd_clean (cmd); return ret; } /** * Initialize the database and run the benchmark * * @param benchmark_name the name of the benchmark, displayed in the logs * @param configuration_file path to the taler configuration file to use * @param init the commands to use for the database initialisation, * if #NULL the standard initialization is used * @param benchmark the commands for the benchmark * @return #GNUNET_OK upon success; #GNUNET_SYSERR upon failure, #GNUNET_NO * if we failed to init the database */ int PERF_TALER_EXCHANGEDB_run_benchmark (const char *benchmark_name, const char *configuration_file, struct PERF_TALER_EXCHANGEDB_Cmd *init, struct PERF_TALER_EXCHANGEDB_Cmd *benchmark) { struct TALER_EXCHANGEDB_Plugin *plugin; struct GNUNET_CONFIGURATION_Handle *config; int ret = 0; struct PERF_TALER_EXCHANGEDB_Cmd init_def[] = { // Denomination used to create coins PERF_TALER_EXCHANGEDB_INIT_CMD_DEBUG ("00 - Start of interpreter"), PERF_TALER_EXCHANGEDB_INIT_CMD_LOOP ("01 - denomination loop", PERF_TALER_EXCHANGEDB_NB_DENOMINATION_INIT), PERF_TALER_EXCHANGEDB_INIT_CMD_START_TRANSACTION (""), PERF_TALER_EXCHANGEDB_INIT_CMD_CREATE_DENOMINATION ("01 - denomination"), PERF_TALER_EXCHANGEDB_INIT_CMD_INSERT_DENOMINATION ("01 - insert", "01 - denomination"), PERF_TALER_EXCHANGEDB_INIT_CMD_COMMIT_TRANSACTION (""), PERF_TALER_EXCHANGEDB_INIT_CMD_SAVE_ARRAY ("01 - save denomination", "01 - denomination loop", "01 - denomination", PERF_TALER_EXCHANGEDB_NB_DENOMINATION_SAVE), PERF_TALER_EXCHANGEDB_INIT_CMD_END_LOOP ("", "01 - denomination loop"), PERF_TALER_EXCHANGEDB_INIT_CMD_DEBUG ("01 - init denomination complete"), // End of initialization // Reserve initialization PERF_TALER_EXCHANGEDB_INIT_CMD_LOOP ("02 - init reserve loop", PERF_TALER_EXCHANGEDB_NB_RESERVE_INIT), PERF_TALER_EXCHANGEDB_INIT_CMD_CREATE_RESERVE ("02 - reserve"), PERF_TALER_EXCHANGEDB_INIT_CMD_INSERT_RESERVE ("02 - insert", "02 - reserve"), PERF_TALER_EXCHANGEDB_INIT_CMD_SAVE_ARRAY ("02 - save reserve", "02 - init reserve loop", "02 - reserve", PERF_TALER_EXCHANGEDB_NB_RESERVE_SAVE), PERF_TALER_EXCHANGEDB_INIT_CMD_END_LOOP ("", "02 - init reserve loop"), PERF_TALER_EXCHANGEDB_INIT_CMD_DEBUG ("02 - reserve init complete"), // End reserve init // Withdrawal initialization PERF_TALER_EXCHANGEDB_INIT_CMD_LOOP ("03 - init withdraw loop", PERF_TALER_EXCHANGEDB_NB_WITHDRAW_INIT), PERF_TALER_EXCHANGEDB_INIT_CMD_START_TRANSACTION (""), PERF_TALER_EXCHANGEDB_INIT_CMD_LOAD_ARRAY ("03 - denomination load", "03 - init withdraw loop", "01 - save denomination"), PERF_TALER_EXCHANGEDB_INIT_CMD_LOAD_ARRAY ("03 - reserve load", "03 - init withdraw loop", "02 - save reserve"), PERF_TALER_EXCHANGEDB_INIT_CMD_CREATE_WITHDRAW ("03 - withdraw", "03 - denomination load", "03 - reserve load"), PERF_TALER_EXCHANGEDB_INIT_CMD_INSERT_WITHDRAW ("03 - insert", "03 - withdraw"), PERF_TALER_EXCHANGEDB_INIT_CMD_COMMIT_TRANSACTION (""), PERF_TALER_EXCHANGEDB_INIT_CMD_SAVE_ARRAY ("03 - save coin", "03 - init withdraw loop", "03 - withdraw", PERF_TALER_EXCHANGEDB_NB_WITHDRAW_SAVE), PERF_TALER_EXCHANGEDB_INIT_CMD_END_LOOP ("", "03 - init withdraw loop"), PERF_TALER_EXCHANGEDB_INIT_CMD_DEBUG ("03 - withdraw init complete"), //End of withdrawal initialization //Deposit initialization PERF_TALER_EXCHANGEDB_INIT_CMD_LOOP ("04 - deposit init loop", PERF_TALER_EXCHANGEDB_NB_DEPOSIT_INIT), PERF_TALER_EXCHANGEDB_INIT_CMD_START_TRANSACTION ("04 - start transaction"), PERF_TALER_EXCHANGEDB_INIT_CMD_LOAD_ARRAY ("04 - denomination load", "04 - deposit init loop", "03 - save coin"), PERF_TALER_EXCHANGEDB_INIT_CMD_INSERT_DEPOSIT ("04 - deposit", "04 - denomination load"), PERF_TALER_EXCHANGEDB_INIT_CMD_COMMIT_TRANSACTION ("04 - commit transaction"), PERF_TALER_EXCHANGEDB_INIT_CMD_SAVE_ARRAY ("04 - deposit array", "04 - deposit init loop", "04 - deposit", PERF_TALER_EXCHANGEDB_NB_DEPOSIT_SAVE), PERF_TALER_EXCHANGEDB_INIT_CMD_END_LOOP ("04 - deposit init loop end", "04 - deposit init loop"), PERF_TALER_EXCHANGEDB_INIT_CMD_DEBUG ("04 - deposit init complete"), // End of deposit initialization PERF_TALER_EXCHANGEDB_INIT_CMD_END ("end") }; GNUNET_log_setup (benchmark_name, "INFO", NULL); config = GNUNET_CONFIGURATION_create (); ret = GNUNET_CONFIGURATION_parse (config, configuration_file); if (GNUNET_OK != ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error parsing configuration file\n"); return GNUNET_SYSERR; } plugin = TALER_EXCHANGEDB_plugin_load (config); if (NULL == plugin) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error connectiong to the database\n"); return GNUNET_NO; } ret = plugin->create_tables (plugin->cls); if (GNUNET_OK != ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error while creating the database architecture\n"); return GNUNET_NO; } /* * Running the initialization */ if (NULL == init) { init = init_def; } ret = PERF_TALER_EXCHANGEDB_interpret (plugin, init); if (GNUNET_OK != ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error during database initialization\n"); return ret; } /* * Running the benchmark */ ret = PERF_TALER_EXCHANGEDB_interpret (plugin, benchmark); if (GNUNET_OK != ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error while runing the benchmark\n"); return ret; } /* Drop tables */ { ret = plugin->drop_tables (plugin->cls); if (GNUNET_OK != ret) { GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error cleaning the database\n"); return ret; } } TALER_EXCHANGEDB_plugin_unload (plugin); GNUNET_CONFIGURATION_destroy (config); return ret; }