GNUnet  0.11.x
testbed_api_testbed.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet
3  Copyright (C) 2008--2013 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  */
20 
28 #include "platform.h"
29 #include "gnunet_util_lib.h"
30 #include "gnunet_testbed_service.h"
31 #include "testbed_api.h"
32 #include "testbed_api_peers.h"
33 #include "testbed_api_hosts.h"
34 #include "testbed_api_topology.h"
35 
39 #define LOG(kind, ...) \
40  GNUNET_log_from (kind, "testbed-api-testbed", __VA_ARGS__)
41 
45 #define DEBUG(...) \
46  LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
47 
51 #define DEFAULT_SETUP_TIMEOUT 300
52 
53 
57 #define TESTBED_CONFIG_SECTION "testbed"
58 
63 #define SCALE_FREE_CAP "SCALE_FREE_TOPOLOGY_CAP"
64 
69 #define SCALE_FREE_M "SCALE_FREE_TOPOLOGY_M"
70 
75 {
80 
85 
89  void *cls;
90 };
91 
92 
96 enum State
97 {
101  RC_INIT = 0,
102 
107 
112 
119 
120  /* /\** */
121  /* * Peers are stopped */
122  /* *\/ */
123  /* RC_PEERS_STOPPED, */
124 
125  /* /\** */
126  /* * Peers are destroyed */
127  /* *\/ */
128  /* RC_PEERS_DESTROYED */
129 
134 };
135 
136 
141 {
146 
151 
155  unsigned int index;
156 };
157 
158 
163 {
168 
175 
180 
185 
190 
194  void *cc_cls;
195 
199  char *trusted_ip;
200 
205 
210 
215 
220 
225 
230 
236 
240  char *topo_file;
241 
246 
250  struct GNUNET_TIME_Absolute pstart_time;
251 
256 
261 
266 
270  uint64_t event_mask;
271 
275  enum State state;
276 
281 
285  int shutdown;
286 
290  unsigned int num_hosts;
291 
296  unsigned int reg_hosts;
297 
302  unsigned int peer_count;
303 
307  unsigned int num_peers;
308 
312  unsigned int num_oc;
313 
317  unsigned int random_links;
318 
322  unsigned int links_succeeded;
323 
327  unsigned int links_failed;
328 };
329 
330 
337 static uint32_t
338 rcop_key (void *rcop)
339 {
340  return *((uint32_t *) &rcop);
341 }
342 
343 
347 struct SearchContext
348 {
353 
358 };
359 
360 
369 static int
370 search_iterator (void *cls, uint32_t key, void *value)
371 {
372  struct RunContextOperation *rcop = value;
373  struct SearchContext *sc = cls;
374 
375  GNUNET_assert (NULL != rcop);
376  if (sc->query == rcop->op)
377  {
378  GNUNET_assert (NULL == sc->result);
379  sc->result = rcop;
380  return GNUNET_NO;
381  }
382  return GNUNET_YES;
383 }
384 
385 
394 static struct RunContextOperation *
397 {
398  struct SearchContext sc;
399 
400  sc.query = op;
401  sc.result = NULL;
402  if (GNUNET_SYSERR ==
404  rcop_key (op),
406  &sc))
407  {
408  GNUNET_assert (NULL != sc.result);
409  return sc.result;
410  }
411  return NULL;
412 }
413 
414 
421 static void
423  RunContextOperation *rcop)
424 {
427  rcop_key (rcop->op), rcop,
429 }
430 
431 
439 static void
441  RunContextOperation *rcop)
442 {
445  rcop_key (rcop->op),
446  rcop));
447 }
448 
449 
455 static void
457 {
458  unsigned int hid;
459 
460  GNUNET_assert (NULL == rc->register_hosts_task);
461  GNUNET_assert (NULL == rc->reg_handle);
462  GNUNET_assert (NULL == rc->peers);
463  GNUNET_assert (NULL == rc->hclist);
467  if (NULL != rc->c)
469  if (NULL != rc->cproc)
471  if (NULL != rc->h)
473  for (hid = 0; hid < rc->num_hosts; hid++)
476  if (NULL != rc->cfg)
480  GNUNET_free (rc);
481 }
482 
483 
492 static int
493 rcop_cleanup_iterator (void *cls, uint32_t key, void *value)
494 {
495  struct GNUNET_TESTBED_RunHandle *rc = cls;
496  struct RunContextOperation *rcop = value;
497 
498  GNUNET_assert (rc == rcop->rc);
499  remove_rcop (rc, rcop);
501  GNUNET_free (rcop);
502  return GNUNET_YES;
503 }
504 
505 
511 static void
513 {
514  struct CompatibilityCheckContext *hc;
515  unsigned int nhost;
516 
517  if (NULL != rc->hclist)
518  {
519  for (nhost = 0; nhost < rc->num_hosts; nhost++)
520  {
521  hc = &rc->hclist[nhost];
522  if (NULL != hc->h)
524  }
525  GNUNET_free (rc->hclist);
526  rc->hclist = NULL;
527  }
528  /* Stop register hosts task if it is running */
529  if (NULL != rc->register_hosts_task)
530  {
532  rc->register_hosts_task = NULL;
533  }
534  if (NULL != rc->timeout_task)
535  {
537  rc->timeout_task = NULL;
538  }
539  if (NULL != rc->reg_handle)
540  {
542  rc->reg_handle = NULL;
543  }
544  if (NULL != rc->topology_operation)
545  {
547  rc->topology_operation = NULL;
548  }
549  /* cancel any exiting operations */
553  rc));
554 }
555 
556 
562 static void
564 {
566  rc->interrupt_task = NULL;
567 }
568 
569 
576 static void
578 {
579  struct GNUNET_TESTBED_RunHandle *rc = cls;
580  struct RunContextOperation *rcop;
581 
582  if ((NULL == rc->cproc)
583  || (NULL == rc->c)
584  || (GNUNET_YES == rc->shutdown))
585  {
586  if (NULL != rc->peers)
587  {
588  GNUNET_free (rc->peers);
589  rc->peers = NULL;
590  }
591  goto cleanup_;
592  }
593  if (NULL == rc->peers)
594  goto cleanup_;
595  rc->shutdown = GNUNET_YES;
596  rcop = GNUNET_new (struct RunContextOperation);
597  rcop->rc = rc;
598  rcop->op = GNUNET_TESTBED_shutdown_peers (rc->c, rcop, NULL, NULL);
599  GNUNET_assert (NULL != rcop->op);
600  DEBUG ("Shutting down peers\n");
602  insert_rcop (rc, rcop);
603  return;
604 
605 cleanup_:
606  rc->state = RC_PEERS_SHUTDOWN;
608  cleanup (rc);
609 }
610 
611 
617 static void
618 interrupt (void *cls)
619 {
620  struct GNUNET_TESTBED_RunHandle *rc = cls;
621  struct GNUNET_TESTBED_Controller *c = rc->c;
622  unsigned int size;
623 
624  /* reschedule */
627  if ((GNUNET_NO == rc->shutdown) &&
628  (NULL != c) &&
629  (NULL != c->opc_map) &&
630  (0 != (size = GNUNET_CONTAINER_multihashmap32_size (c->opc_map))))
631  {
633  "Shutdown postponed as there are %u operations currently active\n",
634  size);
636  c->opcq_empty_cls = rc;
637  return;
638  }
639  wait_op_completion (rc);
640 }
641 
642 
650 static const char *
652 {
653  struct GNUNET_TIME_Relative ptime;
654 
657 }
658 
659 
665 static void
667 {
668  struct GNUNET_TESTBED_RunHandle *rc = cls;
669  struct RunContextOperation *rcop;
670  unsigned int peer;
671 
672  DEBUG ("Starting Peers\n");
674  for (peer = 0; peer < rc->num_peers; peer++)
675  {
676  rcop = GNUNET_new (struct RunContextOperation);
677  rcop->rc = rc;
678  rcop->op = GNUNET_TESTBED_peer_start (NULL, rc->peers[peer], NULL, NULL);
679  GNUNET_assert (NULL != rcop->op);
680  rcop->cls = rc->peers[peer];
681  insert_rcop (rc, rcop);
682  }
683  rc->peer_count = 0;
684 }
685 
686 
696 static void
697 peer_create_cb (void *cls, struct GNUNET_TESTBED_Peer *peer, const char *emsg)
698 {
699  struct RunContextOperation *rcop = cls;
701 
702  GNUNET_assert (NULL != rcop);
703  GNUNET_assert (NULL != (rc = rcop->rc));
704  remove_rcop (rc, rcop);
706  GNUNET_free (rcop);
707  if (NULL == peer)
708  {
709  if (NULL != emsg)
710  LOG (GNUNET_ERROR_TYPE_ERROR, "Error while creating a peer: %s\n",
711  emsg);
713  return;
714  }
715  rc->peers[rc->peer_count] = peer;
716  rc->peer_count++;
717  if (rc->peer_count < rc->num_peers)
718  return;
719  DEBUG ("%u peers created in %s\n", rc->num_peers, prof_time (rc));
720  rc->state = RC_PEERS_CREATED;
722 }
723 
724 
730 static void
732 {
734  rc->timeout_task = NULL;
735  if (NULL != rc->test_master)
736  rc->test_master (rc->test_master_cls, rc, rc->num_peers, rc->peers,
737  rc->links_succeeded, rc->links_failed);
738 }
739 
740 
750 static void
751 topology_completion_callback (void *cls, unsigned int nsuccess,
752  unsigned int nfailures)
753 {
754  struct GNUNET_TESTBED_RunHandle *rc = cls;
755 
756  DEBUG ("Overlay topology generated in %s\n", prof_time (rc));
758  rc->topology_operation = NULL;
759  rc->links_succeeded = nsuccess;
760  rc->links_failed = nfailures;
761  rc->state = RC_READY;
762  call_master (rc);
763 }
764 
765 
771 static void
773 {
774  struct RunContextOperation *rcop;
775  unsigned int peer;
776 
777  DEBUG ("Creating peers\n");
779  rc->peers =
780  GNUNET_malloc (sizeof(struct GNUNET_TESTBED_Peer *) * rc->num_peers);
781  GNUNET_assert (NULL != rc->c);
782  rc->peer_count = 0;
783  for (peer = 0; peer < rc->num_peers; peer++)
784  {
785  rcop = GNUNET_new (struct RunContextOperation);
786  rcop->rc = rc;
787  rcop->op =
789  (0 ==
790  rc->num_hosts) ? rc->h : rc->hosts[peer
791  % rc->
792  num_hosts],
793  rc->cfg, &peer_create_cb, rcop);
794  GNUNET_assert (NULL != rcop->op);
795  insert_rcop (rc, rcop);
796  }
797 }
798 
799 
807 static void
808 event_cb (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
809 {
810  struct GNUNET_TESTBED_RunHandle *rc = cls;
811  struct RunContextOperation *rcop;
812 
813  if (RC_INIT == rc->state)
814  {
815  switch (event->type)
816  {
818  rcop = event->op_cls;
819  if (NULL != event->details.operation_finished.emsg)
820  {
822  "Linking controllers failed. Exiting"));
824  }
825  else
826  rc->reg_hosts++;
827  GNUNET_assert (event->op == rcop->op);
828  remove_rcop (rc, rcop);
830  GNUNET_free (rcop);
831  if (rc->reg_hosts == rc->num_hosts)
832  {
833  rc->state = RC_LINKED;
834  create_peers (rc);
835  }
836  return;
837 
838  default:
839  GNUNET_break (0);
841  return;
842  }
843  }
845  goto call_cc;
846  if (NULL == (rcop = search_rcop (rc, event->op)))
847  goto call_cc;
848  remove_rcop (rc, rcop);
850  GNUNET_free (rcop);
851  if ((GNUNET_NO == rc->shutdown)
852  && (NULL != event->details.operation_finished.emsg))
853  {
854  LOG (GNUNET_ERROR_TYPE_ERROR, "A operation has failed with error: %s\n",
855  event->details.operation_finished.emsg);
857  return;
858  }
860  switch (rc->state)
861  {
862  case RC_LINKED:
863  case RC_PEERS_CREATED:
864  case RC_READY:
865  rc->state = RC_PEERS_SHUTDOWN;
867  rc->peers = NULL;
868  DEBUG ("Peers shut down in %s\n", prof_time (rc));
870  break;
871 
872  default:
873  GNUNET_assert (0);
874  }
875  return;
876 
877 call_cc:
878  if ((0 != (rc->event_mask & (1LL << event->type))) && (NULL != rc->cc))
879  rc->cc (rc->cc_cls, event);
880  if (GNUNET_TESTBED_ET_PEER_START != event->type)
881  return;
882  if (NULL == (rcop = search_rcop (rc, event->op))) /* Not our operation */
883  return;
884  remove_rcop (rc, rcop);
886  GNUNET_free (rcop);
887  rc->peer_count++;
888  if (rc->peer_count < rc->num_peers)
889  return;
890  DEBUG ("%u peers started in %s\n", rc->num_peers, prof_time (rc));
892  {
893  switch (rc->topology)
894  {
896  GNUNET_assert (0);
897 
901  rc->topology_operation =
903  rc->peers, &rc->num_oc,
905  rc,
906  rc->topology,
907  rc->random_links,
909  break;
910 
912  GNUNET_assert (NULL != rc->topo_file);
913  rc->topology_operation =
915  rc->peers, &rc->num_oc,
917  rc,
918  rc->topology,
919  rc->topo_file,
921  break;
922 
924  {
925  unsigned long long number;
926  unsigned int cap;
931  &number));
932  cap = (unsigned int) number;
936  SCALE_FREE_M,
937  &number));
938  rc->topology_operation =
940  rc->peers, &rc->num_oc,
941  &
943  rc,
944  rc->topology,
945  cap, /* uint16_t */
946  (unsigned int) number, /* uint8_t */
948  }
949  break;
950 
951  default:
952  rc->topology_operation =
954  rc->peers, &rc->num_oc,
956  rc,
957  rc->topology,
959  }
960  if (NULL == rc->topology_operation)
962  "Not generating a topology. Check number of peers\n");
963  else
964  {
965  DEBUG ("Creating overlay topology\n");
967  return;
968  }
969  }
970  rc->state = RC_READY;
971  call_master (rc);
972 }
973 
974 
980 static void
981 register_hosts (void *cls);
982 
983 
990 static void
991 host_registration_completion (void *cls, const char *emsg)
992 {
993  struct GNUNET_TESTBED_RunHandle *rc = cls;
994 
995  rc->reg_handle = NULL;
996  if (NULL != emsg)
997  {
999  _ ("Host registration failed for a host. Error: %s\n"), emsg);
1001  return;
1002  }
1004  rc);
1005 }
1006 
1007 
1013 static void
1015 {
1016  struct GNUNET_TESTBED_RunHandle *rc = cls;
1017  struct RunContextOperation *rcop;
1018  unsigned int slave;
1019 
1020  rc->register_hosts_task = NULL;
1021  if (rc->reg_hosts == rc->num_hosts)
1022  {
1023  DEBUG ("All hosts successfully registered\n");
1024  /* Start slaves */
1025  for (slave = 0; slave < rc->num_hosts; slave++)
1026  {
1027  rcop = GNUNET_new (struct RunContextOperation);
1028  rcop->rc = rc;
1029  rcop->op =
1030  GNUNET_TESTBED_controller_link (rcop, rc->c, rc->hosts[slave],
1031  rc->h, GNUNET_YES);
1032  GNUNET_assert (NULL != rcop->op);
1033  insert_rcop (rc, rcop);
1034  }
1035  rc->reg_hosts = 0;
1036  return;
1037  }
1038  rc->reg_handle =
1041  rc->reg_hosts++;
1042 }
1043 
1044 
1054 static void
1056  int status)
1057 {
1058  struct GNUNET_TESTBED_RunHandle *rc = cls;
1059  uint64_t event_mask;
1060 
1061  if (status != GNUNET_OK)
1062  {
1063  rc->cproc = NULL;
1065  _ ("Controller crash detected. Shutting down.\n"));
1067  return;
1068  }
1070  rc->cfg = GNUNET_CONFIGURATION_dup (cfg);
1071  event_mask = rc->event_mask;
1072  event_mask |= (1LL << GNUNET_TESTBED_ET_OPERATION_FINISHED);
1073  event_mask |= (1LL << GNUNET_TESTBED_ET_PEER_START);
1075  event_mask |= GNUNET_TESTBED_ET_CONNECT;
1076  rc->c =
1077  GNUNET_TESTBED_controller_connect (rc->h, event_mask, &event_cb, rc);
1078  if (0 < rc->num_hosts)
1079  {
1080  rc->reg_hosts = 0;
1082  return;
1083  }
1084  rc->state = RC_LINKED;
1085  create_peers (rc);
1086 }
1087 
1088 
1101 static int
1102 netint_proc (void *cls, const char *name, int isDefault,
1103  const struct sockaddr *addr, const struct sockaddr *broadcast_addr,
1104  const struct sockaddr *netmask, socklen_t addrlen)
1105 {
1106  struct GNUNET_TESTBED_RunHandle *rc = cls;
1107  char hostip[NI_MAXHOST];
1108  char *buf;
1109 
1110  if (sizeof(struct sockaddr_in) != addrlen)
1111  return GNUNET_OK; /* Only consider IPv4 for now */
1112  if (0 !=
1113  getnameinfo (addr, addrlen, hostip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST))
1115  if (NULL == rc->trusted_ip)
1116  {
1117  rc->trusted_ip = GNUNET_strdup (hostip);
1118  return GNUNET_YES;
1119  }
1120  (void) GNUNET_asprintf (&buf, "%s; %s", rc->trusted_ip, hostip);
1121  GNUNET_free (rc->trusted_ip);
1122  rc->trusted_ip = buf;
1123  return GNUNET_YES;
1124 }
1125 
1126 
1137 static void
1138 host_habitable_cb (void *cls, const struct GNUNET_TESTBED_Host *host,
1139  int status)
1140 {
1141  struct CompatibilityCheckContext *hc = cls;
1142  struct GNUNET_TESTBED_RunHandle *rc;
1143  struct GNUNET_TESTBED_Host **old_hosts;
1144  unsigned int nhost;
1145 
1146  GNUNET_assert (NULL != (rc = hc->rc));
1147  nhost = hc->index;
1148  GNUNET_assert (nhost <= rc->num_hosts);
1149  GNUNET_assert (host == rc->hosts[nhost]);
1150  hc->h = NULL;
1151  if (GNUNET_NO == status)
1152  {
1153  if ((NULL != host) && (NULL != GNUNET_TESTBED_host_get_hostname (host)))
1154  LOG (GNUNET_ERROR_TYPE_ERROR, _ ("Host %s cannot start testbed\n"),
1156  else
1158  _ ("Testbed cannot be started on localhost\n"));
1160  return;
1161  }
1162  rc->reg_hosts++;
1163  if (rc->reg_hosts < rc->num_hosts)
1164  return;
1165  GNUNET_free (rc->hclist);
1166  rc->hclist = NULL;
1167  rc->h = rc->hosts[0];
1168  rc->num_hosts--;
1169  if (0 < rc->num_hosts)
1170  {
1171  old_hosts = rc->hosts;
1172  rc->hosts =
1173  GNUNET_malloc (sizeof(struct GNUNET_TESTBED_Host *) * rc->num_hosts);
1174  GNUNET_memcpy (rc->hosts, &old_hosts[1],
1175  (sizeof(struct GNUNET_TESTBED_Host *) * rc->num_hosts));
1176  GNUNET_free (old_hosts);
1177  }
1178  else
1179  {
1180  GNUNET_free (rc->hosts);
1181  rc->hosts = NULL;
1182  }
1184  for (nhost = 0; nhost < rc->num_hosts; nhost++)
1185  GNUNET_TESTBED_host_resolve_ (rc->hosts[nhost]);
1187  if (NULL == rc->trusted_ip)
1188  rc->trusted_ip = GNUNET_strdup ("127.0.0.1");
1189  rc->cproc =
1191  &controller_status_cb, rc);
1192  GNUNET_free (rc->trusted_ip);
1193  rc->trusted_ip = NULL;
1194  if (NULL == rc->cproc)
1195  {
1196  LOG (GNUNET_ERROR_TYPE_ERROR, _ ("Cannot start the master controller"));
1198  }
1199 }
1200 
1201 
1207 static void
1209 {
1210  struct GNUNET_TESTBED_RunHandle *rc = cls;
1211 
1212  rc->timeout_task = NULL;
1214  _ ("Shutting down testbed due to timeout while setup.\n"));
1216  if (NULL != rc->test_master)
1217  rc->test_master (rc->test_master_cls, rc, 0, NULL, 0, 0);
1218  rc->test_master = NULL;
1219 }
1220 
1221 
1249 void
1251  const struct GNUNET_CONFIGURATION_Handle *cfg,
1252  unsigned int num_peers, uint64_t event_mask,
1255  void *test_master_cls)
1256 {
1257  struct GNUNET_TESTBED_RunHandle *rc;
1258  char *topology;
1259  struct CompatibilityCheckContext *hc;
1260  struct GNUNET_TIME_Relative timeout;
1261  unsigned long long number;
1262  unsigned int hid;
1263  unsigned int nhost;
1264 
1265  GNUNET_assert (num_peers > 0);
1266  rc = GNUNET_new (struct GNUNET_TESTBED_RunHandle);
1267  rc->cfg = GNUNET_CONFIGURATION_dup (cfg);
1268 #if ENABLE_SUPERMUC
1270  &rc->hosts);
1271  if (0 == rc->num_hosts)
1272  {
1274  _ ("No hosts loaded from LoadLeveler. Need at least one host\n"));
1275  goto error_cleanup;
1276  }
1277 #else
1278  if (NULL != host_filename)
1279  {
1280  rc->num_hosts =
1281  GNUNET_TESTBED_hosts_load_from_file (host_filename, rc->cfg,
1282  &rc->hosts);
1283  if (0 == rc->num_hosts)
1284  {
1286  _ ("No hosts loaded. Need at least one host\n"));
1287  goto error_cleanup;
1288  }
1289  }
1290  else
1291  rc->h = GNUNET_TESTBED_host_create (NULL, NULL, rc->cfg, 0);
1292 #endif
1293  rc->num_peers = num_peers;
1294  rc->event_mask = event_mask;
1295  rc->cc = cc;
1296  rc->cc_cls = cc_cls;
1297  rc->test_master = test_master;
1298  rc->test_master_cls = test_master_cls;
1299  rc->state = RC_INIT;
1301  if (GNUNET_OK ==
1303  "OVERLAY_TOPOLOGY", &topology))
1304  {
1305  if (GNUNET_NO == GNUNET_TESTBED_topology_get_ (&rc->topology, topology))
1306  {
1309  "OVERLAY_TOPLOGY",
1310  _
1311  (
1312  "Specified topology must be supported by testbed"));
1313  }
1314  GNUNET_free (topology);
1315  }
1316  switch (rc->topology)
1317  {
1321  if (GNUNET_OK !=
1323  "OVERLAY_RANDOM_LINKS",
1324  &number))
1325  {
1326  /* OVERLAY option RANDOM & SMALL_WORLD_RING requires OVERLAY_RANDOM_LINKS
1327  * option to be set to the number of random links to be established */
1330  "OVERLAY_RANDOM_LINKS");
1331  goto error_cleanup;
1332  }
1333  if (number > UINT32_MAX)
1334  {
1335  GNUNET_break (0); /* Too big number */
1336  goto error_cleanup;
1337  }
1338  rc->random_links = (unsigned int) number;
1339  break;
1340 
1342  if (GNUNET_OK !=
1345  "OVERLAY_TOPOLOGY_FILE",
1346  &rc->topo_file))
1347  {
1350  "OVERLAY_TOPOLOGY_FILE");
1351  goto error_cleanup;
1352  }
1353  goto warn_ignore;
1354 
1356  if (GNUNET_OK !=
1358  SCALE_FREE_CAP, &number))
1359  {
1362  SCALE_FREE_CAP);
1363  goto error_cleanup;
1364  }
1365  if (UINT16_MAX < number)
1366  {
1368  _ ("Maximum number of edges a peer can have in a scale free topology"
1369  " cannot be more than %u. Given `%s = %llu'"), UINT16_MAX,
1370  SCALE_FREE_CAP, number);
1371  goto error_cleanup;
1372  }
1373  if (GNUNET_OK !=
1375  SCALE_FREE_M, &number))
1376  {
1379  SCALE_FREE_M);
1380  goto error_cleanup;
1381  }
1382  if (UINT8_MAX < number)
1383  {
1385  _ ("The number of edges that can established when adding a new node"
1386  " to scale free topology cannot be more than %u. Given `%s = %llu'"),
1387  UINT8_MAX, SCALE_FREE_M, number);
1388  goto error_cleanup;
1389  }
1390  goto warn_ignore;
1391 
1393  /* not allowed! */
1394  GNUNET_assert (0);
1395 
1396  default:
1397 warn_ignore:
1398  /* Warn if OVERLAY_RANDOM_LINKS is present that it will be ignored */
1399  if (GNUNET_YES ==
1401  "OVERLAY_RANDOM_LINKS"))
1403  "Ignoring value of `OVERLAY_RANDOM_LINKS' in given configuration\n");
1404  break;
1405  }
1406  if (0 != rc->num_hosts)
1407  {
1408  rc->hclist = GNUNET_malloc (sizeof(struct CompatibilityCheckContext)
1409  * rc->num_hosts);
1410  for (nhost = 0; nhost < rc->num_hosts; nhost++)
1411  {
1412  hc = &rc->hclist[nhost];
1413  hc->index = nhost;
1414  hc->rc = rc;
1415  hc->h = GNUNET_TESTBED_is_host_habitable (rc->hosts[nhost], rc->cfg,
1416  &host_habitable_cb, hc);
1417  if (NULL == hc->h)
1418  {
1419  GNUNET_break (0);
1420  for (nhost = 0; nhost < rc->num_hosts; nhost++)
1421  {
1422  hc = &rc->hclist[nhost];
1423  if (NULL != hc->h)
1425  }
1426  GNUNET_free (rc->hclist);
1427  rc->hclist = NULL;
1428  goto error_cleanup;
1429  }
1430  }
1431  }
1432  else
1433  rc->cproc =
1434  GNUNET_TESTBED_controller_start ("127.0.0.1", rc->h,
1435  &controller_status_cb, rc);
1438  "SETUP_TIMEOUT",
1439  &timeout))
1440  {
1443  }
1445  rc->timeout_task =
1447  GNUNET_assert (NULL == rc->interrupt_task);
1448  rc->interrupt_task =
1450  rc);
1451  return;
1452 
1453 error_cleanup:
1454  if (NULL != rc->h)
1456  if (NULL != rc->hosts)
1457  {
1458  for (hid = 0; hid < rc->num_hosts; hid++)
1459  if (NULL != rc->hosts[hid])
1461  GNUNET_free (rc->hosts);
1462  }
1463  if (NULL != rc->cfg)
1465  GNUNET_free (rc);
1466 }
1467 
1468 
1478 {
1479  return h->c;
1480 }
1481 
1482 
1483 /* end of testbed_api_testbed.c */
static void start_peers_task(void *cls)
Task for starting peers.
void GNUNET_TESTBED_cancel_registration(struct GNUNET_TESTBED_HostRegistrationHandle *handle)
Cancel the pending registration.
Context information for the operation we start.
unsigned int index
Index of the host in the run context&#39;s hosts array.
void GNUNET_TESTBED_controller_disconnect(struct GNUNET_TESTBED_Controller *c)
Stop the given controller (also will terminate all peers and controllers dependent on this controller...
Definition: testbed_api.c:1720
enum State state
State of this context.
int GNUNET_CONFIGURATION_get_value_time(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, struct GNUNET_TIME_Relative *time)
Get a configuration value that should be a relative time.
unsigned int links_succeeded
the number of overlay link connection attempts that succeeded
struct GNUNET_TESTBED_HostHabitableCheckHandle * GNUNET_TESTBED_is_host_habitable(const struct GNUNET_TESTBED_Host *host, const struct GNUNET_CONFIGURATION_Handle *config, GNUNET_TESTBED_HostHabitableCallback cb, void *cb_cls)
Checks whether a host can be used to start testbed service.
static void timeout_task(void *cls)
Task run upon timeout while setting up the testbed.
int GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
GNUNET_TESTBED_TopologyOption
Topologies and topology options supported for testbeds.
struct GNUNET_SCHEDULER_Task * timeout_task
Task to be run of a timeout.
Handle to interact with a GNUnet testbed controller.
Definition: testbed_api.h:193
void * cc_cls
The pointer to the controller callback.
void GNUNET_TESTBED_is_host_habitable_cancel(struct GNUNET_TESTBED_HostHabitableCheckHandle *handle)
Function to cancel a request started using GNUNET_TESTBED_is_host_habitable()
unsigned int links_failed
the number of overlay link connection attempts that failed
static void test_master(void *cls, struct GNUNET_TESTBED_RunHandle *h, unsigned int num_peers, struct GNUNET_TESTBED_Peer **started_peers, unsigned int links_succeeded, unsigned int links_failed)
Signature of a main function for a testcase.
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
static void event_cb(void *cls, const struct GNUNET_TESTBED_EventInformation *event)
Signature of the event handler function called by the respective event controller.
TESTBED_opcq_empty_cb opcq_empty_cb
If this callback is not NULL, schedule it as a task when opc_map gets empty.
Definition: testbed_api.h:234
int GNUNET_CONTAINER_multihashmap32_iterate(struct GNUNET_CONTAINER_MultiHashMap32 *map, GNUNET_CONTAINER_MulitHashMapIterator32Callback it, void *it_cls)
Iterate over all entries in the map.
struct GNUNET_TESTBED_Operation * op
The testbed operation handle.
struct GNUNET_CONTAINER_MultiHashMap32 * rcop_map
A hashmap for operations started by us.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_TESTBED_HostRegistrationHandle * reg_handle
Host registration handle.
struct GNUNET_TESTBED_RunHandle * rc
Context information for GNUNET_TESTBED_run()
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_controller_link(void *op_cls, struct GNUNET_TESTBED_Controller *master, struct GNUNET_TESTBED_Host *delegated_host, struct GNUNET_TESTBED_Host *slave_host, int is_subordinate)
Create a link from slave controller to delegated controller.
Definition: testbed_api.c:1831
static void wait_op_completion(void *cls)
This callback will be called when all the operations are completed (done/cancelled) ...
#define GNUNET_TIME_UNIT_SECONDS
One second.
All peers are disconnected.
unsigned int num_oc
Expected overlay connects.
void GNUNET_TESTBED_controller_stop(struct GNUNET_TESTBED_ControllerProc *cproc)
Stop the controller process (also will terminate all peers and controllers dependent on this controll...
static void insert_rcop(struct GNUNET_TESTBED_RunHandle *rc, struct RunContextOperation *rcop)
Insert an RunContextOperation into the rcop_map of the given RunContext.
struct GNUNET_TESTBED_ControllerProc * cproc
The handle to the controller process.
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_peer_start(void *op_cls, struct GNUNET_TESTBED_Peer *peer, GNUNET_TESTBED_PeerChurnCallback pcc, void *pcc_cls)
Start the given peer.
static struct RunContextOperation * search_rcop(struct GNUNET_TESTBED_RunHandle *rc, struct GNUNET_TESTBED_Operation *op)
Initiate a search for the given operation in the rcop_map.
struct GNUNET_TESTBED_EventInformation::@55::@60 operation_finished
Details about an operation finished event.
char * trusted_ip
The trusted IP string.
Context for host compability checks.
Argument to GNUNET_TESTBED_ControllerCallback with details about the event.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define TESTBED_CONFIG_SECTION
Configuration section for testbed.
struct GNUNET_TESTBED_Controller * c
The controller handle.
void(* GNUNET_TESTBED_ControllerCallback)(void *cls, const struct GNUNET_TESTBED_EventInformation *event)
Signature of the event handler function called by the respective event controller.
unsigned int num_peers
number of peers to start
#define GNUNET_NO
Definition: gnunet_common.h:78
#define DEFAULT_SETUP_TIMEOUT
The default setup timeout in seconds.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
enum GNUNET_TESTBED_EventType type
Type of the event.
enum GNUNET_TESTBED_TopologyOption topology
The topology to generate.
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
static void interrupt(void *cls)
Task run upon interrupts (SIGINT, SIGTERM) and upon scheduler shutdown.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
void GNUNET_OS_network_interfaces_list(GNUNET_OS_NetworkInterfaceProcessor proc, void *proc_cls)
Enumerate all network interfaces.
Definition: os_network.c:396
int GNUNET_CONTAINER_multihashmap32_get_multiple(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, GNUNET_CONTAINER_MulitHashMapIterator32Callback it, void *it_cls)
Iterate over all entries in the map that match a particular key.
void GNUNET_log_config_invalid(enum GNUNET_ErrorType kind, const char *section, const char *option, const char *required)
Log error message about invalid configuration option value.
The testbed run is ready and the master callback can be called now.
Opaque handle to a host running experiments managed by the testing framework.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:526
struct GNUNET_TIME_Absolute pstart_time
Profiling start time.
Handle for controller process.
struct GNUNET_SCHEDULER_Task * interrupt_task
Task run upon shutdown interrupts.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
void(* GNUNET_TESTBED_TestMaster)(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.
int GNUNET_CONTAINER_multihashmap32_put(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
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.
uint32_t number
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
struct GNUNET_TESTBED_Host * h
Handle to the host on which the controller runs.
static uint32_t rcop_key(void *rcop)
Return a 32-bit key from a pointer.
Read a topology from a given file.
#define SCALE_FREE_M
Option string for the number of edges to be established when adding a new node to the scale free netw...
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
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
static int search_iterator(void *cls, uint32_t key, void *value)
Iterator for searching over the elements matching a given query.
enum State state
current state of profiling
struct GNUNET_TESTBED_HostHabitableCheckHandle * h
Handle for the compability check.
int GNUNET_CONTAINER_multihashmap32_remove(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, const void *value)
Remove the given key-value pair from the map.
#define LOG(kind,...)
Generic loggins shorthand.
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
static char * value
Value of the record to add/remove.
char * topo_file
The file containing topology data.
struct CompatibilityCheckContext * hclist
Array of compatibility check contexts.
struct GNUNET_TESTBED_Operation * topology_operation
The topology generation operation.
static void create_peers(struct GNUNET_TESTBED_RunHandle *rc)
Function to create peers.
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
void GNUNET_TESTBED_host_resolve_(struct GNUNET_TESTBED_Host *host)
Resolves the hostname of the host to an ip address.
The handle for whether a host is habitable or not.
int GNUNET_CONFIGURATION_have_value(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
Test if we have a value for a particular option.
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_overlay_configure_topology(void *op_cls, unsigned int num_peers, struct GNUNET_TESTBED_Peer **peers, unsigned int *max_connections, GNUNET_TESTBED_TopologyCompletionCallback comp_cb, void *comp_cb_cls, enum GNUNET_TESTBED_TopologyOption topo,...)
All peers must have been started before calling this function.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:687
A requested testbed operation has been completed.
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
unsigned int GNUNET_CONTAINER_multihashmap32_size(const struct GNUNET_CONTAINER_MultiHashMap32 *map)
Get the number of key-value pairs in the map.
uint16_t status
See PRISM_STATUS_*-constants.
static char buf[2048]
struct GNUNET_CONTAINER_MultiHashMap32 * opc_map
The map of active operation contexts.
Definition: testbed_api.h:229
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:442
struct GNUNET_TESTBED_RunHandle * rc
The run context.
unsigned int reg_hosts
Number of registered hosts.
static void call_master(struct GNUNET_TESTBED_RunHandle *rc)
call test master callback
Internal representation of the hash map.
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
#define DEBUG(...)
Debug logging shortcut.
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
struct GNUNET_CONTAINER_MultiHashMap32 * GNUNET_CONTAINER_multihashmap32_create(unsigned int len)
Create a 32-bit key multi hash map.
The options should always end with this.
struct GNUNET_TESTBED_Controller * GNUNET_TESTBED_run_get_controller_handle(struct GNUNET_TESTBED_RunHandle *h)
Obtain handle to the master controller from a testbed run.
void GNUNET_CONTAINER_multihashmap32_destroy(struct GNUNET_CONTAINER_MultiHashMap32 *map)
Destroy a 32-bit key hash map.
int GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
static void peer_create_cb(void *cls, struct GNUNET_TESTBED_Peer *peer, const char *emsg)
Functions of this signature are called when a peer has been successfully created. ...
union GNUNET_TESTBED_EventInformation::@55 details
Details about the event.
uint64_t event_mask
Global event mask for all testbed events.
struct GNUNET_TESTBED_Host * GNUNET_TESTBED_host_create(const char *hostname, const char *username, const struct GNUNET_CONFIGURATION_Handle *cfg, uint16_t port)
Create a host to run peers and controllers on.
Controllers on given hosts started and linked.
void GNUNET_TESTBED_host_destroy(struct GNUNET_TESTBED_Host *host)
Destroy a host handle.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
struct GNUNET_HashCode key
The key used in the DHT.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static unsigned int size
Size of the "table".
Definition: peer.c:67
struct RunContextOperation * result
The Run context operation which has the operation being queried.
static void topology_completion_callback(void *cls, unsigned int nsuccess, unsigned int nfailures)
Callbacks of this type are called when topology configuration is completed.
static int netint_proc(void *cls, const char *name, int isDefault, const struct sockaddr *addr, const struct sockaddr *broadcast_addr, const struct sockaddr *netmask, socklen_t addrlen)
Callback function invoked for each interface found.
Small-world network (2d torus plus random links).
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
struct GNUNET_TESTBED_Controller * GNUNET_TESTBED_controller_connect(struct GNUNET_TESTBED_Host *host, uint64_t event_mask, GNUNET_TESTBED_ControllerCallback cc, void *cc_cls)
Connect to a controller process.
Definition: testbed_api.c:1554
State
Available states during profiling.
Peers are created.
A connection between two peers was established.
static unsigned int num_peers
Initial state.
struct GNUNET_TESTBED_Operation * query
The operation pointer to look for.
static void host_registration_completion(void *cls, const char *emsg)
Callback which will be called to after a host registration succeeded or failed.
static void cancel_interrupt_task(struct GNUNET_TESTBED_RunHandle *rc)
Cancels the scheduled interrupt task.
static char * host_filename
Data file with the hosts for the testbed.
internal API to access the &#39;peers&#39; subsystem
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_dup(const struct GNUNET_CONFIGURATION_Handle *cfg)
Duplicate an existing configuration object.
Interface for functions internally exported from testbed_api.c.
Allow multiple values with the same key.
void * opcq_empty_cls
Closure for the above task.
Definition: testbed_api.h:239
void * test_master_cls
The closure for the TestMaster callback.
unsigned int peer_count
Current peer count for an operation; Set this to 0 and increment for each successful operation on a p...
const char * GNUNET_TESTBED_host_get_hostname(const struct GNUNET_TESTBED_Host *host)
Obtain the host&#39;s hostname.
Context information to be used while searching for operation contexts.
Definition: testbed_api.c:225
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_shutdown_peers(struct GNUNET_TESTBED_Controller *c, void *op_cls, GNUNET_TESTBED_OperationCompletionCallback cb, void *cb_cls)
Stops and destroys all peers.
Definition: testbed_api.c:2282
GNUNET_TESTBED_ControllerCallback cc
The callback to use as controller callback.
static void rc_cleanup_operations(struct GNUNET_TESTBED_RunHandle *rc)
Cancels operations and tasks which are assigned to the given run context.
configuration data
Definition: configuration.c:85
unsigned int random_links
Number of random links to established.
enum GNUNET_TESTBED_TopologyOption topology
The topology which has to be achieved with the peers started in this context.
const char * name
static void remove_rcop(struct GNUNET_TESTBED_RunHandle *rc, struct RunContextOperation *rcop)
Remove a RunContextOperation from the rcop_map of the given RunContext.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:375
unsigned int GNUNET_TESTBED_hosts_load_from_loadleveler(const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_TESTBED_Host ***hosts)
Loads the set of host allocated by the LoadLeveler Job Scheduler.
static void cleanup(struct GNUNET_TESTBED_RunHandle *rc)
Assuming all peers have been destroyed cleanup run handle.
#define GNUNET_log(kind,...)
Entry in list of pending tasks.
Definition: scheduler.c:134
unsigned int num_hosts
Number of hosts in the given host file.
int GNUNET_CONFIGURATION_get_value_filename(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be the name of a file or directory.
int shutdown
Have we already shutdown.
struct GNUNET_TESTBED_Peer ** peers
Array of peers which we create.
handle for host registration
struct GNUNET_CONFIGURATION_Handle * cfg
The configuration of the controller.
struct GNUNET_TESTBED_Host ** hosts
An array of hosts loaded from the hostkeys file.
Time for absolute times used by GNUnet, in microseconds.
#define GNUNET_YES
Definition: gnunet_common.h:77
internal API to access the &#39;hosts&#39; subsystem
struct GNUNET_SCHEDULER_Task * register_hosts_task
Host registration task.
A peer controlled by the testing framework.
static void controller_status_cb(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg, int status)
Callback to signal successfull startup of the controller process.
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_peer_create(struct GNUNET_TESTBED_Controller *controller, struct GNUNET_TESTBED_Host *host, const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_TESTBED_PeerCreateCallback cb, void *cls)
Create the given peer at the specified host using the given controller.
static int rcop_cleanup_iterator(void *cls, uint32_t key, void *value)
Iterator for cleaning up elements from rcop_map.
struct GNUNET_TESTBED_HostRegistrationHandle * GNUNET_TESTBED_register_host(struct GNUNET_TESTBED_Controller *controller, struct GNUNET_TESTBED_Host *host, GNUNET_TESTBED_HostRegistrationCompletion cc, void *cc_cls)
Register a host with the controller.
static const char * prof_time(struct GNUNET_TESTBED_RunHandle *rc)
Function to return the string representation of the duration between current time and `pstart_time&#39; i...
header for intra library exported functions
static void register_hosts(void *cls)
Task to register all hosts available in the global host list.
struct GNUNET_TESTBED_ControllerProc * GNUNET_TESTBED_controller_start(const char *trusted_ip, struct GNUNET_TESTBED_Host *host, GNUNET_TESTBED_ControllerStatusCallback cb, void *cls)
Starts a controller process at the given host.
#define GNUNET_malloc(size)
Wrapper around malloc.
unsigned int GNUNET_TESTBED_hosts_load_from_file(const char *filename, const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_TESTBED_Host ***hosts)
Load a set of hosts from a configuration file.
static void host_habitable_cb(void *cls, const struct GNUNET_TESTBED_Host *host, int status)
Callbacks of this type are called by GNUNET_TESTBED_is_host_habitable to inform whether the given hos...
#define GNUNET_free(ptr)
Wrapper around free.
int GNUNET_TESTBED_topology_get_(enum GNUNET_TESTBED_TopologyOption *topology, const char *topology_string)
Get a topology from a string input.
uint64_t event_mask
The event mask for the controller.
Time for relative time used by GNUnet, in microseconds.
GNUNET_TESTBED_TestMaster test_master
TestMaster callback to call when testbed initialization is done.
All peers shutdown (stopped and destroyed)
struct GNUNET_TESTBED_Operation * op
Handle for the corresponding operation that generated this event.
Small-world network (ring plus random links).
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
#define SCALE_FREE_CAP
Option string for the maximum number of edges a peer is permitted to have while generating scale free...