taler/exchange
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

some modifications, there is one error which display (no function matches the given name and argument types)

Browse Source
This commit is contained in:
Joseph 2022-11-18 11:18:45 -05:00
parent f60e38077c
commit b9ccfbd66b
No known key found for this signature in database
GPG Key ID: E709789D3076B5CC
6 changed files with 337 additions and 215 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

195
src/exchangedb/perf_exchangedb_reserves_in_insert.c Normal file
View File

@ -0,0 +1,195 @@
/*
This file is part of TALER
Copyright (C) 2014-2022 Taler Systems SA
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 <http://www.gnu.org/licenses/>
*/
/**
* @file exchangedb/test_exchangedb_by_j.c
* @brief test cases for DB interaction functions
* @author Joseph Xu
*/
#include "platform.h"
#include "taler_exchangedb_lib.h"
#include "taler_json_lib.h"
#include "taler_exchangedb_plugin.h"
/**
* Global result from the testcase.
*/
static int result;
/**
* Report line of error if @a cond is true, and jump to label "drop".
*/
#define FAILIF(cond) \
do { \
if (! (cond)) { break;} \
GNUNET_break (0); \
goto drop; \
} while (0)
/**
* Initializes @a ptr with random data.
*/
#define RND_BLK(ptr) \
GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, ptr, sizeof (*ptr))
/**
* Initializes @a ptr with zeros.
*/
#define ZR_BLK(ptr) \
memset (ptr, 0, sizeof (*ptr))
/**
* Currency we use. Must match test-exchange-db-*.conf.
*/
#define CURRENCY "EUR"
/**
* Database plugin under test.
*/
static struct TALER_EXCHANGEDB_Plugin *plugin;
/**
* Main function that will be run by the scheduler.
*
* @param cls closure with config
*/
static void
run (void *cls)
{
struct GNUNET_CONFIGURATION_Handle *cfg = cls;
const uint32_t num_partitions = 10;
if (NULL ==
(plugin = TALER_EXCHANGEDB_plugin_load (cfg)))
{
GNUNET_break (0);
result = 77;
return;
}
(void) plugin->drop_tables (plugin->cls);
if (GNUNET_OK !=
plugin->create_tables (plugin->cls))
{
GNUNET_break (0);
result = 77;
goto cleanup;
}
if (GNUNET_OK !=
plugin->setup_partitions (plugin->cls,
num_partitions))
{
GNUNET_break (0);
result = 77;
goto cleanup;
}
for (unsigned int i = 0; i< 8; i++)
{
static unsigned int batches[] = {1, 1, 0, 2, 4, 16, 64, 256};
const char *sndr = "payto://x-taler-bank/localhost:8080/1";
struct TALER_Amount value;
unsigned int batch_size = batches[i];
struct GNUNET_TIME_Absolute now;
struct GNUNET_TIME_Timestamp ts;
struct GNUNET_TIME_Relative duration;
struct TALER_ReservePublicKeyP reserve_pub;
GNUNET_assert (GNUNET_OK ==
TALER_string_to_amount (CURRENCY ":1.000010",
&value));
now = GNUNET_TIME_absolute_get ();
ts = GNUNET_TIME_timestamp_get ();
plugin->start (plugin->cls,
"test_by_exchange_j");
for (unsigned int k = 0; k<batch_size; k++)
{
RND_BLK (&reserve_pub);
FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
plugin->reserves_in_insert (plugin->cls,
&reserve_pub,
&value,
ts,
sndr,
"section",
4));
}
plugin->commit (plugin->cls);
duration = GNUNET_TIME_absolute_get_duration (now);
fprintf (stdout,
"for a batchsize equal to %d it took %s\n",
batch_size,
GNUNET_STRINGS_relative_time_to_string (duration,
GNUNET_NO) );
}
drop:
GNUNET_break (GNUNET_OK ==
plugin->drop_tables (plugin->cls));
cleanup:
TALER_EXCHANGEDB_plugin_unload (plugin);
plugin = NULL;
}
int
main (int argc,
char *const argv[])
{
const char *plugin_name;
char *config_filename;
char *testname;
struct GNUNET_CONFIGURATION_Handle *cfg;
(void) argc;
result = -1;
if (NULL == (plugin_name = strrchr (argv[0], (int) '-')))
{
GNUNET_break (0);
return -1;
}
GNUNET_log_setup (argv[0],
"WARNING",
NULL);
plugin_name++;
(void) GNUNET_asprintf (&testname,
"test-exchange-db-%s",
plugin_name);
(void) GNUNET_asprintf (&config_filename,
"%s.conf",
testname);
fprintf (stdout,
"Using config: %s\n",
config_filename);
cfg = GNUNET_CONFIGURATION_create ();
if (GNUNET_OK !=
GNUNET_CONFIGURATION_parse (cfg,
config_filename))
{
GNUNET_break (0);
GNUNET_free (config_filename);
GNUNET_free (testname);
return 2;
}
GNUNET_SCHEDULER_run (&run,
cfg);
GNUNET_CONFIGURATION_destroy (cfg);
GNUNET_free (config_filename);
GNUNET_free (testname);
return result;
}
/* end of test_exchangedb_by_j.c */

