use testbed helper functions and lose old code

1 files changed, 220 insertions, 366 deletions

diff --git a/src/nse/gnunet-nse-profiler.c b/src/nse/gnunet-nse-profiler.c
index cd1e147ad..5777916a0 100644
--- a/src/nse/gnunet-nse-profiler.c
+++ b/src/nse/gnunet-nse-profiler.c
@@ -34,6 +34,18 @@
 #include "gnunet_testbed_service.h"
 #include "gnunet_nse_service.h"
 
+/**
+ * Generic loggins shorthand
+ */
+#define LOG(kind,...)                                           \
+  GNUNET_log (kind, __VA_ARGS__)
+
+/**
+ * Debug logging shorthand
+ */
+#define LOG_DEBUG(...)                          \
+  LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
+
 
 /**
  * Information we track for a peer in the testbed.
@@ -60,20 +72,6 @@ struct NSEPeer
    */
   struct GNUNET_TESTBED_Operation *nse_op;
 
-  /**
-   * Handle to statistics service of the peer.
-   */
-  struct GNUNET_STATISTICS_Handle *stats;
-
-  /**
-   * Testbed operation to connect to statistics service.
-   */
-  struct GNUNET_TESTBED_Operation *stats_op;
-  
-  /**
-   * Task scheduled to get statistics from this peer.
-   */
-  GNUNET_SCHEDULER_TaskIdentifier stats_task;
 };
 
 
@@ -111,6 +109,29 @@ struct StatsContext
 
 
 /**
+ * Operation map entry
+ */
+struct OpListEntry
+{
+  /**
+   * DLL next ptr
+   */
+  struct OpListEntry *next;
+
+  /**
+   * DLL prev ptr
+   */
+  struct OpListEntry *prev;
+
+  /**
+   * The testbed operation
+   */
+  struct GNUNET_TESTBED_Operation *op;
+
+};
+
+
+/**
  * Head of DLL of peers we monitor closely.
  */
 static struct NSEPeer *peer_head;
@@ -136,11 +157,6 @@ static int verbose;
 static char *hosts_file;
 
 /**
- * IP address of this system, as seen by the rest of the system (configuration option)
- */
-static char *controller_ip;
-
-/**
  * Maximum number of peers in the test.
  */
 static unsigned int num_peers;
@@ -217,41 +233,19 @@ static char *data_filename;
 static struct GNUNET_TIME_Relative wait_time = { 60 * 1000 };
 
 /**
- * How often do we query for statistics during a round?
- * Default: 1 s.
- */
-static struct GNUNET_TIME_Relative interval = { 1000 };
-
-/**
- * Name of the file where we write the topology for each round; NULL for
- * none.
+ * DLL head for operation list
  */
-static char *topology_file;
+static struct OpListEntry *oplist_head;
 
 /**
- * List of hosts we use for the testbed.
+ * DLL tail for operation list
  */
-static struct GNUNET_TESTBED_Host **hosts;
+static struct OpListEntry *oplist_tail;
 
 /**
- * Size of the 'hosts' array.
+ * The get stats operation
  */
-static unsigned int num_hosts;
-
-/**
- * Handle to the master controller.
- */
-static struct GNUNET_TESTBED_Controller *controller;
-
-/**
- * Controller start handle.
- */
-static struct GNUNET_TESTBED_ControllerProc *copro;
-
-/* /\** */
-/*  * Testbed handle. */
-/*  *\/ */
-/* static struct GNUNET_TESTBED_Testbed *testbed; */
+static struct GNUNET_TESTBED_Operation *get_stats_op;
 
 
 /**
@@ -262,18 +256,21 @@ static void
 close_monitor_connections ()
 {
   struct NSEPeer *pos;
+  struct OpListEntry *oplist_entry;
 
   while (NULL != (pos = peer_head))
   {
     if (NULL != pos->nse_op)
       GNUNET_TESTBED_operation_done (pos->nse_op);
-    if (NULL != pos->stats_op)
-      GNUNET_TESTBED_operation_done (pos->stats_op);
     GNUNET_CONTAINER_DLL_remove (peer_head, peer_tail, pos);
-    if (GNUNET_SCHEDULER_NO_TASK != pos->stats_task)
-      GNUNET_SCHEDULER_cancel (pos->stats_task);
     GNUNET_free (pos);
   }
+  while (NULL != (oplist_entry = oplist_head))
+  {
+    GNUNET_CONTAINER_DLL_remove (oplist_head, oplist_tail, oplist_entry);
+    GNUNET_TESTBED_operation_done (oplist_entry->op);
+    GNUNET_free (oplist_entry);
+  }
 }
 
 
@@ -288,15 +285,12 @@ shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ending test.\n");    
   close_monitor_connections ();
-  /* if (NULL != testbed) */
-  /*   GNUNET_TESTBED_destroy (testbed); */
-  if (NULL != controller)
-    GNUNET_TESTBED_controller_disconnect (controller);
-  if (NULL != copro)
-      GNUNET_TESTBED_controller_stop (copro);
-  while (0 < num_hosts)
-    GNUNET_TESTBED_host_destroy (hosts[--num_hosts]);
-  // FIXME: what about closing other files!?
+  if (NULL != get_stats_op)
+  {
+    GNUNET_TESTBED_operation_done (get_stats_op);
+    get_stats_op = NULL;
+  }
+  // FIXME: what about closing other files!?  
   if (NULL != data_file)
     GNUNET_DISK_file_close (data_file);
   if (NULL != testing_cfg)
