src/benchmark/Makefile.am

@@ -12,8 +12,9 @@ endif
 
 bin_PROGRAMS = \
   taler-aggregator-benchmark \
-  taler-bank-benchmark \
+  taler-bank-benchmark
-  taler-exchange-benchmark
+
+# taler-exchange-benchmark
 
 
 taler_aggregator_benchmark_SOURCES = \

src/benchmark/benchmark-common.conf

@@ -58,15 +58,20 @@ MAX_DEBT_BANK=EUR:1000000000000000.0
 DATABASE=bank-db.sqlite3
 
 [libeufin-nexus]
-DB_CONNECTION="jdbc:postgresql://localhost/talercheck?socketFactory=org.newsclub.net.unix.AFUNIXSocketFactory$FactoryArg&socketFactoryArg=/var/run/postgresql/.s.PGSQL.5432"
+#DB_CONNECTION="jdbc:postgresql://localhost/talercheck?socketFactory=org.newsclub.net.unix.AFUNIXSocketFactory$FactoryArg&socketFactoryArg=/var/run/postgresql/.s.PGSQL.5432"
-#DB_CONNECTION="jdbc:sqlite:libeufin-nexus.sqlite3"
+DB_CONNECTION="jdbc:sqlite:libeufin-nexus.sqlite3"
 
 [libeufin-sandbox]
-DB_CONNECTION="jdbc:postgresql://localhost/talercheck?socketFactory=org.newsclub.net.unix.AFUNIXSocketFactory$FactoryArg&socketFactoryArg=/var/run/postgresql/.s.PGSQL.5432"
+#DB_CONNECTION="jdbc:postgresql://localhost/talercheck?socketFactory=org.newsclub.net.unix.AFUNIXSocketFactory$FactoryArg&socketFactoryArg=/var/run/postgresql/.s.PGSQL.5432"
-#DB_CONNECTION="jdbc:sqlite:libeufin-sandbox.sqlite3"
+DB_CONNECTION="jdbc:sqlite:libeufin-sandbox.sqlite3"
 
 [auditor]
 BASE_URL="http://localhost:8083/"
 
+[benchmark-remote-exchange]
+HOST=localhost
+# Adjust $HOME to match remote target!
+DIR=$HOME/repos/taler/exchange/src/benchmark
+
 [benchmark]
 USER_PAYTO_URI="payto://x-taler-bank/localhost:8082/42?receiver-name=user42"

src/benchmark/taler-exchange-benchmark.c

@@ -28,7 +28,25 @@
 #include <microhttpd.h>
 #include <sys/resource.h>
 #include "taler_util.h"
+#include "taler_signatures.h"
+#include "taler_exchangedb_lib.h"
+#include "taler_exchange_service.h"
+#include "taler_json_lib.h"
+#include "taler_bank_service.h"
+#include "taler_fakebank_lib.h"
 #include "taler_testing_lib.h"
+#include "taler_error_codes.h"
+
+/* Error codes.  */
+enum BenchmarkError
+{
+  MISSING_BANK_URL,
+  FAILED_TO_LAUNCH_BANK,
+  BAD_CLI_ARG,
+  BAD_CONFIG_FILE,
+  NO_CONFIG_FILE_GIVEN
+};
+
 
 /**
  * The whole benchmark is a repetition of a "unit".  Each
@@ -37,11 +55,51 @@
  */
 #define UNITY_SIZE 6
 
+#define FIRST_INSTRUCTION -1
+
 
 /**
- * Credentials to use for the benchmark.
+ * What mode should the benchmark run in?
  */
-static struct TALER_TESTING_Credentials cred;
+enum BenchmarkMode
+{
+  /**
+   * Run as client (with fakebank), also starts a remote exchange.
+   */
+  MODE_CLIENT = 1,
+
+  /**
+   * Run the the exchange.
+   */
+  MODE_EXCHANGE = 2,
+
+  /**
+   * Run both, for a local benchmark.
+   */
+  MODE_BOTH = 3,
+};
+
+
+/**
+ * Hold information regarding which bank has the exchange account.
+ */
+static const struct TALER_EXCHANGEDB_AccountInfo *exchange_bank_account;
+
+/**
+ * Hold information about a user at the bank.
+ */
+static char *user_payto_uri;
+
+/**
+ * Time snapshot taken right before executing the CMDs.
+ */
+static struct GNUNET_TIME_Absolute start_time;
+
+/**
+ * Benchmark duration time taken right after the CMD interpreter
+ * returns.
+ */
+static struct GNUNET_TIME_Relative duration;
 
 /**
  * Array of all the commands the benchmark is running.
@@ -53,6 +111,16 @@ static struct TALER_TESTING_Command *all_commands;
  */
 static char *cfg_filename;
 
