#define GNUNET_TESTING_LIB_H
#include "gnunet_util_lib.h"
+#include "gnunet_statistics_service.h"
#ifdef __cplusplus
extern "C"
#endif
#endif
+#define HOSTKEYFILESIZE 914
+
/**
* Handle for a GNUnet daemon (technically a set of
* daemons; the handle is really for the master ARM
*/
struct GNUNET_TESTING_Daemon;
+/**
+ * Linked list of hostnames and ports to use for starting daemons.
+ */
+struct GNUNET_TESTING_Host
+{
+ /**
+ * Pointer to next item in the list.
+ */
+ struct GNUNET_TESTING_Host *next;
+
+ /**
+ * Hostname to connect to.
+ */
+ char *hostname;
+
+ /**
+ * Username to use when connecting (may be null).
+ */
+ char *username;
+
+ /**
+ * Port to use for SSH connection (used for ssh
+ * connection forwarding, 0 to let ssh decide)
+ */
+ uint16_t port;
+};
+
/**
* Prototype of a function that will be called whenever
* a daemon was started by the testing library.
*/
SP_START_CORE,
+ /**
+ * CORE is up, now make sure we get the HELLO for this peer.
+ */
+ SP_GET_HELLO,
+
/**
* Core has notified us that we've established a connection to the service.
* The main FSM halts here and waits to be moved to UPDATE or CLEANUP.
*/
struct GNUNET_TESTING_Daemon
{
- /**
- * Our scheduler.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
-
/**
* Our configuration.
*/
*/
char *hostname;
+ /**
+ * Port to use for ssh, NULL to let system choose default.
+ */
+ char *ssh_port_str;
+
/**
* Result of GNUNET_i2s of this peer,
* for printing
*/
int dead;
+ /**
+ * GNUNET_YES if the hostkey has been created
+ * for this peer, GNUNET_NO otherwise.
+ */
+ int have_hostkey;
+
/**
* PID of the process that we started last.
*/
- pid_t pid;
+ struct GNUNET_OS_Process *proc;
/**
* In which phase are we during the start of
struct GNUNET_TESTING_Daemon *second_daemon,
const char *emsg);
+/**
+ * Prototype of a callback function indicating that two peers
+ * are currently connected.
+ *
+ * @param cls closure
+ * @param first peer id for first daemon
+ * @param second peer id for the second daemon
+ * @param distance distance between the connected peers
+ * @param emsg error message (NULL on success)
+ */
+typedef void (*GNUNET_TESTING_NotifyTopology)(void *cls,
+ const struct GNUNET_PeerIdentity *first,
+ const struct GNUNET_PeerIdentity *second,
+ const char *emsg);
+
/**
* Starts a GNUnet daemon. GNUnet must be installed on the target
* system and available in the PATH. The machine must furthermore be
* reachable via "ssh" (unless the hostname is "NULL") without the
* need to enter a password.
*
- * @param sched scheduler to use
* @param cfg configuration to use
* @param timeout how long to wait starting up peers
+ * @param pretend GNUNET_YES to set up files but not start peer GNUNET_NO
+ * to really start the peer (default)
* @param hostname name of the machine where to run GNUnet
* (use NULL for localhost).
+ * @param ssh_username ssh username to use when connecting to hostname
+ * @param sshport port to pass to ssh process when connecting to hostname
+ * @param hostkey pointer to a hostkey to be written to disk (instead of being generated)
* @param hostkey_callback function to call once the hostkey has been
* generated for this peer, but it hasn't yet been started
* (NULL to start immediately, otherwise waits on GNUNET_TESTING_daemon_continue_start)
* @param hostkey_cls closure for hostkey callback
- * @param cb function to call with the result
+ * @param cb function to call once peer is up, or failed to start
* @param cb_cls closure for cb
* @return handle to the daemon (actual start will be completed asynchronously)
*/
struct GNUNET_TESTING_Daemon *
-GNUNET_TESTING_daemon_start (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_TESTING_daemon_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TIME_Relative timeout,
+ int pretend,
const char *hostname,
- GNUNET_TESTING_NotifyHostkeyCreated hostkey_callback,
- void *hostkey_cls,
+ const char *ssh_username,
+ uint16_t sshport,
+ const char *hostkey,
+ GNUNET_TESTING_NotifyHostkeyCreated
+ hostkey_callback, void *hostkey_cls,
GNUNET_TESTING_NotifyDaemonRunning cb,
void *cb_cls);
void
GNUNET_TESTING_daemon_continue_startup(struct GNUNET_TESTING_Daemon *daemon);
+/**
+ * Check whether the given daemon is running.
+ *
+ * @param daemon the daemon to check
+ *
+ * @return GNUNET_YES if the daemon is up, GNUNET_NO if the
+ * daemon is down, GNUNET_SYSERR on error.
+ */
+int
+GNUNET_TESTING_daemon_running (struct GNUNET_TESTING_Daemon *daemon);
+
/**
* Restart (stop and start) a GNUnet daemon.
*
GNUNET_TESTING_daemon_get (struct GNUNET_TESTING_PeerGroup *pg,
unsigned int position);
+/*
+ * Get a daemon by peer identity, so callers can
+ * retrieve the daemon without knowing it's offset.
+ *
+ * @param pg the peer group to retrieve the daemon from
+ * @param peer_id the peer identity of the daemon to retrieve
+ *
+ * @return the daemon on success, or NULL if no such peer identity is found
+ */
+struct GNUNET_TESTING_Daemon *
+GNUNET_TESTING_daemon_get_by_id (struct GNUNET_TESTING_PeerGroup *pg,
+ struct GNUNET_PeerIdentity *peer_id);
/**
* Stops a GNUnet daemon.
* allowed to take?
* @param max_connect_attempts how many times should we try to reconnect
* (within timeout)
+ * @param send_hello GNUNET_YES to send the HELLO, GNUNET_NO to assume
+ * the HELLO has already been exchanged
* @param cb function to call at the end
* @param cb_cls closure for cb
*/
-void GNUNET_TESTING_daemons_connect (struct GNUNET_TESTING_Daemon *d1,
- struct GNUNET_TESTING_Daemon *d2,
- struct GNUNET_TIME_Relative timeout,
- unsigned int max_connect_attempts,
- GNUNET_TESTING_NotifyConnection cb,
- void *cb_cls);
+void
+GNUNET_TESTING_daemons_connect (struct GNUNET_TESTING_Daemon *d1,
+ struct GNUNET_TESTING_Daemon *d2,
+ struct GNUNET_TIME_Relative timeout,
+ unsigned int max_connect_attempts,
+ int send_hello,
+ GNUNET_TESTING_NotifyConnection cb,
+ void *cb_cls);
/**
- * Start count gnunetd processes with the same set of transports and
+ * Start count gnunet instances with the same set of transports and
* applications. The port numbers (any option called "PORT") will be
* adjusted to ensure that no two peers running on the same system
* have the same port(s) in their respective configurations.
*
- * @param sched scheduler to use
* @param cfg configuration template to use
* @param total number of daemons to start
+ * @param max_concurrent_connections for testing, how many peers can
+* we connect to simultaneously
+ * @param max_concurrent_ssh when starting with ssh, how many ssh
+ * connections will we allow at once (based on remote hosts allowed!)
* @param timeout total time allowed for peers to start
* @param hostkey_callback function to call on each peers hostkey generation
* if NULL, peers will be started by this call, if non-null,
* @param cb_cls closure for cb
* @param connect_callback function to call each time two hosts are connected
* @param connect_callback_cls closure for connect_callback
- * @param hostnames space-separated list of hostnames to use; can be NULL (to run
- * everything on localhost).
+ * @param hostnames linked list of host structs to use to start peers on
+ * (NULL to run on localhost only)
+ *
* @return NULL on error, otherwise handle to control peer group
*/
struct GNUNET_TESTING_PeerGroup *
-GNUNET_TESTING_daemons_start (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_TESTING_daemons_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
unsigned int total,
+ unsigned int max_concurrent_connections,
+ unsigned int max_concurrent_ssh,
struct GNUNET_TIME_Relative timeout,
- GNUNET_TESTING_NotifyHostkeyCreated hostkey_callback,
- void *hostkey_cls,
+ GNUNET_TESTING_NotifyHostkeyCreated
+ hostkey_callback, void *hostkey_cls,
GNUNET_TESTING_NotifyDaemonRunning cb,
void *cb_cls,
GNUNET_TESTING_NotifyConnection
connect_callback, void *connect_callback_cls,
- const char *hostnames);
+ const struct GNUNET_TESTING_Host *hostnames);
/**
* Function which continues a peer group starting up
void *cb_cls);
+/**
+ * Count the number of running peers.
+ *
+ * @param pg handle for the peer group
+ *
+ * @return the number of currently running peers in the peer group
+ */
+unsigned int
+GNUNET_TESTING_daemons_running (struct GNUNET_TESTING_PeerGroup *pg);
+
/**
* Simulate churn by stopping some peers (and possibly
* re-starting others if churn is called multiple times). This
GNUNET_TESTING_NotifyCompletion cb,
void *cb_cls);
+/**
+ * Callback function to process statistic values.
+ *
+ * @param cls closure
+ * @param peer the peer the statistics belong to
+ * @param subsystem name of subsystem that created the statistic
+ * @param name the name of the datum
+ * @param value the current value
+ * @param is_persistent GNUNET_YES if the value is persistent, GNUNET_NO if not
+ * @return GNUNET_OK to continue, GNUNET_SYSERR to abort iteration
+ */
+typedef int (*GNUNET_TESTING_STATISTICS_Iterator) (void *cls,
+ const struct GNUNET_PeerIdentity *peer,
+ const char *subsystem,
+ const char *name,
+ uint64_t value,
+ int is_persistent);
+
+/**
+ * Iterate over all (running) peers in the peer group, retrieve
+ * all statistics from each.
+ */
+void
+GNUNET_TESTING_get_statistics (struct GNUNET_TESTING_PeerGroup *pg,
+ GNUNET_STATISTICS_Callback cont,
+ GNUNET_TESTING_STATISTICS_Iterator proc, void *cls);
/**
* Topologies supported for testbeds.
/**
* All peers are disconnected.
*/
- GNUNET_TESTING_TOPOLOGY_NONE
+ GNUNET_TESTING_TOPOLOGY_NONE,
+
+ /**
+ * Read a topology from a given file.
+ */
+ GNUNET_TESTING_TOPOLOGY_FROM_FILE
};
/**
*/
GNUNET_TESTING_TOPOLOGY_OPTION_DFS,
+ /**
+ * Find the N closest peers to each allowed peer in the
+ * topology and make sure a connection to those peers
+ * exists in the connect topology.
+ */
+ GNUNET_TESTING_TOPOLOGY_OPTION_ADD_CLOSEST,
+
/**
* No options specified.
*/
* known topology, GNUNET_NO if not
*/
int
-GNUNET_TESTING_topology_get(enum GNUNET_TESTING_Topology *topology, char * topology_string);
+GNUNET_TESTING_topology_get(enum GNUNET_TESTING_Topology *topology,
+ const char * topology_string);
/**
* Get connect topology option from string input.
*/
int
GNUNET_TESTING_topology_option_get(enum GNUNET_TESTING_TopologyOption *topology_option,
- char * topology_string);
+ const char * topology_string);
/**
* files for the peers so they can only connect to those allowed
* by the topology. This will only have an effect once peers
* are started if the FRIENDS_ONLY option is set in the base
- * config. Also takes an optional restrict topology which
- * disallows direct TCP connections UNLESS they are specified in
+ * config.
+ *
+ * Also takes an optional restrict topology which
+ * disallows direct connections UNLESS they are specified in
* the restricted topology.
*
+ * A simple example; if the topology option is set to LINE
+ * peers can ONLY connect in a LINE. However, if the topology
+ * option is set to 2D-torus and the restrict option is set to
+ * line with restrict_transports equal to "tcp udp", then peers
+ * may connect in a 2D-torus, but will be restricted to tcp and
+ * udp connections only in a LINE. Generally it only makes
+ * sense to do this if restrict_topology is a subset of topology.
+ *
+ * For testing peer discovery, etc. it is generally better to
+ * leave restrict_topology as GNUNET_TESTING_TOPOLOGY_NONE and
+ * then use the connect_topology function to restrict the initial
+ * connection set.
+ *
* @param pg the peer group struct representing the running peers
* @param topology which topology to connect the peers in
- * @param restrict_topology allow only direct TCP connections in this topology
+ * @param restrict_topology allow only direct connections in this topology,
+ * based on those listed in restrict_transports, set to
+ * GNUNET_TESTING_TOPOLOGY_NONE for no restrictions
* @param restrict_transports space delimited list of transports to blacklist
- * to create restricted topology
+ * to create restricted topology, NULL for none
*
* @return the maximum number of connections were all allowed peers
* connected to each other
*/
-int
+unsigned int
GNUNET_TESTING_create_topology (struct GNUNET_TESTING_PeerGroup *pg,
enum GNUNET_TESTING_Topology topology,
enum GNUNET_TESTING_Topology restrict_topology,
- char *restrict_transports);
+ const char *restrict_transports);
+
+/**
+ * Iterate over all (running) peers in the peer group, retrieve
+ * all connections that each currently has.
+ *
+ * @param pg the peer group we are concerned with
+ * @param cb callback for topology information
+ * @param cls closure for callback
+ */
+void
+GNUNET_TESTING_get_topology (struct GNUNET_TESTING_PeerGroup *pg,
+ GNUNET_TESTING_NotifyTopology cb, void *cls);
+
+/**
+ * Stop the connection process temporarily.
+ *
+ * @param pg the peer group to stop connecting
+ */
+void GNUNET_TESTING_stop_connections(struct GNUNET_TESTING_PeerGroup *pg);
+
+/**
+ * Resume the connection process.
+ *
+ * @param pg the peer group to resume connecting
+ */
+void GNUNET_TESTING_resume_connections(struct GNUNET_TESTING_PeerGroup *pg);
/**
* There are many ways to connect peers that are supported by this function.
* @param topology which topology to connect the peers in
* @param options options for connecting the topology
* @param option_modifier modifier for options that take a parameter
+ * @param connect_timeout how long to wait before giving up on connecting
+ * two peers
+ * @param connect_attempts how many times to attempt to connect two peers
+ * over the connect_timeout duration
+ * @param notify_callback notification to be called once all connections completed
+ * @param notify_cls closure for notification callback
+ *
* @return the number of connections that will be attempted, GNUNET_SYSERR on error
*/
int
GNUNET_TESTING_connect_topology (struct GNUNET_TESTING_PeerGroup *pg,
enum GNUNET_TESTING_Topology topology,
enum GNUNET_TESTING_TopologyOption options,
- double option_modifier);
+ double option_modifier,
+ struct GNUNET_TIME_Relative connect_timeout,
+ unsigned int connect_attempts,
+ GNUNET_TESTING_NotifyCompletion
+ notify_callback, void *notify_cls);
/**
* Start or stop an individual peer from the given group.
GNUNET_TESTING_NotifyCompletion cb,
void *cb_cls);
+/**
+ * Start a peer group with a given number of peers. Notify
+ * on completion of peer startup and connection based on given
+ * topological constraints. Optionally notify on each
+ * established connection.
+ *
+ * @param cfg configuration template to use
+ * @param total number of daemons to start
+ * @param timeout total time allowed for peers to start
+ * @param connect_cb function to call each time two daemons are connected
+ * @param peergroup_cb function to call once all peers are up and connected
+ * @param peergroup_cls closure for peergroup callbacks
+ * @param hostnames linked list of host structs to use to start peers on
+ * (NULL to run on localhost only)
+ *
+ * @return NULL on error, otherwise handle to control peer group
+ */
+struct GNUNET_TESTING_PeerGroup *
+GNUNET_TESTING_peergroup_start(
+ const struct GNUNET_CONFIGURATION_Handle *cfg,
+ unsigned int total,
+ struct GNUNET_TIME_Relative timeout,
+ GNUNET_TESTING_NotifyConnection connect_cb,
+ GNUNET_TESTING_NotifyCompletion peergroup_cb,
+ void *peergroup_cls,
+ const struct GNUNET_TESTING_Host *hostnames);
+
#if 0 /* keep Emacsens' auto-indent happy */
{