testing_core_cmd_recv.c File Reference

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_testing_lib.h"
#include "gnunet_core_service.h"
#include "gnunet_testing_core_lib.h"

Include dependency graph for testing_core_cmd_recv.c:

Go to the source code of this file.

Data Structures
struct	ChannelCount
struct	RecvState

Macros
#define	LOG(kind, ...)    GNUNET_log_from (kind, "testing-core-recv", __VA_ARGS__)
	Generic logging shortcut.

Functions
static void	handle_msg_test (void *cls, struct GNUNET_TESTING_CORE_Channel *channel, const struct GNUNET_TESTING_CORE_Message *msg)
static void	do_finish_cmd_delayed (void *cls)
static void	remove_recv_handler (struct GNUNET_TESTING_CORE_ConnectState *connect_state)
static void	exec_recv_run (void *cls, struct GNUNET_TESTING_Interpreter *is)
static void	exec_recv_cleanup (void *cls)
const struct GNUNET_TESTING_Command	GNUNET_TESTING_CORE_cmd_recv (const char *label, uint64_t num_messages)

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "testing-core-recv", __VA_ARGS__)

Generic logging shortcut.

Definition at line 37 of file testing_core_cmd_recv.c.

Function Documentation

handle_msg_test()

static void handle_msg_test ( void *  cls, struct GNUNET_TESTING_CORE_Channel *  channel, const struct GNUNET_TESTING_CORE_Message *  msg  )

static

Definition at line 116 of file testing_core_cmd_recv.c.

{
  //struct ChannelCount *channel_count = cls;
  struct RecvState *rs = cls;
  struct ChannelCount *channel_count;
  uint32_t channel_i;
  uint64_t num_messages_received;
  uint64_t num_messages_target;
  enum GNUNET_GenericReturnValue ret;
 
  LOG (GNUNET_ERROR_TYPE_INFO, "received test message %" PRIu64 " (%" PRIu64 ") %s\n",
       GNUNET_ntohll (msg->id),
       GNUNET_ntohll (msg->batch),
       msg->node_id);
 
  /* First, find the channel count struct with the channel over which we
   * received this message */
  channel_count = NULL;
  channel_i = rs->num_channels; /* For error checking -
                                   should be overwritten in the following loop. */
  for (uint32_t i = 0; i<rs->num_channels; i++)
  {
    struct ChannelCount *channel_count_iter = &rs->channel_count[i];
    if (NULL == channel_count_iter->channel)
    {
      channel_count = channel_count_iter;
      channel_count->channel = channel;
      channel_count->rs = rs;
      channel_i = i;
      break;
    }
    else if (channel == channel_count_iter->channel)
    {
      channel_count = channel_count_iter;
      channel_i = i;
      break;
    }
    // else: continue until suitable channel count structure is found
  }
  if (NULL == channel_count)
  {
    /* no suitable channel was found -> add this channel */
    GNUNET_array_grow (rs->channel_count,
                       rs->num_channels,
                       rs->num_channels + 1);
    channel_count = &rs->channel_count[rs->num_channels - 1];
    channel_count->channel = channel;
    channel_count->rs = rs;
    channel_i = rs->num_channels;
  }
 
  /* Then update number of received messages */
  channel_count->num_messages_received++;
 
  /* Finally check if this and then other channels received the correct amount
   * potentially finish. */
  num_messages_received = channel_count->num_messages_received;
  num_messages_target = channel_count->rs->num_messages_target;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
      "Received %" PRIu64 " messages (of %" PRIu64 " on channel %" PRIu32 ")\n",
      num_messages_received,
      num_messages_target,
      channel_i);
  if (num_messages_target > num_messages_received) return;
  if (num_messages_target < num_messages_received) GNUNET_assert (0);
  //if (num_messages_target == num_messages_received)
  //  GNUNET_TESTING_async_finish (&rs->ac);
  ret = GNUNET_YES;
  for (uint32_t i = 0; i < rs->num_channels; i++)
  {
    channel_count = &rs->channel_count[i];
    if (channel_count->num_messages_received != rs->num_messages_target)
      ret = GNUNET_NO;
  }
  if (GNUNET_YES == ret)
  {
    LOG (GNUNET_ERROR_TYPE_INFO, "Received all expected messages on all channels\n");
    remove_recv_handler (rs->connect_state);
    // TODO do we want to keep track of this task?
    /* If we finish this task, this ARM will shut down this peer, taking with
     * it core and with it all the messages still in transit.
     * Adding a bit of delay gives the other peer a chance to still receive
     * them.
     * This might be done nicer - via a barrier? Check the other node's receive
     * state?
     * The number of 3 Milliseconds was chosen by looking at logs and then
     * continuously runnint the test and seeing how many actually work reliably
     * (Increased it quite a bit in the end for valgrind - no repeated tests
     * this time.)
     */
    (void) GNUNET_SCHEDULER_add_delayed (
      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 100),
      do_finish_cmd_delayed,
      rs);
  }
}

References ChannelCount::channel, RecvState::channel_count, RecvState::connect_state, do_finish_cmd_delayed(), GNUNET_array_grow, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_NO, GNUNET_ntohll(), GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_MILLISECONDS, GNUNET_YES, LOG, msg, RecvState::num_channels, ChannelCount::num_messages_received, RecvState::num_messages_target, remove_recv_handler(), ret, and ChannelCount::rs.

Referenced by exec_recv_run(), and remove_recv_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

do_finish_cmd_delayed()

static void do_finish_cmd_delayed ( void *  cls )

static

Definition at line 69 of file testing_core_cmd_recv.c.

{
  struct RecvState *rs = cls;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Finishing test delayed\n");
  GNUNET_TESTING_async_finish (&rs->ac);
  GNUNET_free (rs);
}

References RecvState::ac, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_TESTING_async_finish(), and LOG.

Referenced by handle_msg_test().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_recv_handler()

static void remove_recv_handler ( struct GNUNET_TESTING_CORE_ConnectState *  connect_state )

static

Definition at line 80 of file testing_core_cmd_recv.c.

{
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Removing recv handler\n");
  for (uint64_t i = 0; i < connect_state->recv_handlers_len; i++)
  {
    if (&handle_msg_test == connect_state->recv_handlers[i])
    {
      // FIXME this is the dirty solution. The attempt below did for whatever
      // reason not work.
      connect_state->recv_handlers[i] = NULL;
      //LOG (GNUNET_ERROR_TYPE_DEBUG,
      //    "recv handlers[0]: %p, handle_msg_test: %p, (%lu)\n",
      //    connect_state->recv_handlers[0],
      //    &handle_msg_test,
      //    sizeof (&handle_msg_test));
      //LOG (GNUNET_ERROR_TYPE_DEBUG,
      //    "recv handlers: %p, %" PRIu64 "\n",
      //    connect_state->recv_handlers,
      //    connect_state->recv_handlers_len);
      //GNUNET_memcpy (&connect_state->recv_handlers[i],
      //               &connect_state->recv_handlers[i+1],
      //               (connect_state->connect_cbs_len - i - 1) *
      //                 sizeof (handle_msg_test));
      //LOG (GNUNET_ERROR_TYPE_DEBUG,
      //    "recv handlers: %p, %" PRIu64 "\n",
      //    connect_state->recv_handlers,
      //    connect_state->recv_handlers_len);
      //GNUNET_array_grow (connect_state->recv_handlers,
      //                   connect_state->recv_handlers_len,
      //                   connect_state->recv_handlers_len - 1);
    }
  }
}

References RecvState::connect_state, GNUNET_ERROR_TYPE_DEBUG, handle_msg_test(), LOG, GNUNET_TESTING_CORE_ConnectState::recv_handlers, and GNUNET_TESTING_CORE_ConnectState::recv_handlers_len.

Referenced by handle_msg_test().

Here is the call graph for this function:

Here is the caller graph for this function:

exec_recv_run()

static void exec_recv_run ( void *  cls, struct GNUNET_TESTING_Interpreter *  is  )

static

Definition at line 217 of file testing_core_cmd_recv.c.

{
  struct RecvState *rs = cls;
  const struct GNUNET_TESTING_CORE_ConnectState *connect_state;
 
  if (GNUNET_OK != GNUNET_CORE_TESTING_get_trait_connect (
        // TODO make the "connect" an input to the command
        GNUNET_TESTING_interpreter_lookup_command (is, "connect"),
        &connect_state)) {
    GNUNET_assert (0);
  };
  rs->connect_state = connect_state;
  // FIXME: set cls per hanlder
  GNUNET_array_append (connect_state->recv_handlers,
                       connect_state->recv_handlers_len,
                       &handle_msg_test);
  // FIXME is the following ok?
  ((struct GNUNET_TESTING_CORE_ConnectState *)connect_state)->recv_handlers_cls = rs;
}

References RecvState::connect_state, GNUNET_array_append, GNUNET_assert, GNUNET_CORE_TESTING_get_trait_connect(), GNUNET_OK, GNUNET_TESTING_interpreter_lookup_command(), handle_msg_test(), is, GNUNET_TESTING_CORE_ConnectState::recv_handlers, and GNUNET_TESTING_CORE_ConnectState::recv_handlers_len.

Referenced by GNUNET_TESTING_CORE_cmd_recv().

Here is the call graph for this function:

Here is the caller graph for this function:

exec_recv_cleanup()

static void exec_recv_cleanup ( void *  cls )

static

Definition at line 240 of file testing_core_cmd_recv.c.

{
  //struct RecvState *rs = cls;
  // TODO
 
  //GNUNET_free (rs->channel_count);
  //GNUNET_free (rs);
}

Referenced by GNUNET_TESTING_CORE_cmd_recv().

Here is the caller graph for this function:

GNUNET_TESTING_CORE_cmd_recv()

const struct GNUNET_TESTING_Command GNUNET_TESTING_CORE_cmd_recv	(	const char *	label,
		uint64_t	num_messages
	)

Definition at line 251 of file testing_core_cmd_recv.c.

{
  struct RecvState *rs;
 
  // TODO this could be a static global variable
  rs = GNUNET_new (struct RecvState);
  rs->num_channels = 0;
  rs->channel_count = GNUNET_new_array (rs->num_channels, struct ChannelCount);
  rs->num_messages_target = num_messages;
  LOG (GNUNET_ERROR_TYPE_DEBUG, "(Setting up _cmd_recv)\n");
  return GNUNET_TESTING_command_new_ac (
      rs, // state
      label,
      &exec_recv_run,
      &exec_recv_cleanup,
      NULL, // traits
      &rs->ac); // FIXME
}

References RecvState::ac, RecvState::channel_count, exec_recv_cleanup(), exec_recv_run(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_new, GNUNET_new_array, GNUNET_TESTING_command_new_ac(), LOG, RecvState::num_channels, and RecvState::num_messages_target.

Here is the call graph for this function: