cadet_test_lib.c File Reference

library for writing CADET tests More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "cadet_test_lib.h"
#include "gnunet_cadet_service.h"

Include dependency graph for cadet_test_lib.c:

Go to the source code of this file.

Data Structures
struct	GNUNET_CADET_TEST_Context
	Test context for a CADET Test. More...
struct	GNUNET_CADET_TEST_AdapterContext
	Context for a cadet adapter callback. More...

Functions
static void *	cadet_connect_adapter (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Adapter function called to establish a connection to the CADET service. More...
static void	cadet_disconnect_adapter (void *cls, void *op_result)
	Adapter function called to destroy a connection to the CADET service. More...
static void	cadet_connect_cb (void *cls, struct GNUNET_TESTBED_Operation *op, void *ca_result, const char *emsg)
	Callback to be called when a service connect operation is completed. More...
void	GNUNET_CADET_TEST_cleanup (struct GNUNET_CADET_TEST_Context *ctx)
	Clean up the testbed. More...
static void	cadet_test_run (void *cls, struct GNUNET_TESTBED_RunHandle *h, unsigned int num_peers, struct GNUNET_TESTBED_Peer **peers, unsigned int links_succeeded, unsigned int links_failed)
	Callback run when the testbed is ready (peers running and connected to each other) More...
void	GNUNET_CADET_TEST_ruN (const char *testname, const char *cfgfile, unsigned int num_peers, GNUNET_CADET_TEST_AppMain tmain, void *tmain_cls, GNUNET_CADET_ConnectEventHandler connects, GNUNET_CADET_WindowSizeEventHandler window_changes, GNUNET_CADET_DisconnectEventHandler disconnects, struct GNUNET_MQ_MessageHandler *handlers, const struct GNUNET_HashCode **ports)
	Run a test using the given name, configuration file and number of peers. More...

Detailed Description

library for writing CADET tests

Author

Bartlomiej Polot

Definition in file cadet_test_lib.c.

Function Documentation

cadet_connect_adapter()

static void* cadet_connect_adapter ( void *  cls, const struct GNUNET_CONFIGURATION_Handle *  cfg  )

static

Adapter function called to establish a connection to the CADET service.

Parameters

cls	closure
cfg	configuration of the peer to connect to; will be available until GNUNET_TESTBED_operation_done() is called on the operation returned from GNUNET_TESTBED_service_connect()

Returns

service handle to return in 'op_result', NULL on error

Definition at line 131 of file cadet_test_lib.c.

{
  struct GNUNET_CADET_TEST_AdapterContext *actx = cls;
  struct GNUNET_CADET_TEST_Context *ctx = actx->ctx;
  struct GNUNET_CADET_Handle *h;
 
  h = GNUNET_CADET_connect (cfg);
  if (NULL == h)
  {
    GNUNET_break (0);
    return NULL;
  }
  if (NULL == ctx->ports)
    return h;
  actx->ports = GNUNET_new_array (ctx->port_count,
                                  struct GNUNET_CADET_Port *);
  for (unsigned int i = 0; i < ctx->port_count; i++)
  {
    actx->ports[i] = GNUNET_CADET_open_port (h,
                                             ctx->ports[i],
                                             ctx->connects,
                                             (void *) (long) actx->peer,
                                             ctx->window_changes,
                                             ctx->disconnects,
                                             ctx->handlers);
  }
  return h;
}

References cfg, GNUNET_CADET_TEST_AdapterContext::ctx, ctx, GNUNET_break, GNUNET_CADET_connect(), GNUNET_CADET_open_port(), GNUNET_new_array, h, GNUNET_CADET_TEST_AdapterContext::peer, and GNUNET_CADET_TEST_AdapterContext::ports.

Referenced by cadet_test_run().

Here is the call graph for this function:

Here is the caller graph for this function:

cadet_disconnect_adapter()

static void cadet_disconnect_adapter ( void *  cls, void *  op_result  )

static

Adapter function called to destroy a connection to the CADET service.

Parameters

cls	closure
op_result	service handle returned from the connect adapter

Definition at line 170 of file cadet_test_lib.c.

{
  struct GNUNET_CADET_Handle *cadet = op_result;
  struct GNUNET_CADET_TEST_AdapterContext *actx = cls;
 
  if (NULL != actx->ports)
  {
    for (unsigned int i = 0; i < actx->ctx->port_count; i++)
    {
      GNUNET_CADET_close_port (actx->ports[i]);
      actx->ports[i] = NULL;
    }
    GNUNET_free (actx->ports);
  }
  GNUNET_free (actx);
  GNUNET_CADET_disconnect (cadet);
}

References cadet, GNUNET_CADET_TEST_AdapterContext::ctx, GNUNET_CADET_close_port(), GNUNET_CADET_disconnect(), GNUNET_free, op_result(), GNUNET_CADET_TEST_Context::port_count, and GNUNET_CADET_TEST_AdapterContext::ports.

Referenced by cadet_test_run().

Here is the call graph for this function:

Here is the caller graph for this function:

cadet_connect_cb()

static void cadet_connect_cb ( void *  cls, struct GNUNET_TESTBED_Operation *  op, void *  ca_result, const char *  emsg  )

static

Callback to be called when a service connect operation is completed.

Parameters

cls	The callback closure from functions generating an operation.
op	The operation that has been finished.
ca_result	The service handle returned from GNUNET_TESTBED_ConnectAdapter() (cadet handle).
emsg	Error message in case the operation has failed. NULL if operation has executed successfully.

Definition at line 201 of file cadet_test_lib.c.

{
  struct GNUNET_CADET_TEST_Context *ctx = cls;
 
  if (NULL != emsg)
  {
    fprintf (stderr,
             "Failed to connect to CADET service: %s\n",
             emsg);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  for (unsigned int i = 0; i < ctx->num_peers; i++)
    if (op == ctx->ops[i])
    {
      ctx->cadets[i] = ca_result;
      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                  "...cadet %u connected\n",
                  i);
    }
  for (unsigned int i = 0; i < ctx->num_peers; i++)
    if (NULL == ctx->cadets[i])
      return;
  /* still some CADET connections missing */
  /* all CADET connections ready! */
  ctx->app_main (ctx->app_main_cls,
                 ctx,
                 ctx->num_peers,
                 ctx->peers,
                 ctx->cadets);
}

References ctx, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SCHEDULER_shutdown(), and op.

Referenced by cadet_test_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CADET_TEST_cleanup()

void GNUNET_CADET_TEST_cleanup

(

struct GNUNET_CADET_TEST_Context *

ctx

)

Clean up the testbed.

Parameters

ctx	handle for the testbed

Definition at line 238 of file cadet_test_lib.c.

{
  for (unsigned int i = 0; i < ctx->num_peers; i++)
  {
    GNUNET_assert (NULL != ctx->ops[i]);
    GNUNET_TESTBED_operation_done (ctx->ops[i]);
    ctx->ops[i] = NULL;
  }
  GNUNET_free (ctx->ops);
  GNUNET_free (ctx->cadets);
  GNUNET_free (ctx->handlers);
  GNUNET_free (ctx);
  GNUNET_SCHEDULER_shutdown ();
}

References ctx, GNUNET_assert, GNUNET_free, GNUNET_SCHEDULER_shutdown(), and GNUNET_TESTBED_operation_done().

Referenced by disconnect_cadet_peers(), start_test(), and warmup().

Here is the call graph for this function:

Here is the caller graph for this function:

cadet_test_run()

static void cadet_test_run ( void *  cls, struct GNUNET_TESTBED_RunHandle *  h, unsigned int  num_peers, struct GNUNET_TESTBED_Peer **  peers, unsigned int  links_succeeded, unsigned int  links_failed  )

static

Callback run when the testbed is ready (peers running and connected to each other)

Parameters

cls	Closure (context).
h	the run handle
num_peers	Number of peers that are running.
peers	Handles to each one of the num_peers peers.
links_succeeded	the number of overlay link connection attempts that succeeded
links_failed	the number of overlay link connection attempts that failed

Definition at line 268 of file cadet_test_lib.c.

{
  struct GNUNET_CADET_TEST_Context *ctx = cls;
 
  if (0 != links_failed)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Some links failed (%u), ending\n",
                links_failed);
    exit (77);
  }
  if (num_peers != ctx->num_peers)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Peers started %u/%u, ending\n",
                num_peers,
                ctx->num_peers);
    exit (1);
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Testbed up, %u peers and %u links\n",
              num_peers,
              links_succeeded);
  ctx->peers = peers;
  for (unsigned int i = 0; i < num_peers; i++)
  {
    struct GNUNET_CADET_TEST_AdapterContext *newctx;
 
    newctx = GNUNET_new (struct GNUNET_CADET_TEST_AdapterContext);
    newctx->peer = i;
    newctx->ctx = ctx;
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Connecting to cadet %u\n",
                i);
    ctx->ops[i] = GNUNET_TESTBED_service_connect (ctx,
                                                  peers[i],
                                                  "cadet",
                                                  &cadet_connect_cb,
                                                  ctx,
                                                  &cadet_connect_adapter,
                                                  &cadet_disconnect_adapter,
                                                  newctx);
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "op handle %p\n",
                ctx->ops[i]);
  }
}