+/**
+ * Exit code.
+ */
+static enum GNUNET_GenericReturnValue result;
+
+/**
+ * Use the fakebank instead of the Python bank.
+ */
+static int use_fakebank;
+
 /**
  * How many coins we want to create per client and reserve.
  */
@@ -83,6 +151,16 @@ static char *loglev;
  */
 static char *logfile;
 
+/**
+ * Benchmarking mode (run as client, exchange, both) as string.
+ */
+static char *mode_str;
+
+/**
+ * Benchmarking mode (run as client, exchange, both).
+ */
+static enum BenchmarkMode mode;
+
 /**
  * Configuration.
  */
@@ -93,22 +171,21 @@ static struct GNUNET_CONFIGURATION_Handle *cfg;
  */
 static int reserves_first;
 
-/**
- * Are we running against 'fakebank'?
- */
-static int use_fakebank;
-
-/**
- * Section with the configuration data for the exchange
- * bank account.
- */
-static char *exchange_bank_section = "exchange-account-1";
-
 /**
  * Currency used.
  */
 static char *currency;
 
+/**
+ * Remote host that runs the exchange.
+ */
+static char *remote_host;
+
+/**
+ * Remote benchmarking directory.
+ */
+static char *remote_dir;
+
 /**
  * Array of command labels.
  */
@@ -125,7 +202,8 @@ static unsigned int label_len;
 static unsigned int label_off;
 
 /**
- * Linger around until stop is requested by the user explicitly by key stroke.
+ * Don't kill exchange/fakebank/wirewatch until
+ * requested by the user explicitly.
  */
 static int linger;
 
@@ -168,8 +246,8 @@ cmd_transfer_to_exchange (const char *label,
   return TALER_TESTING_cmd_admin_add_incoming_retry (
     TALER_TESTING_cmd_admin_add_incoming (label,
                                           amount,
-                                          &cred.ba,
+                                          exchange_bank_account->auth,
-                                          cred.user42_payto));
+                                          user_payto_uri));
 }
 
 