195
src/exchangedb/pg_batch_reserves_in_insert.c
View File

@ -14,7 +14,7 @@
TALER; see the file COPYING. If not, see <http://www.gnu.org/licenses/>
*/
/**
* @file exchangedb/pg_bash_reserves_in_insert.c
* @file exchangedb/pg_batch_reserves_in_insert.c
* @brief Implementation of the reserves_in_insert function for Postgres
* @author JOSEPHxu
*/
@ -70,7 +70,12 @@ TEH_PG_batch_reserves_in_insert (void *cls,
struct TALER_EXCHANGEDB_Reserve reserve;
struct GNUNET_TIME_Timestamp expiry;
struct GNUNET_TIME_Timestamp gc;
struct TALER_PaytoHashP h_payto;
uint64_t reserve_uuid;
bool conflicted;
bool transaction_duplicate;
struct GNUNET_TIME_Timestamp reserve_expiration
= GNUNET_TIME_relative_to_timestamp (pg->idle_reserve_expiration_time);
reserve.pub = reserves->reserve_pub;
expiry = GNUNET_TIME_absolute_to_timestamp (
@ -91,15 +96,28 @@ TEH_PG_batch_reserves_in_insert (void *cls,
the 'add' operation needs the reserve entry as a foreign key. */
{
struct GNUNET_PQ_QueryParam params[] = {
GNUNET_PQ_query_param_auto_from_type (&(reserves->reserve_pub)),
TALER_PQ_query_param_amount (&(reserves->balance)),
GNUNET_PQ_query_param_timestamp (&expiry),
GNUNET_PQ_query_param_timestamp (&gc),
GNUNET_PQ_query_param_auto_from_type (&reserves->reserve_pub), /*$1*/
TALER_PQ_query_param_amount (&reserves->balance), /*$2+3*/
GNUNET_PQ_query_param_timestamp (&expiry), /*$4*/
GNUNET_PQ_query_param_timestamp (&gc), /*$5*/
GNUNET_PQ_query_param_uint64 (&reserves->wire_reference), /*6*/
TALER_PQ_query_param_amount (&reserves->balance), /*7+8*/
GNUNET_PQ_query_param_string (reserves->exchange_account_name), /*9*/
GNUNET_PQ_query_param_timestamp (&reserves->execution_time), /*10*/
GNUNET_PQ_query_param_auto_from_type (&h_payto), /*11*/
GNUNET_PQ_query_param_string (reserves->sender_account_details),/*12*/
GNUNET_PQ_query_param_timestamp (&reserve_expiration),/*13*/
GNUNET_PQ_query_param_end
};
/* We should get all our results into results[]*/
struct GNUNET_PQ_ResultSpec rs[] = {
GNUNET_PQ_result_spec_uint64 ("reserve_uuid",
&reserve_uuid),
GNUNET_PQ_result_spec_bool ("conflicted",
&conflicted),
GNUNET_PQ_result_spec_bool ("transaction_duplicate",
&transaction_duplicate),
GNUNET_PQ_result_spec_end
};
@ -108,7 +126,12 @@ TEH_PG_batch_reserves_in_insert (void *cls,
/* Note: query uses 'on conflict do nothing' */
PREPARE (pg,
"reserve_create",
"SELECT bash_reserves_in('34', '20','//asdddfs3', '60', '20'),bash_reserves_in('24', '10','//dfs3', '40', '50'),bash_reserves_in('42', '40','//d43', '40', '50'),bash_reserves_in('44', '10','//ghs3', '40', '50') AS existed from reserves;");
"SELECT "
"out_reserve_found AS conflicted"
",transaction_duplicate"
",ruuid"
" FROM batch_reserves_in"
" ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12);");
qs1 = GNUNET_PQ_eval_prepared_singleton_select (pg->conn,
"reserve_create",
@ -118,167 +141,9 @@ TEH_PG_batch_reserves_in_insert (void *cls,
return qs1;
}
/* Create new incoming transaction, "ON CONFLICT DO NOTHING"
is again used to guard against duplicates. */
{
enum GNUNET_DB_QueryStatus qs2;
enum GNUNET_DB_QueryStatus qs3;
struct TALER_PaytoHashP h_payto;
qs3 = TEH_PG_setup_wire_target (pg,
reserves->sender_account_details,
&h_payto);
if (qs3 < 0)
return qs3;
/* We do not have the UUID, so insert by public key */
struct GNUNET_PQ_QueryParam params[] = {
GNUNET_PQ_query_param_auto_from_type (&reserve.pub),
GNUNET_PQ_query_param_uint64 (&(reserves->wire_reference)),
TALER_PQ_query_param_amount (&(reserves->balance)),
GNUNET_PQ_query_param_string (reserves->exchange_account_name),
GNUNET_PQ_query_param_auto_from_type (&h_payto),
GNUNET_PQ_query_param_timestamp (&reserves->execution_time),
GNUNET_PQ_query_param_end
};
PREPARE (pg,
"reserves_in_add_transaction",
"INSERT INTO reserves_in "
"(reserve_pub"
",wire_reference"
",credit_val"
",credit_frac"
",exchange_account_section"
",wire_source_h_payto"
",execution_date"
") VALUES ($1, $2, $3, $4, $5, $6, $7)"
" ON CONFLICT DO NOTHING;");
qs2 = GNUNET_PQ_eval_prepared_non_select (pg->conn,
"reserves_in_add_transaction",
params);
/* qs2 could be 0 as statement used 'ON CONFLICT DO NOTHING' */
if (0 >= qs2)
{
if ( (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS == qs2) &&
(GNUNET_DB_STATUS_SUCCESS_NO_RESULTS != qs1) )
{
/* Conflict for the transaction, but the reserve was
just now created, that should be impossible. */
GNUNET_break (0); /* should be impossible: reserve was fresh,
but transaction already known */
return GNUNET_DB_STATUS_HARD_ERROR;
}
/* Transaction was already known or error. We are finished. */
return qs2;
}
}
if (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT == qs1)
{
/* New reserve, we are finished */
notify_on_reserve (pg,
&(reserves->reserve_pub));
return GNUNET_DB_STATUS_SUCCESS_ONE_RESULT;
}
/* we were wrong with our optimistic assumption:
reserve did already exist, need to do an update instead */
{
/* We need to move away from 'read committed' to serializable.
Also, we know that it should be safe to commit at this point.
(We are only run in a larger transaction for performance.) */
enum GNUNET_DB_QueryStatus cs;
cs = TEH_PG_commit(pg);
if (cs < 0)
return cs;
if (GNUNET_OK !=
TEH_PG_start (pg,
"reserve-update-serializable"))
{
GNUNET_break (0);
return GNUNET_DB_STATUS_HARD_ERROR;
}
}
{
enum GNUNET_DB_QueryStatus reserve_exists;
reserve_exists = TEH_PG_reserves_get (pg,
&reserve);
switch (reserve_exists)
{
case GNUNET_DB_STATUS_HARD_ERROR:
GNUNET_break (0);
return reserve_exists;
case GNUNET_DB_STATUS_SOFT_ERROR:
return reserve_exists;
case GNUNET_DB_STATUS_SUCCESS_NO_RESULTS:
/* First we got a conflict, but then we cannot select? Very strange. */
GNUNET_break (0);
return GNUNET_DB_STATUS_SOFT_ERROR;
case GNUNET_DB_STATUS_SUCCESS_ONE_RESULT:
/* continued below */
break;
}
}
{
struct TALER_EXCHANGEDB_Reserve updated_reserve;
enum GNUNET_DB_QueryStatus qs3;
/* If the reserve already existed, we need to still update the
balance; we do this after checking for duplication, as
otherwise we might have to actually pay the cost to roll this
back for duplicate transactions; like this, we should virtually
never actually have to rollback anything. */
updated_reserve.pub = reserve.pub;
if (0 >
TALER_amount_add (&updated_reserve.balance,
&reserve.balance,
&reserves->balance))
{
/* currency overflow or incompatible currency */
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Attempt to deposit incompatible amount into reserve\n");
return GNUNET_DB_STATUS_HARD_ERROR;
}
updated_reserve.expiry = GNUNET_TIME_timestamp_max (expiry,
reserve.expiry);
updated_reserve.gc = GNUNET_TIME_timestamp_max (gc,
reserve.gc);
qs3 = TEH_PG_reserves_update (pg,
&updated_reserve);
switch (qs3)
{
case GNUNET_DB_STATUS_HARD_ERROR:
GNUNET_break (0);
return qs3;
case GNUNET_DB_STATUS_SOFT_ERROR:
return qs3;
case GNUNET_DB_STATUS_SUCCESS_NO_RESULTS:
/* How can the UPDATE not work here? Very strange. */
GNUNET_break (0);
return GNUNET_DB_STATUS_HARD_ERROR;
case GNUNET_DB_STATUS_SUCCESS_ONE_RESULT:
/* continued below */
break;
}
}
notify_on_reserve (pg,
&reserves->reserve_pub);
/* Go back to original transaction mode */
{
enum GNUNET_DB_QueryStatus cs;
cs = TEH_PG_commit (pg);
if (cs < 0)
return cs;
if (GNUNET_OK !=
TEH_PG_start_read_committed (pg,
"reserve-insert-continued"))
{
GNUNET_break (0);
return GNUNET_DB_STATUS_HARD_ERROR;
}
}
return GNUNET_DB_STATUS_SUCCESS_ONE_RESULT;
}

1
src/exchangedb/pg_batch_reserves_in_insert.h
View File

@ -31,4 +31,5 @@ TEH_PG_batch_reserves_in_insert (void *cls,
const struct TALER_EXCHANGEDB_ReserveInInfo *reserves,
unsigned int reserves_length,
enum GNUNET_DB_QueryStatus *results);
#endif

2
src/exchangedb/plugin_exchangedb_postgres.c
View File

@ -5446,8 +5446,10 @@ libtaler_plugin_exchangedb_postgres_init (void *cls)
= &TEH_PG_select_purse_by_merge_pub;
plugin->set_purse_balance
= &TEH_PG_set_purse_balance;
plugin->batch_reserves_in_insert
= &TEH_PG_batch_reserves_in_insert;
return plugin;
}

148
src/exchangedb/procedures.sql
View File

@ -2520,62 +2520,120 @@ BEGIN
policy_details_serial_id = out_policy_details_serial_id;
END $$;
COMMIT;
/*************************************************************/
CREATE OR REPLACE FUNCTION bash_reserves_in(
IN amount_val INT8,
IN amount_frac INT4,
IN rpub BYTEA,
IN now INT8,
IN min_reserve_gc INT8,
OUT reserve_found BOOLEAN,
CREATE OR REPLACE FUNCTION batch_reserves_in(
IN in_reserve_pub BYTEA,
IN in_current_balance_val INT8,
IN in_current_balance_frac INT4,
IN in_expiration_date INT8,
IN in_gc_date INT8,
IN in_wire_ref INT8,
IN in_credit_val INT8,
IN in_credit_frac INT4,
IN in_exchange_account_name VARCHAR,
IN in_exectution_date INT4,
IN in_wire_source_h_payto BYTEA, ---h_payto
IN in_payto_uri VARCHAR,
IN in_reserve_expiration INT8,
OUT out_reserve_found BOOLEAN,
OUT transaction_duplicate BOOLEAN,
OUT ruuid INT8)
LANGUAGE plpgsql
AS $$
DECLARE
existed BOOLEAN;
not_existed BOOLEAN;
my_amount_val INT8;
DECLARE
my_amount_frac INT4;
BEGIN
SELECT reserves.reserve_uuid into ruuid from reserves
where reserves.reserve_pub = rpub;
IF ruuid IS NOT NULL
THEN
existed = TRUE;
UPDATE reserves
SET (current_balance_val
,current_balance_frac
,expiration_date
,gc_date) =
(amount_val
,amount_frac
,now
,min_reserve_gc)
WHERE
reserve_pub = rpub
RETURNING existed into reserve_found;
END IF;
IF NOT FOUND
THEN
SELECT MAX(reserve_uuid)+1 into ruuid from reserves;
existed = FALSE;
INSERT INTO reserves
(reserve_uuid
,reserve_pub
SELECT
current_balance_val
,current_balance_frac
INTO
my_amount_val
,my_amount_frac
FROM reserves
WHERE reserves.reserve_pub = in_reserve_pub;
INSERT INTO reserves
(reserve_pub
,current_balance_val
,current_balance_frac
,expiration_date
,gc_date)
VALUES
(ruuid
,rpub
,amount_val
,amount_frac
,now
,min_reserve_gc) RETURNING existed into reserve_found;
(in_reserve_pub
,in_current_balance_val
,in_current_balance_frac
,in_expiration_date
,in_gc_date)
ON CONFLICT DO NOTHING
RETURNING reserves.reserve_uuid INTO ruuid;
--IF THE INSERT WAS NOT SUCCESSFUL, REMEMBER IT
IF NOT FOUND
THEN
out_reserve_found = FALSE;
ELSE
out_reserve_found = TRUE;
END IF;
--SIMPLE INSERT ON CONFLICT DO NOTHING
INSERT INTO wire_targets
(wire_target_h_payto
,payto_uri)
VALUES
(in_wire_source_h_payto
,in_payto_uri)
ON CONFLICT DO NOTHING;
INSERT INTO reserves_in
(reserve_pub
,wire_reference
,credit_val
,credit_frac
,exchange_account_section
,wire_source_h_payto
,execution_date)
VALUES
(in_reserve_pub
,in_wire_ref
,in_current_balance_val
,in_credit_frac
,in_exchange_account_section
,in_wire_source_h_payto
,in_execution_date);
--IF THE INSERTION WAS A SUCCESS IT MEANS NO DUPLICATED TRANSACTION
IF FOUND
THEN
transaction_duplicate = FALSE;
IF out_reserve_found = TRUE
THEN
UPDATE reserves
SET
in_current_balance_frac=in_current_balance_frac+my_amount_frac
- CASE
WHEN in_current_balance_frac + my_amount_frac >= 100000000
THEN 100000000
ELSE 0
END
,in_current_balance_val=in_current_balance_val+my_amount_val
+ CASE
WHEN in_current_balance_frac + my_amount_frac >= 100000000
THEN 1
ELSE 0
END
,expiration_date=GREATEST(in_expiration_date,in_reserve_expiration)
,gc_date=GREATEST(in_gc_date,in_reserve_expiration)
WHERE reserves.reserve_pub=in_reserve_pub;
RETURN;
ELSE
RETURN;
END IF;
ELSE
transaction_duplicate = TRUE;
RETURN;
END IF;
END $$;
COMMIT;

11
src/exchangedb/test_exchangedb_by_j.c
View File

@ -33,7 +33,7 @@ static int result;
*/
#define FAILIF(cond) \
do { \
if (! (cond)) { break;} \
if (! (cond)) {break;} \
GNUNET_break (0); \
goto drop; \
} while (0)
@ -108,14 +108,15 @@ run (void *cls)
struct GNUNET_TIME_Timestamp ts;
struct GNUNET_TIME_Relative duration;
struct TALER_EXCHANGEDB_ReserveInInfo reserves[batch_size];
enum GNUNET_DB_QueryStatus *results;
enum GNUNET_DB_QueryStatus results[batch_size];
GNUNET_assert (GNUNET_OK ==
TALER_string_to_amount (CURRENCY ":1.000010",
&value));
now = GNUNET_TIME_absolute_get ();
ts = GNUNET_TIME_timestamp_get ();
plugin->start (plugin->cls,
"test_by_exchange_j");
"test_by_j");
for (unsigned int k = 0; k<batch_size; k++)
{
RND_BLK (&reserves[k].reserve_pub);
@ -123,13 +124,13 @@ run (void *cls)
reserves[k].execution_time = ts;
reserves[k].sender_account_details = sndr;
reserves[k].exchange_account_name = "name";
}
FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
plugin->batch_reserves_in_insert (plugin->cls,
reserves,
batch_size,
&results));
results));
plugin->commit (plugin->cls);
duration = GNUNET_TIME_absolute_get_duration (now);