References cadet_connect_adapter(), cadet_connect_cb(), cadet_disconnect_adapter(), GNUNET_CADET_TEST_AdapterContext::ctx, ctx, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_new, GNUNET_TESTBED_service_connect(), num_peers, GNUNET_CADET_TEST_AdapterContext::peer, and peers.

Referenced by GNUNET_CADET_TEST_ruN().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CADET_TEST_ruN()

void GNUNET_CADET_TEST_ruN	(	const char *	testname,
		const char *	cfgfile,
		unsigned int	num_peers,
		GNUNET_CADET_TEST_AppMain	tmain,
		void *	tmain_cls,
		GNUNET_CADET_ConnectEventHandler	connects,
		GNUNET_CADET_WindowSizeEventHandler	window_changes,
		GNUNET_CADET_DisconnectEventHandler	disconnects,
		struct GNUNET_MQ_MessageHandler *	handlers,
		const struct GNUNET_HashCode **	ports
	)

Run a test using the given name, configuration file and number of peers.

All cadet callbacks will receive the peer number (long) as the closure.

Parameters

testname	Name of the test (for logging).
cfgfile	Name of the configuration file.
num_peers	Number of peers to start.
tmain	Main function to run once the testbed is ready.
tmain_cls	Closure for tmain.
connects	Handler for incoming channels.
window_changes	Handler for the window size change notification.
disconnects	Cleaner for destroyed incoming channels.
handlers	Message handlers.
ports	Ports the peers offer, NULL-terminated.

