GNUnet  0.11.x
gnunet-nse-profiler.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2011, 2012 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
10  GNUnet is distributed in the hope that it will be useful, but
11  WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
32 #include "platform.h"
33 #include "gnunet_testbed_service.h"
34 #include "gnunet_nse_service.h"
35 
39 #define LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__)
40 
44 #define LOG_DEBUG(...) LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
45 
46 
50 struct NSEPeer
51 {
55  struct NSEPeer *prev;
56 
60  struct NSEPeer *next;
61 
66 
71 
76 
81 };
82 
83 
88 {
92  struct OpListEntry *next;
93 
97  struct OpListEntry *prev;
98 
103 
108  int delta;
109 };
110 
111 
115 static struct NSEPeer *peer_head;
116 
120 static struct NSEPeer *peer_tail;
121 
125 static int ok;
126 
130 static unsigned int verbose;
131 
135 static char *hosts_file;
136 
140 static unsigned int num_peers;
141 
145 static unsigned int num_rounds;
146 
150 static unsigned int current_round;
151 
155 static unsigned int *num_peers_in_round;
156 
160 static unsigned int peers_running;
161 
165 static char *num_peer_spec;
166 
170 static struct GNUNET_TESTBED_Peer **daemons;
171 
176 
180 static unsigned int connection_limit;
181 
185 static unsigned int total_connections;
186 
191 
195 static char *output_filename;
196 
201 
205 static char *data_filename;
206 
211 static struct GNUNET_TIME_Relative wait_time = { 60 * 1000 };
212 
216 static struct OpListEntry *oplist_head;
217 
221 static struct OpListEntry *oplist_tail;
222 
227 
228 
233 static void
235 {
236  struct NSEPeer *pos;
237  struct OpListEntry *oplist_entry;
238 
239  while (NULL != (pos = peer_head))
240  {
241  if (NULL != pos->nse_op)
243  if (NULL != pos->stat_op)
245  GNUNET_CONTAINER_DLL_remove (peer_head, peer_tail, pos);
246  GNUNET_free (pos);
247  }
248  while (NULL != (oplist_entry = oplist_head))
249  {
250  GNUNET_CONTAINER_DLL_remove (oplist_head, oplist_tail, oplist_entry);
251  GNUNET_TESTBED_operation_done (oplist_entry->op);
252  GNUNET_free (oplist_entry);
253  }
254 }
255 
256 
262 static void
263 shutdown_task (void *cls)
264 {
265  LOG_DEBUG ("Ending test.\n");
267  if (NULL != round_task)
268  {
269  GNUNET_SCHEDULER_cancel (round_task);
270  round_task = NULL;
271  }
272  if (NULL != data_file)
273  {
274  GNUNET_DISK_file_close (data_file);
275  data_file = NULL;
276  }
277  if (NULL != output_file)
278  {
279  GNUNET_DISK_file_close (output_file);
280  output_file = NULL;
281  }
282  if (NULL != testing_cfg)
283  {
284  GNUNET_CONFIGURATION_destroy (testing_cfg);
285  testing_cfg = NULL;
286  }
287 }
288 
289 
299 static void
300 handle_estimate (void *cls,
301  struct GNUNET_TIME_Absolute timestamp,
302  double estimate,
303  double std_dev)
304 {
305  struct NSEPeer *peer = cls;
306  char output_buffer[512];
307  size_t size;
308 
309  if (NULL == output_file)
310  {
311  fprintf (stderr,
312  "Received network size estimate from peer %p. Size: %f std.dev. %f\n",
313  peer,
314  estimate,
315  std_dev);
316  return;
317  }
318  size = GNUNET_snprintf (output_buffer,
319  sizeof(output_buffer),
320  "%p %llu %llu %f %f %f\n",
321  peer,
323  (unsigned long long) timestamp.abs_value_us,
324  GNUNET_NSE_log_estimate_to_n (estimate),
325  estimate,
326  std_dev);
327  if (size != GNUNET_DISK_file_write (output_file, output_buffer, size))
328  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
329 }
330 
331 
342 static void *
344 {
345  struct NSEPeer *current_peer = cls;
346 
347  return GNUNET_NSE_connect (cfg, &handle_estimate, current_peer);
348 }
349 
350 
358 static void
360 {
361  GNUNET_NSE_disconnect (op_result);
362 }
363 
364 
375 static int
376 stat_iterator (void *cls,
377  const char *subsystem,
378  const char *name,
379  uint64_t value,
380  int is_persistent)
381 {
382  char *output_buffer;
383  struct GNUNET_TIME_Absolute now;
384  int size;
385  unsigned int flag;
386 
387  GNUNET_assert (NULL != data_file);
388  now = GNUNET_TIME_absolute_get ();
389  flag = strcasecmp (subsystem, "core");
390  if (0 != flag)
391  flag = 1;
392  size = GNUNET_asprintf (&output_buffer,
393  "%llu %llu %u\n",
394  now.abs_value_us / 1000LL / 1000LL,
395  value,
396  flag);
397  if (0 > size)
398  {
399  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Error formatting output buffer.\n");
400  GNUNET_free (output_buffer);
401  return GNUNET_SYSERR;
402  }
403  if (size != GNUNET_DISK_file_write (data_file, output_buffer, (size_t) size))
404  {
405  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
406  GNUNET_free (output_buffer);
407  return GNUNET_SYSERR;
408  }
409  GNUNET_free (output_buffer);
410  return GNUNET_OK;
411 }
412 
413 
423 static void *
425 {
426  struct NSEPeer *peer = cls;
427 
428  peer->sh = GNUNET_STATISTICS_create ("nse-profiler", cfg);
429  return peer->sh;
430 }
431 
432 
439 static void
441 {
442  struct NSEPeer *peer = cls;
443 
446  "core",
447  "# peers connected",
449  peer));
452  "nse",
453  "# peers connected",
455  peer));
457  peer->sh = NULL;
458 }
459 
460 
471 static void
472 stat_comp_cb (void *cls,
474  void *ca_result,
475  const char *emsg)
476 {
477  struct GNUNET_STATISTICS_Handle *sh = ca_result;
478  struct NSEPeer *peer = cls;
479 
480  if (NULL != emsg)
481  {
482  GNUNET_break (0);
483  return;
484  }
486  "core",
487  "# peers connected",
489  peer));
491  "nse",
492  "# peers connected",
494  peer));
495 }
496 
497 
502 static void
504 {
505  struct NSEPeer *current_peer;
506  unsigned int i;
507  unsigned int connections;
508 
509  if (0 == connection_limit)
510  return;
511  LOG_DEBUG ("Connecting to nse service of peers\n");
512  connections = 0;
513  for (i = 0; i < num_peers_in_round[current_round]; i++)
514  {
515  if ((num_peers_in_round[current_round] > connection_limit) &&
516  (0 != (i % (num_peers_in_round[current_round] / connection_limit))))
517  continue;
518  LOG_DEBUG ("Connecting to nse service of peer %d\n", i);
519  current_peer = GNUNET_new (struct NSEPeer);
520  current_peer->daemon = daemons[i];
521  current_peer->nse_op =
523  current_peer->daemon,
524  "nse",
525  NULL,
526  NULL,
529  current_peer);
530  if (NULL != data_file)
531  current_peer->stat_op =
533  current_peer->daemon,
534  "statistics",
535  stat_comp_cb,
536  current_peer,
539  current_peer);
540  GNUNET_CONTAINER_DLL_insert (peer_head, peer_tail, current_peer);
541  if (++connections == connection_limit)
542  break;
543  }
544 }
545 
546 
552 static void
553 next_round (void *cls);
554 
555 
563 static void
564 finish_round (void *cls)
565 {
566  LOG (GNUNET_ERROR_TYPE_INFO, "Have %u connections\n", total_connections);
568  round_task = GNUNET_SCHEDULER_add_now (&next_round, NULL);
569 }
570 
571 
577 static void
579 {
580  LOG_DEBUG ("Running round %u\n", current_round);
582  GNUNET_SCHEDULER_add_delayed (wait_time, &finish_round, NULL);
583 }
584 
585 
589 static struct OpListEntry *
591 {
592  struct OpListEntry *entry;
593 
594  entry = GNUNET_new (struct OpListEntry);
595  GNUNET_CONTAINER_DLL_insert_tail (oplist_head, oplist_tail, entry);
596  return entry;
597 }
598 
599 
607 static void
608 manage_service_cb (void *cls,
610  const char *emsg)
611 {
612  struct OpListEntry *entry = cls;
613 
615  if (NULL != emsg)
616  {
617  LOG (GNUNET_ERROR_TYPE_ERROR, "Failed to start/stop NSE at a peer\n");
619  return;
620  }
621  GNUNET_assert (0 != entry->delta);
622  peers_running += entry->delta;
623  GNUNET_CONTAINER_DLL_remove (oplist_head, oplist_tail, entry);
624  GNUNET_free (entry);
626  run_round ();
627 }
628 
629 
634 static void
636 {
637  struct OpListEntry *entry;
638  unsigned int i;
639 
640  /* start peers if we have too few */
641  for (i = peers_running; i < num_peers_in_round[current_round]; i++)
642  {
643  entry = make_oplist_entry ();
644  entry->delta = 1;
645  entry->op = GNUNET_TESTBED_peer_manage_service (NULL,
646  daemons[i],
647  "nse",
649  entry,
650  1);
651  }
652  /* stop peers if we have too many */
653  for (i = num_peers_in_round[current_round]; i < peers_running; i++)
654  {
655  entry = make_oplist_entry ();
656  entry->delta = -1;
657  entry->op = GNUNET_TESTBED_peer_manage_service (NULL,
658  daemons[i],
659  "nse",
661  entry,
662  0);
663  }
664 }
665 
666 
673 static void
674 next_round (void *cls)
675 {
676  round_task = NULL;
677  LOG_DEBUG ("Disconnecting nse service of peers\n");
678  current_round++;
679  if (current_round == num_rounds)
680  {
681  /* this was the last round, terminate */
682  ok = 0;
684  return;
685  }
687  {
688  /* no need to churn, just run next round */
689  run_round ();
690  return;
691  }
693 }
694 
695 
703 static void
705  const struct GNUNET_TESTBED_EventInformation *event)
706 {
707  switch (event->type)
708  {
711  break;
712 
715  break;
716 
717  default:
718  break;
719  }
720 }
721 
722 
736 static void
737 test_master (void *cls,
738  struct GNUNET_TESTBED_RunHandle *h,
739  unsigned int num_peers_,
740  struct GNUNET_TESTBED_Peer **peers,
741  unsigned int links_succeeded,
742  unsigned int links_failed)
743 {
744  if (NULL == peers)
745  {
747  return;
748  }
749  daemons = peers;
750  GNUNET_break (num_peers_ == num_peers);
753  {
754  /* no need to churn, just run the starting round */
755  run_round ();
756  return;
757  }
759 }
760 
761 
770 static void
771 run (void *cls,
772  char *const *args,
773  const char *cfgfile,
774  const struct GNUNET_CONFIGURATION_Handle *cfg)
775 {
776  char *tok;
777  uint64_t event_mask;
778  unsigned int num;
779 
780  ok = 1;
781  testing_cfg = GNUNET_CONFIGURATION_dup (cfg);
782  LOG_DEBUG ("Starting daemons.\n");
783  if (NULL == num_peer_spec)
784  {
785  fprintf (stderr, "You need to specify the number of peers to run\n");
786  return;
787  }
788  for (tok = strtok (num_peer_spec, ","); NULL != tok; tok = strtok (NULL, ","))
789  {
790  if (1 != sscanf (tok, "%u", &num))
791  {
792  fprintf (stderr, "You need to specify numbers, not `%s'\n", tok);
793  return;
794  }
795  if (0 == num)
796  {
797  fprintf (stderr, "Refusing to run a round with 0 peers\n");
798  return;
799  }
801  num_peers = GNUNET_MAX (num_peers, num);
802  }
803  if (0 == num_peers)
804  {
805  fprintf (stderr, "Refusing to run a testbed with no rounds\n");
806  return;
807  }
808  if ((NULL != data_filename) &&
809  (NULL ==
810  (data_file = GNUNET_DISK_file_open (data_filename,
817 
818  if ((NULL != output_filename) &&
819  (NULL ==
820  (output_file = GNUNET_DISK_file_open (output_filename,
826  event_mask = 0LL;
827  event_mask |= (1LL << GNUNET_TESTBED_ET_PEER_START);
828  event_mask |= (1LL << GNUNET_TESTBED_ET_PEER_STOP);
829  event_mask |= (1LL << GNUNET_TESTBED_ET_CONNECT);
830  event_mask |= (1LL << GNUNET_TESTBED_ET_DISCONNECT);
832  cfg,
833  num_peers,
834  event_mask,
836  NULL, /* master_controller_cb cls */
837  &test_master,
838  NULL); /* test_master cls */
840 }
841 
842 
848 int
849 main (int argc, char *const *argv)
850 {
851  struct GNUNET_GETOPT_CommandLineOption options[] =
853  'C',
854  "connections",
855  "COUNT",
856  gettext_noop (
857  "limit to the number of connections to NSE services, 0 for none"),
860  'd',
861  "details",
862  "FILENAME",
863  gettext_noop (
864  "name of the file for writing connection information and statistics"),
865  &data_filename),
866 
868  'H',
869  "hosts",
870  "FILENAME",
871  gettext_noop (
872  "name of the file with the login information for the testbed"),
873  &hosts_file),
874 
876  'o',
877  "output",
878  "FILENAME",
879  gettext_noop ("name of the file for writing the main results"),
880  &output_filename),
881 
882 
884  'p',
885  "peers",
886  "NETWORKSIZESPEC",
887  gettext_noop (
888  "Number of peers to run in each round, separated by commas"),
889  &num_peer_spec),
890 
892  'V',
893  "verbose",
894  gettext_noop ("be verbose (print progress information)"),
895  &verbose),
896 
898  "wait",
899  "DELAY",
900  gettext_noop ("delay between rounds"),
901  &wait_time),
903 
904  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
905  return 2;
906  if (
907  GNUNET_OK !=
908  GNUNET_PROGRAM_run (argc,
909  argv,
910  "nse-profiler",
911  gettext_noop (
912  "Measure quality and performance of the NSE service."),
913  options,
914  &run,
915  NULL))
916  ok = 1;
917  return ok;
918 }
919 
920 
921 /* end of nse-profiler.c */
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_relative_time(char shortName, const char *name, const char *argumentHelp, const char *description, struct GNUNET_TIME_Relative *val)
Allow user to specify a struct GNUNET_TIME_Relative (using human-readable "fancy" time)...
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
static void close_monitor_connections()
Clean up all of the monitoring connections to NSE and STATISTICS that we keep to selected peers...
static void next_round(void *cls)
Task that starts/stops peers to move to the next round.
struct OpListEntry * prev
DLL prev ptr.
Create file if it doesn&#39;t exist.
struct NSEPeer * next
Next reference in DLL.
static char * subsystem
Set to subsystem that we&#39;re going to get stats for (or NULL for all).
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1345
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static struct GNUNET_TESTBED_Peer ** daemons
Handles to all of the running peers.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
int GNUNET_snprintf(char *buf, size_t size, const char *format,...)
Like snprintf, just aborts if the buffer is of insufficient size.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1300
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.
int GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1438
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_increment_uint(char shortName, const char *name, const char *description, unsigned int *val)
Increment val each time the option flag is given by one.
static unsigned int current_round
Current round we are in.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static int op_result(struct GNUNET_OP_Handle *h, uint64_t op_id, int64_t result_code, const void *data, uint16_t data_size, void **ctx, uint8_t cancel)
Remove an operation, and call its result callback (unless it was cancelled).
Definition: op.c:245
struct GNUNET_NSE_Handle * GNUNET_NSE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_NSE_Callback func, void *func_cls)
Connect to the network size estimation service.
Definition: nse_api.c:165
static struct NSEPeer * peer_head
Head of DLL of peers we monitor closely.
static void * stat_connect_adapter(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
Called to open a connection to the peer&#39;s statistics.
static int ok
Return value from &#39;main&#39; (0 == success)
Argument to GNUNET_TESTBED_ControllerCallback with details about the event.
static void test_master(void *cls, struct GNUNET_TESTBED_RunHandle *h, unsigned int num_peers_, struct GNUNET_TESTBED_Peer **peers, unsigned int links_succeeded, unsigned int links_failed)
Signature of a main function for a testcase.
#define GNUNET_NO
Definition: gnunet_common.h:78
static struct GNUNET_DISK_FileHandle * data_file
File to log connection info, statistics to.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
enum GNUNET_TESTBED_EventType type
Type of the event.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Definition of a command line option.
static char * hosts_file
Name of the file with the hosts to run the test over (configuration option)
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:526
Handle for the service.
struct GNUNET_CONTAINER_MultiShortmap * connections
Map from struct GNUNET_CADET_ConnectionTunnelIdentifier hash codes to struct CadetConnection objects...
uint64_t abs_value_us
The actual value.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static void master_controller_cb(void *cls, const struct GNUNET_TESTBED_EventInformation *event)
Function that will be called whenever something in the testbed changes.
static struct OpListEntry * make_oplist_entry()
Creates an oplist entry and adds it to the oplist DLL.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
Opaque handle to an abstract operation to be executed by the testing framework.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_string(char shortName, const char *name, const char *argumentHelp, const char *description, char **str)
Allow user to specify a string.
static struct OpListEntry * oplist_head
DLL head for operation list.
struct GNUNET_TESTBED_Operation * nse_op
Testbed operation to connect to NSE service.
static void shutdown_task(void *cls)
Task run on shutdown; cleans up everything.
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_service_connect(void *op_cls, struct GNUNET_TESTBED_Peer *peer, const char *service_name, GNUNET_TESTBED_ServiceConnectCompletionCallback cb, void *cb_cls, GNUNET_TESTBED_ConnectAdapter ca, GNUNET_TESTBED_DisconnectAdapter da, void *cada_cls)
Connect to a service offered by the given peer.
struct NSEPeer * prev
Prev reference in DLL.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1253
Information we track for a peer in the testbed.
static struct OpListEntry * oplist_tail
DLL tail for operation list.
static void handle_estimate(void *cls, struct GNUNET_TIME_Absolute timestamp, double estimate, double std_dev)
Callback to call when network size estimate is updated.
struct GNUNET_TESTBED_Peer * daemon
Handle with testbed.
static char * value
Value of the record to add/remove.
static struct GNUNET_SCHEDULER_Task * round_task
Task running each round of the experiment.
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
static unsigned int num_peers
Maximum number of peers in the test.
Truncate file if it exists.
ssize_t GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: disk.c:820
#define GNUNET_MAX(a, b)
Definition: gnunet_common.h:82
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1280
static char * data_filename
Filename to log connection info, statistics to.
Operation map entry.
static struct NSEPeer * peer_tail
Tail of DLL of peers we monitor closely.
static unsigned int verbose
Be verbose (configuration option)
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
static unsigned int total_connections
Total number of connections in the whole network.
static struct GNUNET_TIME_Relative wait_time
How long to wait before triggering next round? Default: 60 s.
void GNUNET_TESTBED_operation_done(struct GNUNET_TESTBED_Operation *operation)
This function is used to signal that the event information (struct GNUNET_TESTBED_EventInformation) f...
Definition: testbed_api.c:2044
static struct GNUNET_CONFIGURATION_Handle * testing_cfg
Global configuration file.
void GNUNET_TESTBED_run(const char *host_filename, const struct GNUNET_CONFIGURATION_Handle *cfg, unsigned int num_peers, uint64_t event_mask, GNUNET_TESTBED_ControllerCallback cc, void *cc_cls, GNUNET_TESTBED_TestMaster test_master, void *test_master_cls)
Convenience method for running a testbed with a single call.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
A connection between two peers was torn down.
static unsigned int connection_limit
Maximum number of connections to NSE services.
void GNUNET_NSE_disconnect(struct GNUNET_NSE_Handle *h)
Disconnect from network size estimation service.
Definition: nse_api.c:193
static void finish_round(void *cls)
We&#39;re at the end of a round.
uint64_t event_mask
Global event mask for all testbed events.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static unsigned int size
Size of the "table".
Definition: peer.c:67
static void adjust_running_peers()
Adjust the number of running peers to match the required number of running peers for the round...
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
static void stat_comp_cb(void *cls, struct GNUNET_TESTBED_Operation *op, void *ca_result, const char *emsg)
Called after successfully opening a connection to a peer&#39;s statistics service; we register statistics...
A connection between two peers was established.
int delta
Depending on whether we start or stop NSE service at the peer set this to 1 or -1.
static unsigned int num_rounds
Total number of rounds to execute.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_dup(const struct GNUNET_CONFIGURATION_Handle *cfg)
Duplicate an existing configuration object.
struct GNUNET_STATISTICS_Handle * sh
Handle to the statistics service.
static unsigned int * num_peers_in_round
Array of size &#39;num_rounds&#39; with the requested number of peers in the given round. ...
#define GNUNET_array_append(arr, size, element)
Append an element to a list (growing the list by one).
int GNUNET_STATISTICS_watch_cancel(struct GNUNET_STATISTICS_Handle *handle, const char *subsystem, const char *name, GNUNET_STATISTICS_Iterator proc, void *proc_cls)
Stop watching statistics from the peer.
int main(int argc, char *const *argv)
Main function.
static void run(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
Actual main function that runs the emulation.
#define LOG(kind,...)
Generic loggins shorthand.
configuration data
Definition: configuration.c:85
static void nse_disconnect_adapter(void *cls, void *op_result)
Adapter function called to destroy a connection to NSE service.
const char * name
static struct CadetPeer * peers
Operation to get peer ids.
static char * num_peer_spec
Specification for the numbers of peers to have in each round.
int GNUNET_STATISTICS_watch(struct GNUNET_STATISTICS_Handle *handle, const char *subsystem, const char *name, GNUNET_STATISTICS_Iterator proc, void *proc_cls)
Watch statistics from the peer (be notified whenever they change).
static void connect_nse_service()
Task run to connect to the NSE and statistics services to a subset of all of the running peers...
#define GNUNET_log(kind,...)
Entry in list of pending tasks.
Definition: scheduler.c:134
static int stat_iterator(void *cls, const char *subsystem, const char *name, uint64_t value, int is_persistent)
Callback function to process statistic values.
Open the file for both reading and writing.
static void run_round()
We have reached the desired number of peers for the current round.
int GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration, parse options).
Definition: program.c:367
static void manage_service_cb(void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg)
Callback to be called when NSE service is started or stopped at peers.
Time for absolute times used by GNUnet, in microseconds.
static void * nse_connect_adapter(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
Adapter function called to establish a connection to NSE service.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_uint(char shortName, const char *name, const char *argumentHelp, const char *description, unsigned int *val)
Allow user to specify an unsigned int.
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
A peer controlled by the testing framework.
A peer has been stopped.
static unsigned int peers_running
How many peers are running right now?
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_peer_manage_service(void *op_cls, struct GNUNET_TESTBED_Peer *peer, const char *service_name, GNUNET_TESTBED_OperationCompletionCallback cb, void *cb_cls, unsigned int start)
Start or stop given service at a peer.
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition: disk.c:1268
#define GNUNET_NSE_log_estimate_to_n(loge)
Convert the logarithmic estimated returned to the &#39;GNUNET_NSE_Callback&#39; into an absolute estimate in ...
struct GNUNET_TESTBED_Operation * stat_op
Testbed operation to connect to statistics service.
Handle used to access files (and pipes).
struct OpListEntry * next
DLL next ptr.
struct GNUNET_TESTBED_Operation * op
The testbed operation.
#define LOG_DEBUG(...)
Debug logging shorthand.
static struct GNUNET_DISK_FileHandle * output_file
File to report results to.
static void stat_disconnect_adapter(void *cls, void *op_result)
Called to disconnect from peer&#39;s statistics service.
static char * output_filename
Filename to log results to.
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
#define gettext_noop(String)
Definition: gettext.h:69
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966