@@ -210,12 +288,11 @@ run (void *cls,
   char *amount_1;
 
   (void) cls;
-  all_commands = GNUNET_new_array (
+  all_commands = GNUNET_new_array (howmany_reserves * (1     /* Withdraw block */
-    howmany_reserves * (1                /* Withdraw block */
+                                                       + howmany_coins)   /* All units */
-                        + howmany_coins) /* All units */
+                                   + 1 /* stat CMD */
-    + 1                                /* stat CMD */
+                                   + 1 /* End CMD */,
-    + 1 /* End CMD */,
+                                   struct TALER_TESTING_Command);
-    struct TALER_TESTING_Command);
   GNUNET_asprintf (&amount_5, "%s:5", currency);
   GNUNET_asprintf (&amount_4, "%s:4", currency);
   GNUNET_asprintf (&amount_1, "%s:1", currency);
@@ -273,25 +350,25 @@ run (void *cls,
       wl = add_label (withdraw_label);
       GNUNET_asprintf (&order_enc,
                        "{\"nonce\": %llu}",
-                       ((unsigned long long) i)
+                       ((unsigned long long) i) + (howmany_coins
-                       + (howmany_coins * (unsigned long long) j));
+                                                   * (unsigned long long) j));
       unit[0] =
-        TALER_TESTING_cmd_withdraw_with_retry (
+        TALER_TESTING_cmd_withdraw_with_retry
-          TALER_TESTING_cmd_withdraw_amount (wl,
+          (TALER_TESTING_cmd_withdraw_amount (wl,
-                                             create_reserve_label,
+                                              create_reserve_label,
-                                             amount_5,
+                                              amount_5,
-                                             0,  /* age restriction off */
+                                              0, /* age restriction off */
-                                             MHD_HTTP_OK));
+                                              MHD_HTTP_OK));
       unit[1] =
-        TALER_TESTING_cmd_deposit_with_retry (
+        TALER_TESTING_cmd_deposit_with_retry
-          TALER_TESTING_cmd_deposit ("deposit",
+          (TALER_TESTING_cmd_deposit ("deposit",
-                                     wl,
+                                      wl,
-                                     0,  /* Index of the one withdrawn coin in the traits.  */
+                                      0, /* Index of the one withdrawn coin in the traits.  */
-                                     cred.user43_payto,
+                                      user_payto_uri,
-                                     add_label (order_enc),
+                                      add_label (order_enc),
-                                     GNUNET_TIME_UNIT_ZERO,
+                                      GNUNET_TIME_UNIT_ZERO,
-                                     amount_1,
+                                      amount_1,
-                                     MHD_HTTP_OK));
+                                      MHD_HTTP_OK));
       if (eval_probability (refresh_rate / 100.0))
       {
         char *melt_label;
@@ -310,21 +387,21 @@ run (void *cls,
                          j);
         rl = add_label (reveal_label);
         unit[2] =
-          TALER_TESTING_cmd_melt_with_retry (
+          TALER_TESTING_cmd_melt_with_retry
-            TALER_TESTING_cmd_melt (ml,
+            (TALER_TESTING_cmd_melt (ml,
-                                    wl,
+                                     wl,
-                                    MHD_HTTP_OK,
+                                     MHD_HTTP_OK,
-                                    NULL));
+                                     NULL));
         unit[3] =
-          TALER_TESTING_cmd_refresh_reveal_with_retry (
+          TALER_TESTING_cmd_refresh_reveal_with_retry
-            TALER_TESTING_cmd_refresh_reveal (rl,
+            (TALER_TESTING_cmd_refresh_reveal (rl,
-                                              ml,
+                                               ml,
-                                              MHD_HTTP_OK));
+                                               MHD_HTTP_OK));
         unit[4] =
-          TALER_TESTING_cmd_refresh_link_with_retry (
+          TALER_TESTING_cmd_refresh_link_with_retry
-            TALER_TESTING_cmd_refresh_link ("link",
+            (TALER_TESTING_cmd_refresh_link ("link",
-                                            rl,
+                                             rl,
-                                            MHD_HTTP_OK));
+                                             MHD_HTTP_OK));
         unit[5] = TALER_TESTING_cmd_end ();
       }
       else
@@ -352,6 +429,7 @@ run (void *cls,
   GNUNET_free (amount_4);
   GNUNET_free (amount_5);
   GNUNET_free (withdraw_fee_str);
+  result = GNUNET_OK;
 }
 
 
@@ -368,10 +446,10 @@ print_stats (void)
 
     total = GNUNET_strdup (
       GNUNET_STRINGS_relative_time_to_string (timings[i].total_duration,
-                                              true));
+                                              GNUNET_YES));
     latency = GNUNET_strdup (
       GNUNET_STRINGS_relative_time_to_string (timings[i].success_latency,
-                                              true));
+                                              GNUNET_YES));
     fprintf (stderr,
              "%s-%d took %s in total with %s for latency for %u executions (%u repeats)\n",
              timings[i].prefix,
@@ -402,66 +480,135 @@ parallel_benchmark (TALER_TESTING_Main main_cb,
 {
   enum GNUNET_GenericReturnValue result = GNUNET_OK;
   pid_t cpids[howmany_clients];
+  pid_t fakebank = -1;
+  int wstatus;
 
-  if (1 == howmany_clients)
+  if (MODE_CLIENT == mode)
   {
-    result = TALER_TESTING_loop (main_cb,
+    char *remote_cmd;
-                                 main_cb_cls);
+
-    print_stats ();
+    GNUNET_asprintf (&remote_cmd,
+                     ("cd '%s'; "
+                      "taler-exchange-benchmark --mode=exchange -c '%s'"),
+                     remote_dir,
+                     config_file);
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "remote command: %s\n",
+                remote_cmd);
+
+    GNUNET_assert (NULL != (exchange_slave_pipe =
+                              GNUNET_DISK_pipe (GNUNET_DISK_PF_BLOCKING_RW)));
+
+    exchange_slave = GNUNET_OS_start_process (GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
+                                              exchange_slave_pipe, NULL, NULL,
+                                              "ssh",
+                                              "ssh",
+                                              /* Don't ask for pw/passphrase, rather fail */
+                                              "-oBatchMode=yes",
+                                              remote_host,
+                                              remote_cmd,
+                                              NULL);
+    GNUNET_free (remote_cmd);
   }
-  else
-  {
-    for (unsigned int i = 0; i<howmany_clients; i++)
-    {
-      if (0 == (cpids[i] = fork ()))
-      {
-        /* I am the child, do the work! */
-        GNUNET_log_setup ("benchmark-worker",
-                          NULL == loglev ? "INFO" : loglev,
-                          logfile);
-        result = TALER_TESTING_loop (main_cb,
-                                     main_cb_cls);
-        print_stats ();
-        if (GNUNET_OK != result)
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                      "Failure in child process %u test suite!\n",
-                      i);
-        if (GNUNET_OK == result)
-          exit (0);
-        else
-          exit (1);
-      }
-      if (-1 == cpids[i])
-      {
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
-                             "fork");
-        howmany_clients = i;
-        result = GNUNET_SYSERR;
-        break;
-      }
-      /* fork() success, continue starting more processes! */
-    }
-    /* collect all children */
-    for (unsigned int i = 0; i<howmany_clients; i++)
-    {
-      int wstatus;
 
-      waitpid (cpids[i],
+  /* We always wait for the exchange, no matter if it's running locally or
-               &wstatus,
+     remotely */
-               0);
+  if (0 != TALER_TESTING_wait_httpd_ready (ec.exchange_url))
-      if ( (! WIFEXITED (wstatus)) ||
+  {
-           (0 != WEXITSTATUS (wstatus)) )
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to detect running exchange at `%s'\n",
+                ec.exchange_url);
+    return 77;
+  }
+  if ( (MODE_CLIENT == mode) || (MODE_BOTH == mode) )
+  {
+    start_time = GNUNET_TIME_absolute_get ();
+    result = GNUNET_OK;
+    if (1 == howmany_clients)
+    {
+      result = TALER_TESTING_run (main_cb,
+                                  main_cb_cls);
+      print_stats ();
+    }
+    else
+    {
+      for (unsigned int i = 0; i<howmany_clients; i++)
       {
-        GNUNET_break (0);
+        if (0 == (cpids[i] = fork ()))
-        result = GNUNET_SYSERR;
+        {
+          /* I am the child, do the work! */
+          GNUNET_log_setup ("benchmark-worker",
+                            NULL == loglev ? "INFO" : loglev,
+                            logfile);
+
+          result = TALER_TESTING_run (main_cb,
+                                      main_cb_cls);
+          print_stats ();
+          if (GNUNET_OK != result)
+            GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                        "Failure in child process test suite!\n");
+          if (GNUNET_OK == result)
+            exit (0);
+          else
+            exit (1);
+        }
+        if (-1 == cpids[i])
+        {
+          GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
+                               "fork");
+          howmany_clients = i;
+          result = GNUNET_SYSERR;
+          break;
+        }
+        /* fork() success, continue starting more processes! */
+      }
+      /* collect all children */
+      for (unsigned int i = 0; i<howmany_clients; i++)
+      {
+        waitpid (cpids[i],
+                 &wstatus,
+                 0);
+        if ( (! WIFEXITED (wstatus)) ||
+             (0 != WEXITSTATUS (wstatus)) )
+        {
+          GNUNET_break (0);
+          result = GNUNET_SYSERR;
+        }
       }
     }
   }
-  if (GNUNET_YES == linger)
+
+  /* Wait for our master to die or to tell us to die */
+  if (MODE_EXCHANGE == mode)
+    (void) getchar ();
+
+  if ( (GNUNET_YES == linger) &&
+       ( ((mode == MODE_BOTH) ||
+          (mode == MODE_CLIENT) ) ) )
   {
     printf ("press ENTER to stop\n");
     (void) getchar ();
   }
+
+  if (MODE_CLIENT == mode)
+  {
+    char c = 'q';
+
+    GNUNET_assert (NULL != exchange_slave);
+
+    /* Write a character to the pipe to end the exchange slave.
+     * We can't send a signal here, as it would just kill SSH and
+     * not necessarily the process on the other machine. */
+    GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle
+                              (exchange_slave_pipe, GNUNET_DISK_PIPE_END_WRITE),
+                            &c, sizeof (c));
+
+    GNUNET_break (GNUNET_OK ==
+                  GNUNET_OS_process_wait (exchange_slave));
+    GNUNET_OS_process_destroy (exchange_slave);
+  }
+
   return result;
 }
 
@@ -478,70 +625,55 @@ main (int argc,
       char *const *argv)
 {
   struct GNUNET_GETOPT_CommandLineOption options[] = {
-    GNUNET_GETOPT_option_mandatory (
+    GNUNET_GETOPT_option_mandatory
-      GNUNET_GETOPT_option_cfgfile (
+      (GNUNET_GETOPT_option_cfgfile (&cfg_filename)),
-        &cfg_filename)),
+    GNUNET_GETOPT_option_version (PACKAGE_VERSION " " VCS_VERSION),
-    GNUNET_GETOPT_option_version (
+    GNUNET_GETOPT_option_help ("Exchange benchmark"),
-      PACKAGE_VERSION " " VCS_VERSION),
+    GNUNET_GETOPT_option_loglevel (&loglev),
-    GNUNET_GETOPT_option_help (
+    GNUNET_GETOPT_option_uint ('n',
-      "Exchange benchmark"),
+                               "coins-number",
-    GNUNET_GETOPT_option_loglevel (
+                               "CN",
-      &loglev),
+                               "How many coins we should instantiate per reserve",
-    GNUNET_GETOPT_option_uint (
+                               &howmany_coins),
-      'n',
+    GNUNET_GETOPT_option_uint ('p',
-      "coins-number",
+                               "parallelism",
-      "CN",
+                               "NPROCS",
-      "How many coins we should instantiate per reserve",
+                               "How many client processes we should run",
-      &howmany_coins),
+                               &howmany_clients),
-    GNUNET_GETOPT_option_uint (
+    GNUNET_GETOPT_option_uint ('r',
-      'p',
+                               "reserves",
-      "parallelism",
+                               "NRESERVES",
-      "NPROCS",
+                               "How many reserves per client we should create",
-      "How many client processes we should run",
+                               &howmany_reserves),
-      &howmany_clients),
+    GNUNET_GETOPT_option_uint ('R',
-    GNUNET_GETOPT_option_uint (
+                               "refresh-rate",
-      'r',
+                               "RATE",
-      "reserves",
+                               "Probability of refresh per coin (0-100)",
-      "NRESERVES",
+                               &refresh_rate),
-      "How many reserves per client we should create",
+    GNUNET_GETOPT_option_string ('m',
-      &howmany_reserves),
+                                 "mode",
-    GNUNET_GETOPT_option_uint (
+                                 "MODE",
-      'R',
+                                 "run as exchange, clients or both",
-      "refresh-rate",
+                                 &mode_str),
-      "RATE",
+    GNUNET_GETOPT_option_string ('l',
-      "Probability of refresh per coin (0-100)",
+                                 "logfile",
-      &refresh_rate),
+                                 "LF",
-    GNUNET_GETOPT_option_string (
+                                 "will log to file LF",
-      'l',
+                                 &logfile),
-      "logfile",
+    GNUNET_GETOPT_option_flag ('f',
-      "LF",
+                               "fakebank",
-      "will log to file LF",
+                               "start a fakebank instead of the Python bank",
-      &logfile),
+                               &use_fakebank),
-    GNUNET_GETOPT_option_string (
+    GNUNET_GETOPT_option_flag ('F',
-      'u',
+                               "reserves-first",
-      "exchange-account-section",
+                               "should all reserves be created first, before starting normal operations",
-      "SECTION",
+                               &reserves_first),
-      "use exchange bank account configuration from the given SECTION",
+    GNUNET_GETOPT_option_flag ('K',
-      &exchange_bank_section),
+                               "linger",
-    GNUNET_GETOPT_option_flag (
+                               "linger around until key press",
-      'f',
+                               &linger),
-      "fakebank",
-      "use fakebank for the banking system",
-      &use_fakebank),
-    GNUNET_GETOPT_option_flag (
-      'F',
-      "reserves-first",
-      "should all reserves be created first, before starting normal operations",
-      &reserves_first),
-    GNUNET_GETOPT_option_flag (
-      'K',
-      "linger",
-      "linger around until key press",
-      &linger),
     GNUNET_GETOPT_OPTION_END
   };
-  enum GNUNET_GenericReturnValue result;
-  struct GNUNET_TIME_Relative duration;
 
   unsetenv ("XDG_DATA_HOME");
   unsetenv ("XDG_CONFIG_HOME");
@@ -554,13 +686,29 @@ main (int argc,
     GNUNET_free (cfg_filename);
     if (GNUNET_NO == result)
       return 0;
-    return EXIT_INVALIDARGUMENT;
+    return BAD_CLI_ARG;
   }
   GNUNET_log_setup ("taler-exchange-benchmark",
-                    NULL == loglev
+                    NULL == loglev ? "INFO" : loglev,
-                    ? "INFO"
-                    : loglev,
                     logfile);
+  if (NULL == mode_str)
+    mode = MODE_BOTH;
+  else if (0 == strcmp (mode_str,
+                        "exchange"))
+    mode = MODE_EXCHANGE;
+  else if (0 == strcmp (mode_str,
+                        "client"))
+    mode = MODE_CLIENT;
+  else if (0 == strcmp (mode_str,
+                        "both"))
+    mode = MODE_BOTH;
+  else
+  {
+    TALER_LOG_ERROR ("Unknown mode given: '%s'\n",
+                     mode_str);
+    GNUNET_free (cfg_filename);
+    return BAD_CONFIG_FILE;
+  }
   if (NULL == cfg_filename)
     cfg_filename = GNUNET_CONFIGURATION_default_filename ();
   if (NULL == cfg_filename)
@@ -576,7 +724,7 @@ main (int argc,
   {
     TALER_LOG_ERROR ("Could not parse configuration\n");
     GNUNET_free (cfg_filename);
-    return EXIT_NOTCONFIGURED;
+    return BAD_CONFIG_FILE;
   }
   if (GNUNET_OK !=
       TALER_config_get_currency (cfg,
@@ -584,45 +732,96 @@ main (int argc,
   {
     GNUNET_CONFIGURATION_destroy (cfg);
     GNUNET_free (cfg_filename);
-    return EXIT_NOTCONFIGURED;
+    return BAD_CONFIG_FILE;
   }
   if (howmany_clients > 10240)
   {
     TALER_LOG_ERROR ("-p option value given is too large\n");
-    return EXIT_INVALIDARGUMENT;
+    return BAD_CLI_ARG;
   }
   if (0 == howmany_clients)
   {
     TALER_LOG_ERROR ("-p option value must not be zero\n");
     GNUNET_free (cfg_filename);
-    return EXIT_INVALIDARGUMENT;
+    return BAD_CLI_ARG;
+  }
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_string (cfg,
+                                             "benchmark",
+                                             "USER_PAYTO_URI",
+                                             &user_payto_uri))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+                               "benchmark",
+                               "USER_PAYTO_URI");
+    GNUNET_free (cfg_filename);
+    return BAD_CONFIG_FILE;
   }
 
   if (GNUNET_OK !=
-      TALER_TESTING_get_credentials (
+      TALER_EXCHANGEDB_load_accounts (cfg,
-        cfg_filename,
+                                      TALER_EXCHANGEDB_ALO_AUTHDATA
-        exchange_bank_section,
+                                      | TALER_EXCHANGEDB_ALO_CREDIT))
-        use_fakebank
-        ? TALER_TESTING_BS_FAKEBANK
-        : TALER_TESTING_BS_IBAN,
-        &cred))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Required bank credentials not given in configuration\n");
+                "Configuration fails to provide exchange bank details\n");
     GNUNET_free (cfg_filename);
-    return EXIT_NOTCONFIGURED;
+    return BAD_CONFIG_FILE;
+  }
+
+  exchange_bank_account
+    = TALER_EXCHANGEDB_find_account_by_method ("x-taler-bank");
+  if (NULL == exchange_bank_account)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "No bank account for `x-taler-bank` given in configuration\n");
+    GNUNET_free (cfg_filename);
+    return BAD_CONFIG_FILE;
   }
 
   {
-    struct GNUNET_TIME_Absolute start_time;
+    if (GNUNET_OK !=
+        GNUNET_CONFIGURATION_get_value_string (cfg,
+                                               "benchmark-remote-exchange",
+                                               "host",
+                                               &remote_host))
+    {
+      GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+                                 "benchmark-remote-exchange",
+                                 "host");
+      GNUNET_CONFIGURATION_destroy (cfg);
+      GNUNET_free (cfg_filename);
+      return BAD_CONFIG_FILE;
+    }
 
-    start_time = GNUNET_TIME_absolute_get ();
+    if (GNUNET_OK !=
-    result = parallel_benchmark (&run,
+        GNUNET_CONFIGURATION_get_value_string (cfg,
-                                 NULL,
+                                               "benchmark-remote-exchange",
-                                 cfg_filename);
+                                               "dir",
-    duration = GNUNET_TIME_absolute_get_duration (start_time);
+                                               &remote_dir))
+    {
+      GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+                                 "benchmark-remote-exchange",
+                                 "dir");
+      GNUNET_CONFIGURATION_destroy (cfg);
+      GNUNET_free (cfg_filename);
+      return BAD_CONFIG_FILE;
+    }
   }
 
+  result = parallel_benchmark (&run,
+                               NULL,
+                               cfg_filename);
+  TALER_EXCHANGEDB_unload_accounts ();
+  GNUNET_CONFIGURATION_destroy (cfg);
+  GNUNET_free (cfg_filename);
+
+  /* If we're the exchange worker, we're done now.  No need to print results */
+  if (MODE_EXCHANGE == mode)
+  {
+    return (GNUNET_OK == result) ? 0 : result;
+  }
+  duration = GNUNET_TIME_absolute_get_duration (start_time);
   if (GNUNET_OK == result)
   {
     struct rusage usage;
@@ -630,45 +829,39 @@ main (int argc,
     GNUNET_assert (0 == getrusage (RUSAGE_CHILDREN,
                                    &usage));
     fprintf (stdout,
-             "Executed (Withdraw=%u, Deposit=%u, Refresh~=%5.2f)"
+             "Executed (Withdraw=%u, Deposit=%u, Refresh~=%5.2f) * Reserve=%u * Parallel=%u, operations in %s\n",
-             " * Reserve=%u * Parallel=%u, operations in %s\n",
              howmany_coins,
              howmany_coins,
              (float) howmany_coins * (refresh_rate / 100.0),
              howmany_reserves,
              howmany_clients,
-             GNUNET_STRINGS_relative_time_to_string (
+             GNUNET_STRINGS_relative_time_to_string
-               duration,
+               (duration,
-               false));
+               GNUNET_NO));
     fprintf (stdout,
              "(approximately %s/coin)\n",
-             GNUNET_STRINGS_relative_time_to_string (
+             GNUNET_STRINGS_relative_time_to_string
-               GNUNET_TIME_relative_divide (
+               (GNUNET_TIME_relative_divide (duration,
-                 duration,
+                                             (unsigned long long) howmany_coins
-                 (unsigned long long) howmany_coins
+                                             * howmany_reserves
-                 * howmany_reserves
+                                             * howmany_clients),
-                 * howmany_clients),
+               GNUNET_YES));
-               true));
     fprintf (stdout,
              "RAW: %04u %04u %04u %16llu\n",
              howmany_coins,
              howmany_reserves,
              howmany_clients,
              (unsigned long long) duration.rel_value_us);
-    fprintf (stdout,
+    fprintf (stdout, "cpu time: sys %llu user %llu\n", \
-             "cpu time: sys %llu user %llu\n",
              (unsigned long long) (usage.ru_stime.tv_sec * 1000 * 1000
                                    + usage.ru_stime.tv_usec),
              (unsigned long long) (usage.ru_utime.tv_sec * 1000 * 1000
                                    + usage.ru_utime.tv_usec));
   }
-
   for (unsigned int i = 0; i<label_off; i++)
     GNUNET_free (labels[i]);
   GNUNET_array_grow (labels,
                      label_len,
                      0);
-  GNUNET_CONFIGURATION_destroy (cfg);
-  GNUNET_free (cfg_filename);
   return (GNUNET_OK == result) ? 0 : result;
 }

src/exchange/taler-exchange-httpd_keys.c

@@ -2318,7 +2318,6 @@ add_denom_key_cb (void *cls,
  * Add the headers we want to set for every /keys response.
  *
  * @param ksh the key state to use
- * @param wsh wire state to use
  * @param[in,out] response the response to modify
  * @return #GNUNET_OK on success
  */