Definition at line 338 of file cadet_test_lib.c.

{
  struct GNUNET_CADET_TEST_Context *ctx;
 
  ctx = GNUNET_new (struct GNUNET_CADET_TEST_Context);
  ctx->num_peers = num_peers;
  ctx->ops = GNUNET_new_array (num_peers,
                               struct GNUNET_TESTBED_Operation *);
  ctx->cadets = GNUNET_new_array (num_peers,
                                  struct GNUNET_CADET_Handle *);
  ctx->app_main = tmain;
  ctx->app_main_cls = tmain_cls;
  ctx->connects = connects;
  ctx->window_changes = window_changes;
  ctx->disconnects = disconnects;
  ctx->handlers = GNUNET_MQ_copy_handlers (handlers);
  ctx->ports = ports;
  ctx->port_count = 0;
  while (NULL != ctx->ports[ctx->port_count])
    ctx->port_count++;
  GNUNET_TESTBED_test_run (testname,
                           cfgfile,
                           num_peers,
                           0LL, NULL, NULL,
                           &cadet_test_run,
                           ctx);
}

References cadet_test_run(), connects(), ctx, disconnects(), GNUNET_MQ_copy_handlers(), GNUNET_new, GNUNET_new_array, GNUNET_TESTBED_test_run(), handlers, num_peers, GNUNET_CADET_TEST_Context::ports, tmain(), and GNUNET_CADET_TEST_Context::window_changes.

Here is the call graph for this function: