0b998cf9599ed0cf77aad8260234de120f593dba
[oweals/gnunet.git] / src / include / gnunet_testing_lib.h
1 /*
2       This file is part of GNUnet
3       (C) 2008, 2009 Christian Grothoff (and other contributing authors)
4
5       GNUnet is free software; you can redistribute it and/or modify
6       it under the terms of the GNU General Public License as published
7       by the Free Software Foundation; either version 3, or (at your
8       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       General Public License for more details.
14
15       You should have received a copy of the GNU General Public License
16       along with GNUnet; see the file COPYING.  If not, write to the
17       Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18       Boston, MA 02111-1307, USA.
19  */
20
21 /**
22  * @file include/gnunet_testing_lib.h
23  * @brief convenience API for writing testcases for GNUnet
24  *        Many testcases need to start and stop gnunetd,
25  *        and this library is supposed to make that easier
26  *        for TESTCASES.  Normal programs should always
27  *        use functions from gnunet_{util,arm}_lib.h.  This API is
28  *        ONLY for writing testcases!
29  * @author Christian Grothoff
30  */
31
32 #ifndef GNUNET_TESTING_LIB_H
33 #define GNUNET_TESTING_LIB_H
34
35 #include "gnunet_util_lib.h"
36 #include "gnunet_statistics_service.h"
37
38 #ifdef __cplusplus
39 extern "C"
40 {
41 #if 0                           /* keep Emacsens' auto-indent happy */
42 }
43 #endif
44 #endif
45
46 #define HOSTKEYFILESIZE 914
47
48 /**
49  * Handle for a GNUnet daemon (technically a set of
50  * daemons; the handle is really for the master ARM
51  * daemon) started by the testing library.
52  */
53 struct GNUNET_TESTING_Daemon;
54
55 /**
56  * Linked list of hostnames and ports to use for starting daemons.
57  */
58 struct GNUNET_TESTING_Host
59 {
60   /**
61    * Pointer to next item in the list.
62    */
63   struct GNUNET_TESTING_Host *next;
64
65   /**
66    * Hostname to connect to.
67    */
68   char *hostname;
69
70   /**
71    * Username to use when connecting (may be null).
72    */
73   char *username;
74
75   /**
76    * Port to use for SSH connection (used for ssh
77    * connection forwarding, 0 to let ssh decide)
78    */
79   uint16_t port;
80 };
81
82 /**
83  * Prototype of a function that will be called whenever
84  * a daemon was started by the testing library.
85  *
86  * @param cls closure
87  * @param id identifier for the daemon, NULL on error
88  * @param d handle for the daemon
89  * @param emsg error message (NULL on success)
90  */
91 typedef void (*GNUNET_TESTING_NotifyHostkeyCreated)(void *cls,
92                                                     const struct GNUNET_PeerIdentity *id,
93                                                     struct GNUNET_TESTING_Daemon *d,
94                                                     const char *emsg);
95
96 /**
97  * Prototype of a function that will be called whenever
98  * a daemon was started by the testing library.
99  *
100  * @param cls closure
101  * @param id identifier for the daemon, NULL on error
102  * @param cfg configuration used by this daemon
103  * @param d handle for the daemon
104  * @param emsg error message (NULL on success)
105  */
106 typedef void (*GNUNET_TESTING_NotifyDaemonRunning)(void *cls,
107                                                    const struct GNUNET_PeerIdentity *id,
108                                                    const struct GNUNET_CONFIGURATION_Handle *cfg,
109                                                    struct GNUNET_TESTING_Daemon *d,
110                                                    const char *emsg);
111
112
113 /**
114  * Handle to an entire testbed of GNUnet peers.
115  */
116 struct GNUNET_TESTING_Testbed;
117
118 /**
119  * Phases of starting GNUnet on a system.
120  */
121 enum GNUNET_TESTING_StartPhase
122 {
123   /**
124    * Copy the configuration file to the target system.
125    */
126   SP_COPYING,
127
128   /**
129    * Configuration file has been copied, generate hostkey.
130    */
131   SP_COPIED,
132
133   /**
134    * Create the hostkey for the peer.
135    */
136   SP_HOSTKEY_CREATE,
137
138   /**
139    * Hostkey generated, wait for topology to be finished.
140    */
141   SP_HOSTKEY_CREATED,
142
143   /**
144    * Topology has been created, now start ARM.
145    */
146   SP_TOPOLOGY_SETUP,
147
148   /**
149    * ARM has been started, check that it has properly daemonized and
150    * then try to connect to the CORE service (which should be
151    * auto-started by ARM).
152    */
153   SP_START_ARMING,
154
155   /**
156    * We're waiting for CORE to start.
157    */
158   SP_START_CORE,
159
160   /**
161    * CORE is up, now make sure we get the HELLO for this peer.
162    */
163   SP_GET_HELLO,
164
165   /**
166    * Core has notified us that we've established a connection to the service.
167    * The main FSM halts here and waits to be moved to UPDATE or CLEANUP.
168    */
169   SP_START_DONE,
170
171   /**
172    * We've been asked to terminate the instance and are now waiting for
173    * the remote command to stop the gnunet-arm process and delete temporary
174    * files.
175    */
176   SP_SHUTDOWN_START,
177
178   /**
179    * We should shutdown a *single* service via gnunet-arm.  Call the dead_cb
180    * upon notification from gnunet-arm that the service has been stopped.
181    */
182   SP_SERVICE_SHUTDOWN_START,
183
184   /**
185    * We should start a *single* service via gnunet-arm.  Call the daemon cb
186    * upon notification from gnunet-arm that the service has been started.
187    */
188   SP_SERVICE_START,
189
190   /**
191    * We've received a configuration update and are currently waiting for
192    * the copy process for the update to complete.  Once it is, we will
193    * return to "SP_START_DONE" (and rely on ARM to restart all affected
194    * services).
195    */
196   SP_CONFIG_UPDATE
197 };
198
199 /**
200  * Prototype of a function that will be called when a
201  * particular operation was completed the testing library.
202  *
203  * @param cls closure
204  * @param emsg NULL on success
205  */
206 typedef void (*GNUNET_TESTING_NotifyCompletion)(void *cls,
207                                                 const char *emsg);
208
209 /**
210  * Prototype of a function that will be called with the
211  * number of connections created for a particular topology.
212  *
213  * @param cls closure
214  * @param num_connections the number of connections created
215  */
216 typedef void (*GNUNET_TESTING_NotifyConnections)(void *cls,
217                                                 unsigned int num_connections);
218
219 /**
220  * Handle for a GNUnet daemon (technically a set of
221  * daemons; the handle is really for the master ARM
222  * daemon) started by the testing library.
223  */
224 struct GNUNET_TESTING_Daemon
225 {
226   /**
227    * Our configuration.
228    */
229   struct GNUNET_CONFIGURATION_Handle *cfg;
230
231   /**
232    * At what time to give up starting the peer
233    */
234   struct GNUNET_TIME_Absolute max_timeout;
235
236   /**
237    * Host to run GNUnet on.
238    */
239   char *hostname;
240
241   /**
242    * Port to use for ssh, NULL to let system choose default.
243    */
244   char *ssh_port_str;
245
246   /**
247    * Result of GNUNET_i2s of this peer,
248    * for printing
249    */
250   char *shortname;
251
252   /**
253    * Username we are using.
254    */
255   char *username;
256
257   /**
258    * Name of the configuration file
259    */
260   char *cfgfile;
261
262   /**
263    * Callback to inform initiator that the peer's
264    * hostkey has been created.
265    */
266   GNUNET_TESTING_NotifyHostkeyCreated hostkey_callback;
267
268   /**
269    * Closure for hostkey creation callback.
270    */
271   void *hostkey_cls;
272
273   /**
274    * Function to call when the peer is running.
275    */
276   GNUNET_TESTING_NotifyDaemonRunning cb;
277
278   /**
279    * Closure for cb.
280    */
281   void *cb_cls;
282
283   /**
284    * Arguments from "daemon_stop" call.
285    */
286   GNUNET_TESTING_NotifyCompletion dead_cb;
287
288   /**
289    * Closure for 'dead_cb'.
290    */
291   void *dead_cb_cls;
292
293   /**
294    * Arguments from "daemon_stop" call.
295    */
296   GNUNET_TESTING_NotifyCompletion update_cb;
297
298   /**
299    * Closure for 'update_cb'.
300    */
301   void *update_cb_cls;
302
303   /**
304    * Identity of this peer (once started).
305    */
306   struct GNUNET_PeerIdentity id;
307
308   /**
309    * Flag to indicate that we've already been asked
310    * to terminate (but could not because some action
311    * was still pending).
312    */
313   int dead;
314
315   /**
316    * GNUNET_YES if the hostkey has been created
317    * for this peer, GNUNET_NO otherwise.
318    */
319   int have_hostkey;
320
321   /**
322    * PID of the process that we started last.
323    */
324   struct GNUNET_OS_Process *proc;
325
326   /**
327    * In which phase are we during the start of
328    * this process?
329    */
330   enum GNUNET_TESTING_StartPhase phase;
331
332   /**
333    * ID of the current task.
334    */
335   GNUNET_SCHEDULER_TaskIdentifier task;
336
337   /**
338    * Handle to the server.
339    */
340   struct GNUNET_CORE_Handle *server;
341
342   /**
343    * Handle to the transport service of this peer
344    */
345   struct GNUNET_TRANSPORT_Handle *th;
346
347   /**
348    * HELLO message for this peer
349    */
350   struct GNUNET_HELLO_Message *hello;
351
352   /**
353    * Handle to a pipe for reading the hostkey.
354    */
355   struct GNUNET_DISK_PipeHandle *pipe_stdout;
356
357   /**
358    * Output from gnunet-peerinfo is read into this buffer.
359    */
360   char hostkeybuf[105];
361
362   /**
363    * Current position in 'hostkeybuf' (for reading from gnunet-peerinfo)
364    */
365   unsigned int hostkeybufpos;
366
367   /**
368    * Set to GNUNET_YES once the peer is up.
369    */
370   int running;
371
372   /**
373    * Used to tell shutdown not to remove configuration for the peer
374    * (if it's going to be restarted later)
375    */
376   int churn;
377
378   /**
379    * Currently, a single char * pointing to a service
380    * that has been churned off.
381    *
382    * FIXME: make this a linked list of services that have been churned off!!!
383    */
384   char *churned_services;
385 };
386
387
388 /**
389  * Handle to a group of GNUnet peers.
390  */
391 struct GNUNET_TESTING_PeerGroup;
392
393
394 /**
395  * Prototype of a function that will be called whenever
396  * two daemons are connected by the testing library.
397  *
398  * @param cls closure
399  * @param first peer id for first daemon
400  * @param second peer id for the second daemon
401  * @param distance distance between the connected peers
402  * @param first_cfg config for the first daemon
403  * @param second_cfg config for the second daemon
404  * @param first_daemon handle for the first daemon
405  * @param second_daemon handle for the second daemon
406  * @param emsg error message (NULL on success)
407  */
408 typedef void (*GNUNET_TESTING_NotifyConnection)(void *cls,
409                                                 const struct GNUNET_PeerIdentity *first,
410                                                 const struct GNUNET_PeerIdentity *second,
411                                                 uint32_t distance,
412                                                 const struct GNUNET_CONFIGURATION_Handle *first_cfg,
413                                                 const struct GNUNET_CONFIGURATION_Handle *second_cfg,
414                                                 struct GNUNET_TESTING_Daemon *first_daemon,
415                                                 struct GNUNET_TESTING_Daemon *second_daemon,
416                                                 const char *emsg);
417
418 /**
419  * Prototype of a callback function indicating that two peers
420  * are currently connected.
421  *
422  * @param cls closure
423  * @param first peer id for first daemon
424  * @param second peer id for the second daemon
425  * @param distance distance between the connected peers
426  * @param emsg error message (NULL on success)
427  */
428 typedef void (*GNUNET_TESTING_NotifyTopology)(void *cls,
429                                               const struct GNUNET_PeerIdentity *first,
430                                               const struct GNUNET_PeerIdentity *second,
431                                               const char *emsg);
432
433 /**
434  * Starts a GNUnet daemon.  GNUnet must be installed on the target
435  * system and available in the PATH.  The machine must furthermore be
436  * reachable via "ssh" (unless the hostname is "NULL") without the
437  * need to enter a password.
438  *
439  * @param cfg configuration to use
440  * @param timeout how long to wait starting up peers
441  * @param pretend GNUNET_YES to set up files but not start peer GNUNET_NO
442  *                to really start the peer (default)
443  * @param hostname name of the machine where to run GNUnet
444  *        (use NULL for localhost).
445  * @param ssh_username ssh username to use when connecting to hostname
446  * @param sshport port to pass to ssh process when connecting to hostname
447  * @param hostkey pointer to a hostkey to be written to disk (instead of being generated)
448  * @param hostkey_callback function to call once the hostkey has been
449  *        generated for this peer, but it hasn't yet been started
450  *        (NULL to start immediately, otherwise waits on GNUNET_TESTING_daemon_continue_start)
451  * @param hostkey_cls closure for hostkey callback
452  * @param cb function to call once peer is up, or failed to start
453  * @param cb_cls closure for cb
454  * @return handle to the daemon (actual start will be completed asynchronously)
455  */
456 struct GNUNET_TESTING_Daemon *
457 GNUNET_TESTING_daemon_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
458                              struct GNUNET_TIME_Relative timeout,
459                              int pretend,
460                              const char *hostname,
461                              const char *ssh_username,
462                              uint16_t sshport,
463                              const char *hostkey,
464                              GNUNET_TESTING_NotifyHostkeyCreated
465                              hostkey_callback, void *hostkey_cls,
466                              GNUNET_TESTING_NotifyDaemonRunning cb,
467                              void *cb_cls);
468
469 /**
470  * Continues GNUnet daemon startup when user wanted to be notified
471  * once a hostkey was generated (for creating friends files, blacklists,
472  * etc.).
473  *
474  * @param daemon the daemon to finish starting
475  */
476 void
477 GNUNET_TESTING_daemon_continue_startup(struct GNUNET_TESTING_Daemon *daemon);
478
479 /**
480  * Check whether the given daemon is running.
481  *
482  * @param daemon the daemon to check
483  *
484  * @return GNUNET_YES if the daemon is up, GNUNET_NO if the
485  *         daemon is down, GNUNET_SYSERR on error.
486  */
487 int
488 GNUNET_TESTING_daemon_running (struct GNUNET_TESTING_Daemon *daemon);
489
490 /**
491  * Restart (stop and start) a GNUnet daemon.
492  *
493  * @param d the daemon that should be restarted
494  * @param cb function called once the daemon is (re)started
495  * @param cb_cls closure for cb
496  */
497 void
498 GNUNET_TESTING_daemon_restart (struct GNUNET_TESTING_Daemon *d,
499                                GNUNET_TESTING_NotifyDaemonRunning cb, void *cb_cls);
500
501 /**
502  * Start a peer that has previously been stopped using the daemon_stop
503  * call (and files weren't deleted and the allow restart flag)
504  *
505  * @param daemon the daemon to start (has been previously stopped)
506  * @param timeout how long to wait for restart
507  * @param cb the callback for notification when the peer is running
508  * @param cb_cls closure for the callback
509  */
510 void
511 GNUNET_TESTING_daemon_start_stopped (struct GNUNET_TESTING_Daemon *daemon,
512                                      struct GNUNET_TIME_Relative timeout,
513                                      GNUNET_TESTING_NotifyDaemonRunning cb,
514                                      void *cb_cls);
515
516 /**
517  * Stops a GNUnet daemon.
518  *
519  * @param d the daemon for which the service should be started
520  * @param service the name of the service to start
521  * @param timeout how long to wait for process for shutdown to complete
522  * @param cb function called once the daemon was stopped
523  * @param cb_cls closure for cb
524  */
525 void
526 GNUNET_TESTING_daemon_start_stopped_service (struct GNUNET_TESTING_Daemon *d,
527                                              char *service,
528                                              struct GNUNET_TIME_Relative timeout,
529                                              GNUNET_TESTING_NotifyDaemonRunning cb, void *cb_cls);
530
531 /**
532  * Get a certain testing daemon handle.
533  *
534  * @param pg handle to the set of running peers
535  * @param position the number of the peer to return
536  */
537 struct GNUNET_TESTING_Daemon *
538 GNUNET_TESTING_daemon_get (struct GNUNET_TESTING_PeerGroup *pg, 
539                            unsigned int position);
540
541 /*
542  * Get a daemon by peer identity, so callers can
543  * retrieve the daemon without knowing it's offset.
544  *
545  * @param pg the peer group to retrieve the daemon from
546  * @param peer_id the peer identity of the daemon to retrieve
547  *
548  * @return the daemon on success, or NULL if no such peer identity is found
549  */
550 struct GNUNET_TESTING_Daemon *
551 GNUNET_TESTING_daemon_get_by_id (struct GNUNET_TESTING_PeerGroup *pg,
552                                  struct GNUNET_PeerIdentity *peer_id);
553
554 /**
555  * Stops a GNUnet daemon.
556  *
557  * @param d the daemon that should be stopped
558  * @param timeout how long to wait for process for shutdown to complete
559  * @param cb function called once the daemon was stopped
560  * @param cb_cls closure for cb
561  * @param delete_files GNUNET_YES to remove files, GNUNET_NO
562  *        to leave them (i.e. for restarting at a later time,
563  *        or logfile inspection once finished)
564  * @param allow_restart GNUNET_YES to restart peer later (using this API)
565  *        GNUNET_NO to kill off and clean up for good
566  */
567 void
568 GNUNET_TESTING_daemon_stop (struct GNUNET_TESTING_Daemon *d,
569                             struct GNUNET_TIME_Relative timeout,
570                             GNUNET_TESTING_NotifyCompletion cb, void *cb_cls,
571                             int delete_files, int allow_restart);
572
573
574 /**
575  * Changes the configuration of a GNUnet daemon.
576  *
577  * @param d the daemon that should be modified
578  * @param cfg the new configuration for the daemon
579  * @param cb function called once the configuration was changed
580  * @param cb_cls closure for cb
581  */
582 void GNUNET_TESTING_daemon_reconfigure (struct GNUNET_TESTING_Daemon *d,
583                                         struct GNUNET_CONFIGURATION_Handle *cfg,
584                                         GNUNET_TESTING_NotifyCompletion cb,
585                                         void * cb_cls);
586
587 /**
588  * Stops a single service of a GNUnet daemon.  Used like daemon_stop,
589  * only doesn't stop the entire peer in any case.  If the service
590  * is not currently running, this call is likely to fail after
591  * timeout!
592  *
593  * @param d the daemon that should be stopped
594  * @param service the name of the service to stop
595  * @param timeout how long to wait for process for shutdown to complete
596  * @param cb function called once the service was stopped
597  * @param cb_cls closure for cb
598  */
599 void
600 GNUNET_TESTING_daemon_stop_service (struct GNUNET_TESTING_Daemon *d,
601                                     char *service,
602                                     struct GNUNET_TIME_Relative timeout,
603                                     GNUNET_TESTING_NotifyCompletion cb, void *cb_cls);
604
605 /**
606  * Read a testing hosts file based on a configuration.
607  * Returns a DLL of hosts (caller must free!) on success
608  * or NULL on failure.
609  *
610  * @param cfg a configuration with a testing section
611  *
612  * @return DLL of hosts on success, NULL on failure
613  */
614 struct GNUNET_TESTING_Host *
615 GNUNET_TESTING_hosts_load (const struct GNUNET_CONFIGURATION_Handle *cfg);
616
617
618 /**
619  * Start count gnunet instances with the same set of transports and
620  * applications.  The port numbers (any option called "PORT") will be
621  * adjusted to ensure that no two peers running on the same system
622  * have the same port(s) in their respective configurations.
623  *
624  * @param cfg configuration template to use
625  * @param total number of daemons to start
626  * @param max_concurrent_connections for testing, how many peers can
627 *                                   we connect to simultaneously
628  * @param max_concurrent_ssh when starting with ssh, how many ssh
629  *        connections will we allow at once (based on remote hosts allowed!)
630  * @param timeout total time allowed for peers to start
631  * @param hostkey_callback function to call on each peers hostkey generation
632  *        if NULL, peers will be started by this call, if non-null,
633  *        GNUNET_TESTING_daemons_continue_startup must be called after
634  *        successful hostkey generation
635  * @param hostkey_cls closure for hostkey callback
636  * @param cb function to call on each daemon that was started
637  * @param cb_cls closure for cb
638  * @param connect_callback function to call each time two hosts are connected
639  * @param connect_callback_cls closure for connect_callback
640  * @param hostnames linked list of host structs to use to start peers on
641  *                  (NULL to run on localhost only)
642  *
643  * @return NULL on error, otherwise handle to control peer group
644  */
645 struct GNUNET_TESTING_PeerGroup *
646 GNUNET_TESTING_daemons_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
647                               unsigned int total,
648                               unsigned int max_concurrent_connections,
649                               unsigned int max_concurrent_ssh,
650                               struct GNUNET_TIME_Relative timeout,
651                               GNUNET_TESTING_NotifyHostkeyCreated
652                               hostkey_callback, void *hostkey_cls,
653                               GNUNET_TESTING_NotifyDaemonRunning cb,
654                               void *cb_cls,
655                               GNUNET_TESTING_NotifyConnection
656                               connect_callback, void *connect_callback_cls,
657                               const struct GNUNET_TESTING_Host *hostnames);
658
659 /**
660  * Function which continues a peer group starting up
661  * after successfully generating hostkeys for each peer.
662  *
663  * @param pg the peer group to continue starting
664  */
665 void
666 GNUNET_TESTING_daemons_continue_startup(struct GNUNET_TESTING_PeerGroup *pg);
667
668
669 /**
670  * Establish a connection between two GNUnet daemons.
671  *
672  * @param d1 handle for the first daemon
673  * @param d2 handle for the second daemon
674  * @param timeout how long is the connection attempt
675  *        allowed to take?
676  * @param max_connect_attempts how many times should we try to reconnect
677  *        (within timeout)
678  * @param send_hello GNUNET_YES to send the HELLO, GNUNET_NO to assume
679  *                   the HELLO has already been exchanged
680  * @param cb function to call at the end
681  * @param cb_cls closure for cb
682  */
683 void
684 GNUNET_TESTING_daemons_connect (struct GNUNET_TESTING_Daemon *d1,
685                                 struct GNUNET_TESTING_Daemon *d2,
686                                 struct GNUNET_TIME_Relative timeout,
687                                 unsigned int max_connect_attempts,
688                                 int send_hello,
689                                 GNUNET_TESTING_NotifyConnection cb,
690                                 void *cb_cls);
691
692
693 /**
694  * Restart all peers in the given group.
695  *
696  * @param pg the handle to the peer group
697  * @param callback function to call on completion (or failure)
698  * @param callback_cls closure for the callback function
699  */
700 void
701 GNUNET_TESTING_daemons_restart (struct GNUNET_TESTING_PeerGroup *pg,
702                                 GNUNET_TESTING_NotifyCompletion callback,
703                                 void *callback_cls);
704
705
706 /**
707  * Shutdown all peers started in the given group.
708  *
709  * @param pg handle to the peer group
710  * @param timeout how long to wait for shutdown
711  * @param cb callback to notify upon success or failure
712  * @param cb_cls closure for cb
713  */
714 void
715 GNUNET_TESTING_daemons_stop (struct GNUNET_TESTING_PeerGroup *pg, 
716                              struct GNUNET_TIME_Relative timeout,
717                              GNUNET_TESTING_NotifyCompletion cb,
718                              void *cb_cls);
719
720
721 /**
722  * Count the number of running peers.
723  *
724  * @param pg handle for the peer group
725  *
726  * @return the number of currently running peers in the peer group
727  */
728 unsigned int
729 GNUNET_TESTING_daemons_running (struct GNUNET_TESTING_PeerGroup *pg);
730
731 /**
732  * Simulate churn by stopping some peers (and possibly
733  * re-starting others if churn is called multiple times).  This
734  * function can only be used to create leave-join churn (peers "never"
735  * leave for good).  First "voff" random peers that are currently
736  * online will be taken offline; then "von" random peers that are then
737  * offline will be put back online.  No notifications will be
738  * generated for any of these operations except for the callback upon
739  * completion.  Note that the implementation is at liberty to keep
740  * the ARM service itself (but none of the other services or daemons)
741  * running even though the "peer" is being varied offline.
742  *
743  * @param pg handle for the peer group
744  * @param service the service to churn on/off, NULL for all
745  * @param voff number of peers that should go offline
746  * @param von number of peers that should come back online;
747  *            must be zero on first call (since "testbed_start"
748  *            always starts all of the peers)
749  * @param timeout how long to wait for operations to finish before
750  *        giving up
751  * @param cb function to call at the end
752  * @param cb_cls closure for cb
753  */
754 void
755 GNUNET_TESTING_daemons_churn (struct GNUNET_TESTING_PeerGroup *pg,
756                               char *service,
757                               unsigned int voff,
758                               unsigned int von,
759                               struct GNUNET_TIME_Relative timeout,
760                               GNUNET_TESTING_NotifyCompletion cb,
761                               void *cb_cls);
762
763 /**
764  * Callback function to process statistic values.
765  *
766  * @param cls closure
767  * @param peer the peer the statistics belong to
768  * @param subsystem name of subsystem that created the statistic
769  * @param name the name of the datum
770  * @param value the current value
771  * @param is_persistent GNUNET_YES if the value is persistent, GNUNET_NO if not
772  * @return GNUNET_OK to continue, GNUNET_SYSERR to abort iteration
773  */
774 typedef int (*GNUNET_TESTING_STATISTICS_Iterator) (void *cls,
775                                                    const struct GNUNET_PeerIdentity *peer,
776                                                    const char *subsystem,
777                                                    const char *name,
778                                                    uint64_t value,
779                                                    int is_persistent);
780
781 /**
782  * Iterate over all (running) peers in the peer group, retrieve
783  * all statistics from each.
784  *
785  * @param pg the peergroup to iterate statistics of
786  * @param cont continuation to call once call is completed(?)
787  * @param proc processing function for each statistic retrieved
788  * @param cls closure to pass to proc
789  */
790 void
791 GNUNET_TESTING_get_statistics (struct GNUNET_TESTING_PeerGroup *pg,
792                                GNUNET_STATISTICS_Callback cont,
793                                GNUNET_TESTING_STATISTICS_Iterator proc, void *cls);
794
795 /**
796  * Topologies supported for testbeds.
797  */
798 enum GNUNET_TESTING_Topology
799 {
800   /**
801    * A clique (everyone connected to everyone else).
802    */
803   GNUNET_TESTING_TOPOLOGY_CLIQUE,
804
805   /**
806    * Small-world network (2d torus plus random links).
807    */
808   GNUNET_TESTING_TOPOLOGY_SMALL_WORLD,
809
810   /**
811    * Small-world network (ring plus random links).
812    */
813   GNUNET_TESTING_TOPOLOGY_SMALL_WORLD_RING,
814
815   /**
816    * Ring topology.
817    */
818   GNUNET_TESTING_TOPOLOGY_RING,
819
820   /**
821    * 2-d torus.
822    */
823   GNUNET_TESTING_TOPOLOGY_2D_TORUS,
824
825   /**
826    * Random graph.
827    */
828   GNUNET_TESTING_TOPOLOGY_ERDOS_RENYI,
829
830   /**
831    * Certain percentage of peers are unable to communicate directly
832    * replicating NAT conditions
833    */
834   GNUNET_TESTING_TOPOLOGY_INTERNAT,
835
836   /**
837    * Scale free topology.
838    */
839   GNUNET_TESTING_TOPOLOGY_SCALE_FREE,
840
841   /**
842    * Straight line topology.
843    */
844   GNUNET_TESTING_TOPOLOGY_LINE,
845
846   /**
847    * All peers are disconnected.
848    */
849   GNUNET_TESTING_TOPOLOGY_NONE,
850
851   /**
852    * Read a topology from a given file.
853    */
854   GNUNET_TESTING_TOPOLOGY_FROM_FILE
855 };
856
857 /**
858  * Options for connecting a topology.
859  */
860 enum GNUNET_TESTING_TopologyOption
861 {
862   /**
863    * Try to connect all peers specified in the topology.
864    */
865   GNUNET_TESTING_TOPOLOGY_OPTION_ALL,
866
867   /**
868    * Choose a random subset of connections to create.
869    */
870   GNUNET_TESTING_TOPOLOGY_OPTION_RANDOM,
871
872   /**
873    * Create at least X connections for each peer.
874    */
875   GNUNET_TESTING_TOPOLOGY_OPTION_MINIMUM,
876
877   /**
878    * Using a depth first search, create one connection
879    * per peer.  If any are missed (graph disconnected)
880    * start over at those peers until all have at least one
881    * connection.
882    */
883   GNUNET_TESTING_TOPOLOGY_OPTION_DFS,
884
885   /**
886    * Find the N closest peers to each allowed peer in the
887    * topology and make sure a connection to those peers
888    * exists in the connect topology.
889    */
890   GNUNET_TESTING_TOPOLOGY_OPTION_ADD_CLOSEST,
891
892   /**
893    * No options specified.
894    */
895   GNUNET_TESTING_TOPOLOGY_OPTION_NONE
896 };
897
898
899 /**
900  * Get a topology from a string input.
901  *
902  * @param topology where to write the retrieved topology
903  * @param topology_string The string to attempt to
904  *        get a configuration value from
905  * @return GNUNET_YES if topology string matched a
906  *         known topology, GNUNET_NO if not
907  */
908 int
909 GNUNET_TESTING_topology_get(enum GNUNET_TESTING_Topology *topology, 
910                             const char * topology_string);
911
912 /**
913  * Get connect topology option from string input.
914  *
915  * @param topology_option where to write the retrieved topology
916  * @param topology_string The string to attempt to
917  *        get a configuration value from
918  * @return GNUNET_YES if topology string matched a
919  *         known topology, GNUNET_NO if not
920  */
921 int
922 GNUNET_TESTING_topology_option_get(enum GNUNET_TESTING_TopologyOption *topology_option,
923                                    const char * topology_string);
924
925
926 /**
927  * Takes a peer group and creates a topology based on the
928  * one specified.  Creates a topology means generates friend
929  * files for the peers so they can only connect to those allowed
930  * by the topology.  This will only have an effect once peers
931  * are started if the FRIENDS_ONLY option is set in the base
932  * config.
933  *
934  * Also takes an optional restrict topology which
935  * disallows direct connections UNLESS they are specified in
936  * the restricted topology.
937  *
938  * A simple example; if the topology option is set to LINE
939  * peers can ONLY connect in a LINE.  However, if the topology
940  * option is set to 2D-torus and the restrict option is set to
941  * line with restrict_transports equal to "tcp udp", then peers
942  * may connect in a 2D-torus, but will be restricted to tcp and
943  * udp connections only in a LINE.  Generally it only makes
944  * sense to do this if restrict_topology is a subset of topology.
945  *
946  * For testing peer discovery, etc. it is generally better to
947  * leave restrict_topology as GNUNET_TESTING_TOPOLOGY_NONE and
948  * then use the connect_topology function to restrict the initial
949  * connection set.
950  *
951  * @param pg the peer group struct representing the running peers
952  * @param topology which topology to connect the peers in
953  * @param restrict_topology allow only direct connections in this topology,
954  *        based on those listed in restrict_transports, set to
955  *        GNUNET_TESTING_TOPOLOGY_NONE for no restrictions
956  * @param restrict_transports space delimited list of transports to blacklist
957  *                            to create restricted topology, NULL for none
958  *
959  * @return the maximum number of connections were all allowed peers
960  *         connected to each other
961  */
962 unsigned int
963 GNUNET_TESTING_create_topology (struct GNUNET_TESTING_PeerGroup *pg,
964                                 enum GNUNET_TESTING_Topology topology,
965                                 enum GNUNET_TESTING_Topology restrict_topology,
966                                 const char *restrict_transports);
967
968 /**
969  * Iterate over all (running) peers in the peer group, retrieve
970  * all connections that each currently has.
971  *
972  * @param pg the peer group we are concerned with
973  * @param cb callback for topology information
974  * @param cls closure for callback
975  */
976 void
977 GNUNET_TESTING_get_topology (struct GNUNET_TESTING_PeerGroup *pg,
978                              GNUNET_TESTING_NotifyTopology cb, void *cls);
979
980 /**
981  * Stop the connection process temporarily.
982  *
983  * @param pg the peer group to stop connecting
984  */
985 void GNUNET_TESTING_stop_connections(struct GNUNET_TESTING_PeerGroup *pg);
986
987 /**
988  * Resume the connection process.
989  *
990  * @param pg the peer group to resume connecting
991  */
992 void GNUNET_TESTING_resume_connections(struct GNUNET_TESTING_PeerGroup *pg);
993
994 /**
995  * There are many ways to connect peers that are supported by this function.
996  * To connect peers in the same topology that was created via the
997  * GNUNET_TESTING_create_topology, the topology variable must be set to
998  * GNUNET_TESTING_TOPOLOGY_NONE.  If the topology variable is specified,
999  * a new instance of that topology will be generated and attempted to be
1000  * connected.  This could result in some connections being impossible,
1001  * because some topologies are non-deterministic.
1002  *
1003  * @param pg the peer group struct representing the running peers
1004  * @param topology which topology to connect the peers in
1005  * @param options options for connecting the topology
1006  * @param option_modifier modifier for options that take a parameter
1007  * @param connect_timeout how long to wait before giving up on connecting
1008  *                        two peers
1009  * @param connect_attempts how many times to attempt to connect two peers
1010  *                         over the connect_timeout duration
1011  * @param notify_callback notification to be called once all connections completed
1012  * @param notify_cls closure for notification callback
1013  *
1014  * @return the number of connections that will be attempted, GNUNET_SYSERR on error
1015  */
1016 int
1017 GNUNET_TESTING_connect_topology (struct GNUNET_TESTING_PeerGroup *pg,
1018                                  enum GNUNET_TESTING_Topology topology,
1019                                  enum GNUNET_TESTING_TopologyOption options,
1020                                  double option_modifier,
1021                                  struct GNUNET_TIME_Relative connect_timeout,
1022                                  unsigned int connect_attempts,
1023                                  GNUNET_TESTING_NotifyCompletion
1024                                  notify_callback, void *notify_cls);
1025
1026 /**
1027  * Start or stop an individual peer from the given group.
1028  *
1029  * @param pg handle to the peer group
1030  * @param offset which peer to start or stop
1031  * @param desired_status GNUNET_YES to have it running, GNUNET_NO to stop it
1032  * @param timeout how long to wait for shutdown
1033  * @param cb function to call at the end
1034  * @param cb_cls closure for cb
1035  */
1036 void
1037 GNUNET_TESTING_daemons_vary (struct GNUNET_TESTING_PeerGroup *pg, 
1038                              unsigned int offset,
1039                              int desired_status,
1040                              struct GNUNET_TIME_Relative timeout,
1041                              GNUNET_TESTING_NotifyCompletion cb,
1042                              void *cb_cls);
1043
1044 /**
1045  * Start a peer group with a given number of peers.  Notify
1046  * on completion of peer startup and connection based on given
1047  * topological constraints.  Optionally notify on each
1048  * established connection.
1049  *
1050  * @param cfg configuration template to use
1051  * @param total number of daemons to start
1052  * @param timeout total time allowed for peers to start
1053  * @param connect_cb function to call each time two daemons are connected
1054  * @param peergroup_cb function to call once all peers are up and connected
1055  * @param peergroup_cls closure for peergroup callbacks
1056  * @param hostnames linked list of host structs to use to start peers on
1057  *                  (NULL to run on localhost only)
1058  *
1059  * @return NULL on error, otherwise handle to control peer group
1060  */
1061 struct GNUNET_TESTING_PeerGroup *
1062 GNUNET_TESTING_peergroup_start(
1063                                const struct GNUNET_CONFIGURATION_Handle *cfg,
1064                                unsigned int total,
1065                                struct GNUNET_TIME_Relative timeout,
1066                                GNUNET_TESTING_NotifyConnection connect_cb,
1067                                GNUNET_TESTING_NotifyCompletion peergroup_cb,
1068                                void *peergroup_cls,
1069                                const struct GNUNET_TESTING_Host *hostnames);
1070
1071 /**
1072  * Print current topology to a graphviz readable file.
1073  *
1074  * @param pg a currently running peergroup to print to file
1075  * @param output_filename the file to write the topology to
1076  * @param notify_cb callback to call upon completion or failure
1077  * @param notify_cb_cls closure for notify_cb
1078  *
1079  */
1080 void
1081 GNUNET_TESTING_peergroup_topology_to_file(struct GNUNET_TESTING_PeerGroup *pg,
1082                                           const char *output_filename,
1083                                           GNUNET_TESTING_NotifyCompletion notify_cb,
1084                                           void *notify_cb_cls);
1085
1086
1087 #if 0                           /* keep Emacsens' auto-indent happy */
1088 {
1089 #endif
1090 #ifdef __cplusplus
1091 }
1092 #endif
1093
1094 #endif