@@ -345,184 +339,6 @@ handle_estimate (void *cls,
 
 
 /**
- * Process core statistic values.
- *
- * @param cls closure
- * @param subsystem name of subsystem that created the statistic
- * @param name the name of the datum
- * @param value the current value
- * @param is_persistent GNUNET_YES if the value is persistent, GNUNET_NO if not
- * @return GNUNET_OK to continue, GNUNET_SYSERR to abort iteration
- */
-static int
-core_stats_iterator (void *cls, const char *subsystem, const char *name,
-                     uint64_t value, int is_persistent)
-{
-  struct NSEPeer *peer = cls;
-  char output_buffer[512];
-  size_t size;
-
-  if (NULL == output_file)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  "%p -> %s [%s]: %llu\n",
-                  peer, subsystem, name, value);
-      return GNUNET_OK;
-    }
-  size =
-    GNUNET_snprintf (output_buffer,
-                     sizeof (output_buffer),
-                     "%p [%s] %s %llu\n",
-                     peer,
-                     subsystem, name, value);
-  if (size != GNUNET_DISK_file_write (output_file, output_buffer, size))
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
-  return GNUNET_OK;
-}
-
-
-/**
- * Continuation called by "get_stats" function once we are done.
- *
- * @param cls closure
- * @param success GNUNET_OK if statistics were
- *        successfully obtained, GNUNET_SYSERR if not.
- */
-static void
-core_stats_cont (void *cls, int success);
-
-
-/**
- * Function invoked periodically to get the statistics.
- *
- * @param cls 'struct NSEPeer' to get stats from
- * @param tc scheduler context
- */
-static void
-core_get_stats (void *cls,
-                const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
-  struct NSEPeer *peer = cls;
-
-  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
-  {
-    GNUNET_TESTBED_operation_done (peer->stats_op);
-    peer->stats = NULL;
-    peer->stats_op = NULL;
-    return;
-  }
-  /* FIXME: code duplication! */
-  GNUNET_STATISTICS_get (peer->stats, "core", NULL,
-                         GNUNET_TIME_UNIT_FOREVER_REL,
-                         &core_stats_cont, 
-                         &core_stats_iterator, peer);
-  GNUNET_STATISTICS_get (peer->stats, "transport", NULL,
-                         GNUNET_TIME_UNIT_FOREVER_REL,
-                         NULL,
-                         &core_stats_iterator, peer);
-  GNUNET_STATISTICS_get (peer->stats, "nse", NULL,
-                         GNUNET_TIME_UNIT_FOREVER_REL,
-                         NULL, 
-                         &core_stats_iterator, peer);
-  peer->stats_task = GNUNET_SCHEDULER_NO_TASK;
-}
-
-
-/**
- * Continuation called by "get_stats" function.
- *
- * @param cls closure
- * @param success GNUNET_OK if statistics were
- *        successfully obtained, GNUNET_SYSERR if not.
- */
-static void
-core_stats_cont (void *cls, 
-                 int success)
-{
-  struct NSEPeer *peer = cls;
-
-  if (GNUNET_OK != success)
-    return;
-  peer->stats_task = GNUNET_SCHEDULER_add_delayed (interval,
-                                                   &core_get_stats, peer);
-}
-
-
-/**
- * Adapter function called to establish a connection to
- * statistics service.
- * 
- * @param cls closure
- * @param cfg configuration of the peer to connect to; will be available until
- *          GNUNET_TESTBED_operation_done() is called on the operation returned
- *          from GNUNET_TESTBED_service_connect()
- * @return service handle to return in 'op_result', NULL on error
- */
-static void *
-statistics_connect_adapter (void *cls,
-                            const struct GNUNET_CONFIGURATION_Handle *cfg)
-{
-  return GNUNET_STATISTICS_create ("<driver>",
-                                   cfg);
-}
-
-
-/**
- * Adapter function called to destroy a connection to
- * statistics service.
- * 
- * @param cls closure
- * @param op_result service handle returned from the connect adapter
- */
-static void 
-statistics_disconnect_adapter (void *cls,
-                               void *op_result)
-{
-  GNUNET_STATISTICS_destroy (op_result, GNUNET_NO);
-}
-
-
-/**
- * Function called by testbed once we are connected to stats service.
- *
- * @param cls the 'struct NSEPeer' for which we connected to stats
- * @param op connect operation handle
- * @param ca_result handle to stats service
- * @param emsg error message on failure
- */
-static void
-stat_run (void *cls, 
-          struct GNUNET_TESTBED_Operation *op,
-          void *ca_result,
-          const char *emsg)
-{
-  struct NSEPeer *current_peer = cls;
-
-  if (NULL == ca_result)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Failed to connect to statistics service: %s\n",
-                  emsg);
-      GNUNET_SCHEDULER_shutdown ();
-      return;
-    }
-  current_peer->stats = ca_result;
-  GNUNET_STATISTICS_get (current_peer->stats, "core", NULL,
-                         GNUNET_TIME_UNIT_FOREVER_REL,
-                         &core_stats_cont, 
-                         &core_stats_iterator, current_peer);
-  GNUNET_STATISTICS_get (current_peer->stats, "transport", NULL,
-                         GNUNET_TIME_UNIT_FOREVER_REL,
-                         NULL, 
-                         &core_stats_iterator, current_peer);
-  GNUNET_STATISTICS_get (current_peer->stats, "nse", NULL,
-                         GNUNET_TIME_UNIT_FOREVER_REL,
-                         NULL, 
-                         &core_stats_iterator, current_peer);
-}
-
-
-/**
  * Adapter function called to establish a connection to
  * NSE service.
  * 
@@ -579,21 +395,13 @@ connect_nse_service ()
     current_peer = GNUNET_malloc (sizeof (struct NSEPeer));
     current_peer->daemon = daemons[i];
     current_peer->nse_op 
-      = GNUNET_TESTBED_service_connect (NULL,
-                                        current_peer->daemon,
-                                        "nse",
-                                        NULL, NULL,
-                                        &nse_connect_adapter,
-                                        &nse_disconnect_adapter,
-                                        current_peer);  
-    current_peer->stats_op 
-      = GNUNET_TESTBED_service_connect (NULL,
-                                        current_peer->daemon,
-                                        "statistics",
-                                        &stat_run, current_peer,
-                                        &statistics_connect_adapter,
-                                        &statistics_disconnect_adapter,
-                                        NULL);  
+        = GNUNET_TESTBED_service_connect (NULL,
+                                          current_peer->daemon,
+                                          "nse",
+                                          NULL, NULL,
+                                          &nse_connect_adapter,
+                                          &nse_disconnect_adapter,
+                                          current_peer);        
     GNUNET_CONTAINER_DLL_insert (peer_head, peer_tail, current_peer);
   }
 }
@@ -629,6 +437,8 @@ stats_finished_callback (void *cls,
   char buf[512];
   size_t buf_len;
 
+  GNUNET_TESTBED_operation_done (get_stats_op);
+  get_stats_op = NULL;
   if (NULL != emsg)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
@@ -696,36 +506,63 @@ statistics_iterator (void *cls,
 {
   struct StatsContext *stats_context = cls;
   char buf[512];
+  const char *const sections[] = {"core", "transport", "nse"};
   size_t buf_len;
+  unsigned int cnt;
+  unsigned int nsections;
 
+  nsections = sizeof (sections) / sizeof (char *);
+  for (cnt = 0; cnt < nsections; cnt++)
+    if (0 == strcmp (subsystem, sections[cnt]))
+      break;
+  if (cnt == nsections)
+    return GNUNET_OK;
+
+  if (NULL == data_file)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "%p -> %s [%s]: %llu\n",
+                peer, subsystem, name, value);
+  }
+  else
+  {
+    buf_len =
+        GNUNET_snprintf (buf,
+                         sizeof (buf),
+                         "%p [%s] %s %llu\n",
+                         peer,
+                         subsystem, name, value);
+    if (buf_len != GNUNET_DISK_file_write (data_file, buf, buf_len))
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
+  }
   if (0 != strcmp (subsystem, "nse"))
     return GNUNET_OK;
   if (0 == strcmp (name, "# flood messages received"))
+  {
+    stats_context->total_nse_received_messages += value;
+    if ( (verbose > 1) && 
+         (NULL != data_file) )
     {
-      stats_context->total_nse_received_messages += value;
-      if ( (verbose > 1) && 
-           (NULL != data_file) )
-        {
-          buf_len =
-            GNUNET_snprintf (buf, sizeof (buf),
-                             "%p %u RECEIVED\n", 
-                             peer, value);
-          GNUNET_DISK_file_write (data_file, buf, buf_len);
-        }
+      buf_len =
+          GNUNET_snprintf (buf, sizeof (buf),
+                           "%p %u RECEIVED\n", 
+                           peer, value);
+      GNUNET_DISK_file_write (data_file, buf, buf_len);
     }
+  }
   if (0 == strcmp (name, "# flood messages transmitted"))
+  {
+    stats_context->total_nse_transmitted_messages += value;
+    if ( (verbose > 1) &&
+         (NULL != data_file) )
     {
-      stats_context->total_nse_transmitted_messages += value;
-      if ( (verbose > 1) &&
-           (NULL != data_file) )
-        {
-          buf_len =
-            GNUNET_snprintf (buf, sizeof (buf),
-                             "%p %u TRANSMITTED\n", 
-                             peer, value);
-          GNUNET_DISK_file_write (data_file, buf, buf_len);
-        }
+      buf_len =
+          GNUNET_snprintf (buf, sizeof (buf),
+                           "%p %u TRANSMITTED\n", 
+                           peer, value);
+      GNUNET_DISK_file_write (data_file, buf, buf_len);
     }
+  }
   if (0 == strcmp (name, "# cross messages"))
     stats_context->total_nse_cross += value;    
   if (0 == strcmp (name, "# extra messages"))    
@@ -737,26 +574,6 @@ statistics_iterator (void *cls,
 
 
 /**
- * Function called upon completion of the node start/stop operations
- * for the current round.  Writes the new topology to disk.
- */
-static void
-write_topology ()
-{
-  char temp_output_file[1024];
-
-  if (NULL != topology_file)
-    {
-      GNUNET_snprintf (temp_output_file, sizeof (temp_output_file),
-                       "%s_%llu.dot", 
-                       topology_file, current_round);
-      GNUNET_TESTBED_overlay_write_topology_to_file (controller,
-                                                     temp_output_file);
-    }
-}
-
-
-/**
  * We're at the end of a round.  Stop monitoring, write total
  * number of connections to log and get full stats.  Then trigger
  * the next round.
@@ -784,11 +601,12 @@ finish_round (void *cls,
     }
   close_monitor_connections ();    
   stats_context = GNUNET_malloc (sizeof (struct StatsContext));
-  GNUNET_TESTBED_get_statistics (num_peers_in_round[current_round], 
-                                 daemons,                                
-                                 &statistics_iterator,
-                                 &stats_finished_callback,
-                                 stats_context);
+  get_stats_op =
+      GNUNET_TESTBED_get_statistics (num_peers_in_round[current_round], 
+                                     daemons,                            
+                                     &statistics_iterator,
+                                     &stats_finished_callback,
+                                     stats_context);
 }
 
 
@@ -800,7 +618,7 @@ finish_round (void *cls,
 static void
 run_round ()
 {
-  write_topology ();
+  LOG_DEBUG ("Running round %u\n", current_round);
   connect_nse_service ();
   GNUNET_SCHEDULER_add_delayed (wait_time,
                                 &finish_round,
@@ -809,6 +627,69 @@ run_round ()
 
 
 /**
+ * Creates an oplist entry and adds it to the oplist DLL
+ */
+static struct OpListEntry *
+make_oplist_entry ()
+{
+  struct OpListEntry *entry;
+
+  entry = GNUNET_malloc (sizeof (struct OpListEntry));
+  GNUNET_CONTAINER_DLL_insert_tail (oplist_head, oplist_tail, entry);
+  return entry;
+}
+
+
+/**
+ * Functions of this signature are called when a peer has been successfully
+ * started or stopped.
+ *
+ * @param cls NULL
+ * @param emsg NULL on success; otherwise an error description
+ */
+static void 
+peer_churn_cb (void *cls, const char *emsg)
+{
+  struct OpListEntry *entry = cls;
+  
+  GNUNET_TESTBED_operation_done (entry->op);
+  GNUNET_CONTAINER_DLL_remove (oplist_head, oplist_tail, entry);
+  GNUNET_free (entry);
+}
+
+
+/**
+ * Adjust the number of running peers to match the required number of running
+ * peers for the round
+ *
+ * @param 
+ * @return 
+ */
+static void
+adjust_running_peers ()
+{
+  struct OpListEntry *entry;
+  unsigned int i;
+
+  /* start peers if we have too few */
+  for (i=peers_running;i<num_peers_in_round[current_round];i++)
+  {
+    entry = make_oplist_entry ();
+    entry->op = GNUNET_TESTBED_peer_start (NULL, daemons[i], 
+                                           &peer_churn_cb, entry);
+  }
+
+  /* stop peers if we have too many */
+  for (i=num_peers_in_round[current_round];i<peers_running;i++)
+  {
+    entry = make_oplist_entry ();
+    entry->op = GNUNET_TESTBED_peer_stop (NULL, daemons[i], 
+                                          &peer_churn_cb, entry);
+  }
+}
+
+
+/**
  * Task run at the end of a round.  Disconnect from all monitored
  * peers; then get statistics from *all* peers.
  *
@@ -819,7 +700,6 @@ static void
 next_round (void *cls, 
             const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  unsigned int i;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "disconnecting nse service of peers\n");
   current_round++;
@@ -836,14 +716,7 @@ next_round (void *cls,
       run_round ();
       return;
     }
-
-  /* start peers if we have too few */
-  for (i=peers_running;i<num_peers_in_round[current_round];i++)
-    GNUNET_TESTBED_peer_start (NULL, daemons[i], NULL, NULL);
-
-  /* stop peers if we have too many */
-  for (i=num_peers_in_round[current_round];i<peers_running;i++)
-    GNUNET_TESTBED_peer_stop (NULL, daemons[i], NULL, NULL);
+  adjust_running_peers ();
 }
 
 
@@ -882,38 +755,29 @@ master_controller_cb (void *cls,
 }
 
 
-static void
-controller_start_cb (void *cls,
-                     const struct GNUNET_CONFIGURATION_Handle *cfg,
-                     int status)
+/**
+ * Signature of a main function for a testcase.
+ *
+ * @param cls NULL
+ * @param num_peers_ number of peers in 'peers'
+ * @param peers handle to peers run in the testbed.  NULL upon timeout (see
+ *          GNUNET_TESTBED_test_run()).
+ */
+static void 
+test_master (void *cls,
+             unsigned int num_peers_,
+             struct GNUNET_TESTBED_Peer **peers)
 {
-  if (GNUNET_OK != status)
-    {
-      copro = NULL;
-      GNUNET_SCHEDULER_shutdown ();
-      return;
-    }
-  num_hosts = GNUNET_TESTBED_hosts_load_from_file (hosts_file,
-                                                   testing_cfg,
-                                                   &hosts);
-  if (0 == num_hosts)
-    {
-      fprintf (stderr,
-               "Failed to read host information from `%s'\n", 
-               hosts_file);
-      return;
-    }
-  controller = GNUNET_TESTBED_controller_connect (cfg,
-                                               NULL, 
-                                               0 /* mask */,
-                                               &master_controller_cb, NULL);
-
-  /* testbed = GNUNET_TESTBED_create (controller, */
-  /*                               num_hosts, hosts,  */
-  /*                               num_peers, */
-  /*                               cfg, */
-  /*                               0 /\* FIXME: topology *\/, */
-  /*                               NULL /\* FIXME: topology options *\/); */
+  daemons = peers;
+  GNUNET_break (num_peers_ == num_peers);
+  peers_running = num_peers;
+  if (num_peers_in_round[current_round] == peers_running)
+  {
+    /* no need to churn, just run next round */
+    run_round ();
+    return;
+  }
+  adjust_running_peers ();
 }
 
 
@@ -930,14 +794,12 @@ run (void *cls, char *const *args, const char *cfgfile,
      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   char *tok;
-  unsigned int num;
+  uint64_t event_mask;
+  unsigned int num;  
 
   ok = 1;
   testing_cfg = GNUNET_CONFIGURATION_dup (cfg);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting daemons.\n");
-  if (verbose)
-    GNUNET_CONFIGURATION_set_value_string (testing_cfg, "testing",
-                                           "use_progressbars", "YES");
   if (NULL == num_peer_spec)
   {
     fprintf (stderr, "You need to specify the number of peers to run\n");
@@ -963,7 +825,6 @@ run (void *cls, char *const *args, const char *cfgfile,
       fprintf (stderr, "Refusing to run a testbed with no rounds\n");
       return;
     }
-  daemons = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_Peer*) * num_peers); 
   if ( (NULL != data_filename) &&
        (NULL == (data_file = 
                  GNUNET_DISK_file_open (data_filename,
@@ -985,16 +846,19 @@ run (void *cls, char *const *args, const char *cfgfile,
                                         GNUNET_DISK_PERM_USER_WRITE))) )
     GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open",
                               output_filename);
-
-  if (NULL ==
-      (copro = GNUNET_TESTBED_controller_start (controller_ip, NULL,
-                                                cfg,
-                                                &controller_start_cb, NULL)))
-    {
-      fprintf (stderr,
-               "Failed to start controller\n");
-      return;
-    }
+  event_mask = 0LL;
+  event_mask |= (1LL << GNUNET_TESTBED_ET_PEER_START);
+  event_mask |= (1LL << GNUNET_TESTBED_ET_PEER_STOP);
+  event_mask |= (1LL << GNUNET_TESTBED_ET_CONNECT);
+  event_mask |= (1LL << GNUNET_TESTBED_ET_DISCONNECT);
+  GNUNET_TESTBED_run (hosts_file,
+                      cfg,
+                      num_peers,
+                      event_mask,
+                      master_controller_cb,
+                      NULL,     /* master_controller_cb cls */
+                      &test_master,
+                      NULL);    /* test_master cls */
   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
                                 &shutdown_task, NULL);
 }
@@ -1017,19 +881,10 @@ main (int argc, char *const *argv)
      1, &GNUNET_GETOPT_set_string, &data_filename},
     {'H', "hosts", "FILENAME",
      gettext_noop ("name of the file with the login information for the testbed"),
-     1, &GNUNET_GETOPT_set_string, &hosts_file},
-    {'i', "ip", "CONTROLLER_IP",
-     gettext_noop ("IP address of this system as seen by the rest of the testbed"),
-     1, &GNUNET_GETOPT_set_string, &controller_ip},
-    {'I', "interval", "DELAY",
-     gettext_noop ("delay between queries to statistics during a round"),
-     1, &GNUNET_GETOPT_set_relative_time, &interval},
-    {'t', "topology", "FILENAME",
-     gettext_noop ("prefix of the filenames we use for writing the topology for each round"),
-     1, &GNUNET_GETOPT_set_string, &topology_file},
+     0, &GNUNET_GETOPT_set_string, &hosts_file},
     {'o', "output", "FILENAME",
      gettext_noop ("name of the file for writing the main results"),
-     1, &GNUNET_GETOPT_set_string, &output_filename},
+     0, &GNUNET_GETOPT_set_string, &output_filename},
     {'p', "peers", "NETWORKSIZESPEC",
      gettext_noop ("Number of peers to run in each round, separated by commas"),
      1, &GNUNET_GETOPT_set_string, &num_peer_spec},
@@ -1043,7 +898,6 @@ main (int argc, char *const *argv)
   };
   if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
     return 2;
-  GNUNET_log_setup ("nse-profiler", "WARNING", NULL);
   if (GNUNET_OK !=
       GNUNET_PROGRAM_run (argc, argv, "nse-profiler",
                           gettext_noop