testing_api_cmd_finish.c File Reference

command to wait for completion of async command More...

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

Include dependency graph for testing_api_cmd_finish.c:

Go to the source code of this file.

Data Structures
struct	FinishState
	Struct to use for command-specific context information closure of a command waiting for another command. More...

Functions
static void	done_finish (void *cls)
	Function called when the command we are waiting on is finished. More...
static void	timeout_finish (void *cls)
	Function triggered if the command we are waiting for did not complete on time. More...
static void	run_finish (void *cls, struct GNUNET_TESTING_Interpreter *is)
	Run method of the command created by the interpreter to wait for another command to finish. More...
static void	cleanup_finish (void *cls)
	Cleanup state of a finish command. More...
const struct GNUNET_TESTING_Command	GNUNET_TESTING_cmd_finish (const char *finish_label, const char *cmd_ref, struct GNUNET_TIME_Relative timeout)
	Create (synchronous) command that waits for another command to finish. More...
struct GNUNET_TESTING_Command	GNUNET_TESTING_cmd_make_unblocking (struct GNUNET_TESTING_Command cmd)
	Turn asynchronous command into non-blocking command by setting asynchronous_finish to true. More...

Detailed Description

command to wait for completion of async command

Author

Christian Grothoff

Definition in file testing_api_cmd_finish.c.

Function Documentation

done_finish()

static void done_finish ( void *  cls )

static

Function called when the command we are waiting on is finished.

Hence we are finished, too.

Parameters

cls	a struct FinishState being notified

Definition at line 83 of file testing_api_cmd_finish.c.

{
  struct FinishState *finish_state = cls;
 
  GNUNET_SCHEDULER_cancel (finish_state->finish_task);
  finish_state->finish_task = NULL;
  if (NULL != finish_state->old_notify)
  {
    finish_state->old_notify (finish_state->old_notify_cls);
    finish_state->old_notify = NULL;
  }
  GNUNET_TESTING_async_finish (&finish_state->ac);
}

References FinishState::ac, FinishState::cls, FinishState::finish_task, GNUNET_SCHEDULER_cancel(), GNUNET_TESTING_async_finish(), FinishState::old_notify, and FinishState::old_notify_cls.

Referenced by run_finish().

Here is the call graph for this function:

Here is the caller graph for this function:

timeout_finish()

static void timeout_finish ( void *  cls )

static

Function triggered if the command we are waiting for did not complete on time.

Parameters

cls	our struct FinishState

Definition at line 105 of file testing_api_cmd_finish.c.

{
  struct FinishState *finish_state = cls;
 
  finish_state->finish_task = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
              "Timeout waiting for command `%s' to finish\n",
              finish_state->async_label);
  GNUNET_TESTING_async_fail (&finish_state->ac);
}

References FinishState::ac, FinishState::async_label, FinishState::cls, FinishState::finish_task, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, and GNUNET_TESTING_async_fail().

Referenced by run_finish().

Here is the call graph for this function:

Here is the caller graph for this function:

run_finish()

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

static

Run method of the command created by the interpreter to wait for another command to finish.

Definition at line 123 of file testing_api_cmd_finish.c.

{
  struct FinishState *finish_state = cls;
  const struct GNUNET_TESTING_Command *async_cmd;
  struct GNUNET_TESTING_AsyncContext *aac;
 
  async_cmd
    = GNUNET_TESTING_interpreter_lookup_command (is,
                                                 finish_state->async_label);
  if (NULL == async_cmd)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Did not find command `%s'\n",
                finish_state->async_label);
    GNUNET_TESTING_FAIL (is);
  }
  if ( (NULL == (aac = async_cmd->ac)) ||
       (! async_cmd->asynchronous_finish) )
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Cannot finish `%s': not asynchronous\n",
                finish_state->async_label);
    GNUNET_TESTING_FAIL (is);
  }
  if (aac->finished)
  {
    /* Command is already finished, so are we! */
    GNUNET_TESTING_async_finish (&finish_state->ac);
    return;
  }
  /* add timeout */
  finish_state->finish_task
    = GNUNET_SCHEDULER_add_delayed (finish_state->timeout,
                                    &timeout_finish,
                                    finish_state);
  /* back up old notification that we will override */
  finish_state->old_notify = aac->notify_finished;
  finish_state->old_notify_cls = aac->notify_finished_cls;
  aac->notify_finished = &done_finish;
  aac->notify_finished_cls = finish_state;
}

References GNUNET_TESTING_Command::ac, FinishState::ac, FinishState::async_label, GNUNET_TESTING_Command::asynchronous_finish, FinishState::cls, done_finish(), FinishState::finish_task, GNUNET_TESTING_AsyncContext::finished, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_TESTING_async_finish(), GNUNET_TESTING_FAIL, GNUNET_TESTING_interpreter_lookup_command(), is, GNUNET_TESTING_AsyncContext::notify_finished, GNUNET_TESTING_AsyncContext::notify_finished_cls, FinishState::old_notify, FinishState::old_notify_cls, FinishState::timeout, and timeout_finish().

Referenced by GNUNET_TESTING_cmd_finish(), and GNUNET_TESTING_cmd_make_unblocking().

Here is the call graph for this function:

Here is the caller graph for this function:

cleanup_finish()

static void cleanup_finish ( void *  cls )

static

Cleanup state of a finish command.

Parameters

cls	a struct FinishState to clean up

Definition at line 174 of file testing_api_cmd_finish.c.

{
  struct FinishState *finish_state = cls;
 
  if (NULL != finish_state->finish_task)
  {
    GNUNET_SCHEDULER_cancel (finish_state->finish_task);
    finish_state->finish_task = NULL;
  }
  GNUNET_free (finish_state);
}

References FinishState::cls, FinishState::finish_task, GNUNET_free, and GNUNET_SCHEDULER_cancel().

Referenced by GNUNET_TESTING_cmd_finish().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_cmd_finish()

const struct GNUNET_TESTING_Command GNUNET_TESTING_cmd_finish	(	const char *	finish_label,
		const char *	cmd_ref,
		struct GNUNET_TIME_Relative	timeout
	)

Create (synchronous) command that waits for another command to finish.

If cmd_ref did not finish after timeout, this command will fail the test case.

Parameters

finish_label	label for this command
cmd_ref	reference to a previous command which we should wait for (call finish() on)
timeout	how long to wait at most for cmd_ref to finish

Returns

a finish-command.

Definition at line 188 of file testing_api_cmd_finish.c.

{
  struct FinishState *finish_state;
 
  finish_state = GNUNET_new (struct FinishState);
  finish_state->async_label = cmd_ref;
  finish_state->timeout = timeout;
  return GNUNET_TESTING_command_new_ac (
    finish_state,
    finish_label,
    &run_finish,
    &cleanup_finish,
    NULL,
    &finish_state->ac);
}

References FinishState::ac, FinishState::async_label, cleanup_finish(), GNUNET_new, GNUNET_TESTING_command_new_ac(), run_finish(), timeout, and FinishState::timeout.

Here is the call graph for this function:

GNUNET_TESTING_cmd_make_unblocking()

struct GNUNET_TESTING_Command GNUNET_TESTING_cmd_make_unblocking

(

struct GNUNET_TESTING_Command

cmd

)

Turn asynchronous command into non-blocking command by setting asynchronous_finish to true.

Modifies (and then returns) cmd simply setting the bit. By default, most commands are blocking, and by wrapping the command construction in this function a blocking command can be turned into an asynchronous command where the interpreter continues after initiating the asynchronous action. Does nothing if the command is fundamentally synchronous.

Parameters

[in,out]

cmd

command to make non-blocking

Returns

a finish-command.

Definition at line 209 of file testing_api_cmd_finish.c.

{
  /* do not permit this function to be used on
     a finish command! */
  GNUNET_assert (cmd.run != &run_finish);
  cmd.asynchronous_finish = true;
  return cmd;
}

References GNUNET_assert, and run_finish().

Here is the call graph for this function: