statistics_api.c File Reference

API of the statistics service. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_constants.h"
#include "gnunet_protocols.h"
#include "gnunet_statistics_service.h"
#include "statistics.h"

Include dependency graph for statistics_api.c:

Go to the source code of this file.

Data Structures
struct	GNUNET_STATISTICS_WatchEntry
	Entry kept for each value we are watching. More...
struct	GNUNET_STATISTICS_GetHandle
	Linked list of things we still need to do. More...
struct	GNUNET_STATISTICS_Handle
	Handle for the service. More...

Macros
#define	SET_TRANSMIT_TIMEOUT
	How long do we wait until a statistics request for setting a value times out? (The update will be lost if the service does not react within this timeframe). More...
#define	LOG(kind, ...)   GNUNET_log_from (kind, "statistics-api", __VA_ARGS__)

Enumerations
enum	ActionType { ACTION_GET , ACTION_SET , ACTION_UPDATE , ACTION_WATCH }
	Types of actions. More...

Functions
static void	update_memory_statistics (struct GNUNET_STATISTICS_Handle *h)
	Obtain statistics about this process's memory consumption and report those as well (if they changed). More...
static void	reconnect_later (struct GNUNET_STATISTICS_Handle *h)
	Reconnect at a later time, respecting back-off. More...
static void	schedule_action (void *cls)
	Schedule the next action to be performed. More...
static void	schedule_watch_request (struct GNUNET_STATISTICS_Handle *h, struct GNUNET_STATISTICS_WatchEntry *watch)
	Transmit request to service that we want to watch the development of a particular value. More...
static void	free_action_item (struct GNUNET_STATISTICS_GetHandle *gh)
	Free memory associated with the given action item. More...
static void	do_disconnect (struct GNUNET_STATISTICS_Handle *h)
	Disconnect from the statistics service. More...
static int	check_statistics_value (void *cls, const struct GNUNET_STATISTICS_ReplyMessage *smsg)
	Process a GNUNET_MESSAGE_TYPE_STATISTICS_VALUE message. More...
static void	handle_statistics_value (void *cls, const struct GNUNET_STATISTICS_ReplyMessage *smsg)
	Process a GNUNET_MESSAGE_TYPE_STATISTICS_VALUE message. More...
static void	handle_statistics_watch_value (void *cls, const struct GNUNET_STATISTICS_WatchValueMessage *wvm)
	We have received a watch value from the service. More...
static void	mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
	Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue. More...
static void	do_destroy (void *cls)
	Task used to destroy the statistics handle. More...
static void	handle_disconnect_confirm (void *cls, const struct GNUNET_MessageHeader *msg)
	Handle a GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT_CONFIRM message. More...
static void	handle_statistics_end (void *cls, const struct GNUNET_MessageHeader *msg)
	Handle a GNUNET_MESSAGE_TYPE_STATISTICS_END message. More...
static int	try_connect (struct GNUNET_STATISTICS_Handle *h)
	Try to (re)connect to the statistics service. More...
static void	reconnect_task (void *cls)
	We've waited long enough, reconnect now. More...
static void	transmit_get (struct GNUNET_STATISTICS_Handle *handle)
	Transmit a GET request (and if successful, start to receive the response). More...
static void	transmit_watch (struct GNUNET_STATISTICS_Handle *handle)
	Transmit a WATCH request (and if successful, start to receive the response). More...
static void	transmit_set (struct GNUNET_STATISTICS_Handle *handle)
	Transmit a SET/UPDATE request. More...
struct GNUNET_STATISTICS_Handle *	GNUNET_STATISTICS_create (const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Get handle for the statistics service. More...
void	GNUNET_STATISTICS_destroy (struct GNUNET_STATISTICS_Handle *h, int sync_first)
	Destroy a handle (free all state associated with it). More...
struct GNUNET_STATISTICS_GetHandle *	GNUNET_STATISTICS_get (struct GNUNET_STATISTICS_Handle *handle, const char *subsystem, const char *name, GNUNET_STATISTICS_Callback cont, GNUNET_STATISTICS_Iterator proc, void *cls)
	Get statistic from the peer. More...
void	GNUNET_STATISTICS_get_cancel (struct GNUNET_STATISTICS_GetHandle *gh)
	Cancel a GNUNET_STATISTICS_get request. More...
int	GNUNET_STATISTICS_watch (struct GNUNET_STATISTICS_Handle *handle, const char *subsystem, const char *name, GNUNET_STATISTICS_Iterator proc, void *proc_cls)
	Watch statistics from the peer (be notified whenever they change). More...
int	GNUNET_STATISTICS_watch_cancel (struct GNUNET_STATISTICS_Handle *handle, const char *subsystem, const char *name, GNUNET_STATISTICS_Iterator proc, void *proc_cls)
	Stop watching statistics from the peer. More...
static void	add_setter_action (struct GNUNET_STATISTICS_Handle *h, const char *name, int make_persistent, uint64_t value, enum ActionType type)
	Queue a request to change a statistic. More...
void	GNUNET_STATISTICS_set (struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
	Set statistic value for the peer. More...
void	GNUNET_STATISTICS_update (struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
	Set statistic value for the peer. More...

Detailed Description

API of the statistics service.

Author

Christian Grothoff

Definition in file statistics_api.c.

Macro Definition Documentation

SET_TRANSMIT_TIMEOUT

#define SET_TRANSMIT_TIMEOUT

Value:

    GNUNET_TIME_relative_multiply ( \
    GNUNET_TIME_UNIT_SECONDS, 2)

How long do we wait until a statistics request for setting a value times out? (The update will be lost if the service does not react within this timeframe).

Definition at line 38 of file statistics_api.c.

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "statistics-api", __VA_ARGS__)

Definition at line 41 of file statistics_api.c.

Enumeration Type Documentation

ActionType

enum ActionType

Types of actions.

Enumerator
ACTION_GET	Get a value.
ACTION_SET	Set a value.
ACTION_UPDATE	Update a value.
ACTION_WATCH	Watch a value.

Definition at line 46 of file statistics_api.c.

{
  ACTION_GET,
 
  ACTION_SET,
 
  ACTION_UPDATE,
 
  ACTION_WATCH
};

Function Documentation

update_memory_statistics()

static void update_memory_statistics ( struct GNUNET_STATISTICS_Handle *  h )

static

Obtain statistics about this process's memory consumption and report those as well (if they changed).

Definition at line 265 of file statistics_api.c.

{
#if ENABLE_HEAP_STATISTICS
  uint64_t current_heap_size = 0;
  uint64_t current_rss = 0;
 
  if (GNUNET_NO != h->do_destroy)
    return;
#if HAVE_MALLINFO2
  {
    struct mallinfo2 mi;
 
    mi = mallinfo2 ();
    current_heap_size = mi.uordblks + mi.fordblks;
  }
#endif
#if HAVE_GETRUSAGE
  {
    struct rusage ru;
 
    if (0 == getrusage (RUSAGE_SELF, &ru))
    {
      current_rss = 1024LL * ru.ru_maxrss;
    }
  }
#endif
  if (current_heap_size > h->peak_heap_size)
  {
    h->peak_heap_size = current_heap_size;
    GNUNET_STATISTICS_set (h,
                           "# peak heap size",
                           current_heap_size,
                           GNUNET_NO);
  }
  if (current_rss > h->peak_rss)
  {
    h->peak_rss = current_rss;
    GNUNET_STATISTICS_set (h,
                           "# peak resident set size",
                           current_rss,
                           GNUNET_NO);
  }
#endif
}

References GNUNET_NO, GNUNET_STATISTICS_set(), and h.

Referenced by transmit_set().

Here is the call graph for this function:

Here is the caller graph for this function:

reconnect_later()

static void reconnect_later ( struct GNUNET_STATISTICS_Handle *  h )

static

Reconnect at a later time, respecting back-off.

Parameters

h	statistics handle

Definition at line 730 of file statistics_api.c.

{
  int loss;
  struct GNUNET_STATISTICS_GetHandle *gh;
 
  GNUNET_assert (NULL == h->backoff_task);
  if (GNUNET_YES == h->do_destroy)
  {
    /* So we are shutting down and the service is not reachable.
     * Chances are that it's down for good and we are not going to connect to
     * it anymore.
     * Give up and don't sync the rest of the data.
     */loss = GNUNET_NO;
    for (gh = h->action_head; NULL != gh; gh = gh->next)
      if ((gh->make_persistent) &&
          (ACTION_SET == gh->type))
        loss = GNUNET_YES;
    if (GNUNET_YES == loss)
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  _ ("Could not save some persistent statistics\n"));
    if (NULL != h->destroy_task)
      GNUNET_SCHEDULER_cancel (h->destroy_task);
    h->destroy_task = GNUNET_SCHEDULER_add_now (&do_destroy,
                                                h);
    return;
  }
  h->backoff_task
    = GNUNET_SCHEDULER_add_delayed (h->backoff,
                                    &reconnect_task,
                                    h);
  h->backoff = GNUNET_TIME_STD_BACKOFF (h->backoff);
}

References _, ACTION_SET, do_destroy(), gh, GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_TIME_STD_BACKOFF, GNUNET_YES, h, and reconnect_task().

Referenced by handle_disconnect_confirm(), handle_statistics_end(), handle_statistics_watch_value(), mq_error_handler(), and schedule_action().

Here is the call graph for this function:

Here is the caller graph for this function:

schedule_action()

static void schedule_action ( void *  cls )

static

Schedule the next action to be performed.

Parameters

cls	statistics handle to reconnect
cls	statistics handle

Definition at line 1001 of file statistics_api.c.

{
  struct GNUNET_STATISTICS_Handle *h = cls;
 
  if (NULL != h->backoff_task)
    return;                     /* action already pending */
  if (GNUNET_YES != try_connect (h))
  {
    reconnect_later (h);
    return;
  }
  if (0 < GNUNET_MQ_get_length (h->mq))
    return; /* Wait for queue to be reduced more */
  /* schedule next action */
  while (NULL == h->current)
  {
    h->current = h->action_head;
    if (NULL == h->current)
    {
      struct GNUNET_MessageHeader *hdr;
      struct GNUNET_MQ_Envelope *env;
 
      if (GNUNET_YES != h->do_destroy)
        return;     /* nothing to do */
      /* let service know that we're done */
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Notifying service that we are done\n");
      h->do_destroy = GNUNET_SYSERR;     /* in 'TEST' mode */
      env = GNUNET_MQ_msg (hdr,
                           GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT);
      GNUNET_MQ_notify_sent (env,
                             &schedule_action,
                             h);
      GNUNET_MQ_send (h->mq,
                      env);
      return;
    }
    GNUNET_CONTAINER_DLL_remove (h->action_head,
                                 h->action_tail,
                                 h->current);
    switch (h->current->type)
    {
    case ACTION_GET:
      transmit_get (h);
      break;
 
    case ACTION_SET:
    case ACTION_UPDATE:
      transmit_set (h);
      break;
 
    case ACTION_WATCH:
      transmit_watch (h);
      break;
 
    default:
      GNUNET_assert (0);
      break;
    }
  }
}

References ACTION_GET, ACTION_SET, ACTION_UPDATE, ACTION_WATCH, env, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT, GNUNET_MQ_get_length(), GNUNET_MQ_msg, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_SYSERR, GNUNET_YES, h, GNUNET_ARM_Handle::mq, reconnect_later(), transmit_get(), transmit_set(), transmit_watch(), and try_connect().

Referenced by add_setter_action(), GNUNET_STATISTICS_destroy(), GNUNET_STATISTICS_get(), handle_statistics_end(), reconnect_task(), schedule_watch_request(), transmit_get(), transmit_set(), and transmit_watch().

Here is the call graph for this function:

Here is the caller graph for this function:

schedule_watch_request()

static void schedule_watch_request ( struct GNUNET_STATISTICS_Handle *  h, struct GNUNET_STATISTICS_WatchEntry *  watch  )

static

Transmit request to service that we want to watch the development of a particular value.

Parameters

h	statistics handle
watch	watch entry of the value to watch

Definition at line 337 of file statistics_api.c.

{
  struct GNUNET_STATISTICS_GetHandle *ai;
  size_t slen;
  size_t nlen;
  size_t nsize;
 
  slen = strlen (watch->subsystem) + 1;
  nlen = strlen (watch->name) + 1;
  nsize = sizeof(struct GNUNET_MessageHeader) + slen + nlen;
  if (nsize >= GNUNET_MAX_MESSAGE_SIZE)
  {
    GNUNET_break (0);
    return;
  }
  ai = GNUNET_new (struct GNUNET_STATISTICS_GetHandle);
  ai->sh = h;
  ai->subsystem = GNUNET_strdup (watch->subsystem);
  ai->name = GNUNET_strdup (watch->name);
  ai->timeout = GNUNET_TIME_UNIT_FOREVER_ABS;
  ai->msize = nsize;
  ai->type = ACTION_WATCH;
  ai->proc = watch->proc;
  ai->cls = watch->proc_cls;
  GNUNET_CONTAINER_DLL_insert_tail (h->action_head,
                                    h->action_tail,
                                    ai);
  schedule_action (h);
}

References ACTION_WATCH, ai, GNUNET_break, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_MAX_MESSAGE_SIZE, GNUNET_new, GNUNET_strdup, GNUNET_TIME_UNIT_FOREVER_ABS, h, schedule_action(), and watch.

Referenced by GNUNET_STATISTICS_watch(), and try_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

free_action_item()

static void free_action_item ( struct GNUNET_STATISTICS_GetHandle *  gh )

static

Free memory associated with the given action item.

Parameters

gh	action item to free

Definition at line 375 of file statistics_api.c.

{
  GNUNET_free (gh->subsystem);
  GNUNET_free (gh->name);
  GNUNET_free (gh);
}

References gh, and GNUNET_free.

Referenced by do_disconnect(), GNUNET_STATISTICS_destroy(), handle_statistics_end(), transmit_set(), transmit_watch(), and try_connect().

Here is the caller graph for this function:

do_disconnect()

static void do_disconnect ( struct GNUNET_STATISTICS_Handle *  h )

static

Disconnect from the statistics service.

Parameters

h	statistics handle to disconnect from

Definition at line 389 of file statistics_api.c.

{
  struct GNUNET_STATISTICS_GetHandle *c;
 
  h->receiving = GNUNET_NO;
  if (NULL != (c = h->current))
  {
    h->current = NULL;
    if ((NULL != c->cont) &&
        (GNUNET_YES != c->aborted))
    {
      c->cont (c->cls,
               GNUNET_SYSERR);
      c->cont = NULL;
    }
    free_action_item (c);
  }
  if (NULL != h->mq)
  {
    GNUNET_MQ_destroy (h->mq);
    h->mq = NULL;
  }
}

References GNUNET_STATISTICS_GetHandle::aborted, GNUNET_STATISTICS_GetHandle::cls, GNUNET_STATISTICS_GetHandle::cont, free_action_item(), GNUNET_MQ_destroy(), GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, h, and GNUNET_ARM_Handle::mq.

Referenced by GNUNET_STATISTICS_destroy(), handle_disconnect_confirm(), handle_statistics_end(), handle_statistics_watch_value(), and mq_error_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

check_statistics_value()

static int check_statistics_value ( void *  cls, const struct GNUNET_STATISTICS_ReplyMessage *  smsg  )

static

Process a GNUNET_MESSAGE_TYPE_STATISTICS_VALUE message.

Parameters

cls	statistics handle
smsg	message received from the service, never NULL

Returns

GNUNET_OK if the message was well-formed

Definition at line 422 of file statistics_api.c.

{
  const char *service;
  const char *name;
  uint16_t size;
 
  size = ntohs (smsg->header.size);
  size -= sizeof(struct GNUNET_STATISTICS_ReplyMessage);
  if (size !=
      GNUNET_STRINGS_buffer_tokenize ((const char *) &smsg[1],
                                      size,
                                      2,
                                      &service,
                                      &name))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_OK, GNUNET_STRINGS_buffer_tokenize(), GNUNET_SYSERR, GNUNET_STATISTICS_ReplyMessage::header, name, service, GNUNET_MessageHeader::size, and size.

Here is the call graph for this function:

handle_statistics_value()

static void handle_statistics_value ( void *  cls, const struct GNUNET_STATISTICS_ReplyMessage *  smsg  )

static

Process a GNUNET_MESSAGE_TYPE_STATISTICS_VALUE message.

Parameters

cls	statistics handle
smsg	message received from the service, never NULL

Returns

GNUNET_OK if the message was well-formed

Definition at line 453 of file statistics_api.c.

{
  struct GNUNET_STATISTICS_Handle *h = cls;
  const char *service;
  const char *name;
  uint16_t size;
 
  if (h->current->aborted)
    return;           /* iteration aborted, don't bother */
 
  size = ntohs (smsg->header.size);
  size -= sizeof(struct GNUNET_STATISTICS_ReplyMessage);
  GNUNET_assert (size ==
                 GNUNET_STRINGS_buffer_tokenize ((const char *) &smsg[1],
                                                 size,
                                                 2,
                                                 &service,
                                                 &name));
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received valid statistic on `%s:%s': %llu\n",
       service, name,
       (unsigned long long) GNUNET_ntohll (smsg->value));
  if (GNUNET_OK !=
      h->current->proc (h->current->cls,
                        service,
                        name,
                        GNUNET_ntohll (smsg->value),
                        (0 !=
                         (ntohl (smsg->uid) & GNUNET_STATISTICS_PERSIST_BIT)) ))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Processing of remaining statistics aborted by client.\n");
    h->current->aborted = GNUNET_YES;
  }
}

References GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ntohll(), GNUNET_OK, GNUNET_STATISTICS_PERSIST_BIT, GNUNET_STRINGS_buffer_tokenize(), GNUNET_YES, h, GNUNET_STATISTICS_ReplyMessage::header, LOG, name, service, GNUNET_MessageHeader::size, size, GNUNET_STATISTICS_ReplyMessage::uid, and GNUNET_STATISTICS_ReplyMessage::value.

Here is the call graph for this function:

handle_statistics_watch_value()

static void handle_statistics_watch_value ( void *  cls, const struct GNUNET_STATISTICS_WatchValueMessage *  wvm  )

static

We have received a watch value from the service.

Process it.

Parameters

cls	statistics handle
wvm	the watch value message

Definition at line 498 of file statistics_api.c.

{
  struct GNUNET_STATISTICS_Handle *h = cls;
  struct GNUNET_STATISTICS_WatchEntry *w;
  uint32_t wid;
 
  GNUNET_break (0 == ntohl (wvm->reserved));
  wid = ntohl (wvm->wid);
  if (wid >= h->watches_size)
  {
    do_disconnect (h);
    reconnect_later (h);
    return;
  }
  w = h->watches[wid];
  if (NULL == w)
    return;
  (void) w->proc (w->proc_cls,
                  w->subsystem,
                  w->name,
                  GNUNET_ntohll (wvm->value),
                  0 != (ntohl (wvm->flags) & GNUNET_STATISTICS_PERSIST_BIT));
}

References do_disconnect(), GNUNET_STATISTICS_WatchValueMessage::flags, GNUNET_break, GNUNET_ntohll(), GNUNET_STATISTICS_PERSIST_BIT, h, GNUNET_STATISTICS_WatchEntry::name, GNUNET_STATISTICS_WatchEntry::proc, GNUNET_STATISTICS_WatchEntry::proc_cls, reconnect_later(), GNUNET_STATISTICS_WatchValueMessage::reserved, GNUNET_STATISTICS_WatchEntry::subsystem, GNUNET_STATISTICS_WatchValueMessage::value, and GNUNET_STATISTICS_WatchValueMessage::wid.

Here is the call graph for this function:

mq_error_handler()

static void mq_error_handler ( void *  cls, enum GNUNET_MQ_Error  error  )

static

Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue.

Not every message queue implementation supports an error handler.

Parameters

cls	closure with the struct GNUNET_STATISTICS_Handle *
error	error code

Definition at line 534 of file statistics_api.c.

{
  struct GNUNET_STATISTICS_Handle *h = cls;
 
  if (GNUNET_NO != h->do_destroy)
  {
    h->do_destroy = GNUNET_NO;
    if (NULL != h->destroy_task)
    {
      GNUNET_SCHEDULER_cancel (h->destroy_task);
      h->destroy_task = NULL;
    }
    GNUNET_STATISTICS_destroy (h,
                               GNUNET_NO);
    return;
  }
  do_disconnect (h);
  reconnect_later (h);
}

References do_disconnect(), GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_destroy(), h, and reconnect_later().

Referenced by try_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

do_destroy()

static void do_destroy ( void *  cls )

static

Task used to destroy the statistics handle.

Parameters

cls	the struct GNUNET_STATISTICS_Handle

Definition at line 562 of file statistics_api.c.

{
  struct GNUNET_STATISTICS_Handle *h = cls;
 
  h->destroy_task = NULL;
  h->do_destroy = GNUNET_NO;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Running final destruction\n");
  GNUNET_STATISTICS_destroy (h,
                             GNUNET_NO);
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, GNUNET_STATISTICS_destroy(), h, and LOG.

Referenced by GNUNET_STATISTICS_destroy(), handle_disconnect_confirm(), and reconnect_later().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_disconnect_confirm()

static void handle_disconnect_confirm ( void *  cls, const struct GNUNET_MessageHeader *  msg  )

static

Handle a GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT_CONFIRM message.

We receive this message at the end of the shutdown when the service confirms that all data has been written to disk.

Parameters

cls	our struct GNUNET_STATISTICS_Handle *
msg	the message

Definition at line 584 of file statistics_api.c.

{
  struct GNUNET_STATISTICS_Handle *h = cls;
 
  if (GNUNET_SYSERR != h->do_destroy)
  {
    /* not in shutdown, why do we get 'TEST'? */
    GNUNET_break (0);
    do_disconnect (h);
    reconnect_later (h);
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received DISCONNNECT_CONFIRM message from statistics, can complete disconnect\n");
  if (NULL != h->destroy_task)
    GNUNET_SCHEDULER_cancel (h->destroy_task);
  h->destroy_task = GNUNET_SCHEDULER_add_now (&do_destroy,
                                              h);
}

References do_destroy(), do_disconnect(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_SYSERR, h, LOG, and reconnect_later().

Here is the call graph for this function:

handle_statistics_end()

static void handle_statistics_end ( void *  cls, const struct GNUNET_MessageHeader *  msg  )

static

Handle a GNUNET_MESSAGE_TYPE_STATISTICS_END message.

We receive this message in response to a query to indicate that there are no further matching results.

Parameters

cls	our struct GNUNET_STATISTICS_Handle *
msg	the message

Definition at line 615 of file statistics_api.c.

{
  struct GNUNET_STATISTICS_Handle *h = cls;
  struct GNUNET_STATISTICS_GetHandle *c;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received end of statistics marker\n");
  if (NULL == (c = h->current))
  {
    GNUNET_break (0);
    do_disconnect (h);
    reconnect_later (h);
    return;
  }
  h->backoff = GNUNET_TIME_UNIT_MILLISECONDS;
  h->current = NULL;
  schedule_action (h);
  if (NULL != c->cont)
  {
    c->cont (c->cls,
             GNUNET_OK);
    c->cont = NULL;
  }
  free_action_item (c);
}

References GNUNET_STATISTICS_GetHandle::cls, GNUNET_STATISTICS_GetHandle::cont, do_disconnect(), free_action_item(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_OK, GNUNET_TIME_UNIT_MILLISECONDS, h, LOG, reconnect_later(), and schedule_action().

Here is the call graph for this function:

try_connect()

static int try_connect ( struct GNUNET_STATISTICS_Handle *  h )

static

Try to (re)connect to the statistics service.

Parameters

h	statistics handle to reconnect

Returns

GNUNET_YES on success, GNUNET_NO on failure.

Definition at line 650 of file statistics_api.c.

{
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_fixed_size (disconnect_confirm,
                             GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT_CONFIRM,
                             struct GNUNET_MessageHeader,
                             h),
    GNUNET_MQ_hd_fixed_size (statistics_end,
                             GNUNET_MESSAGE_TYPE_STATISTICS_END,
                             struct GNUNET_MessageHeader,
                             h),
    GNUNET_MQ_hd_var_size (statistics_value,
                           GNUNET_MESSAGE_TYPE_STATISTICS_VALUE,
                           struct GNUNET_STATISTICS_ReplyMessage,
                           h),
    GNUNET_MQ_hd_fixed_size (statistics_watch_value,
                             GNUNET_MESSAGE_TYPE_STATISTICS_WATCH_VALUE,
                             struct GNUNET_STATISTICS_WatchValueMessage,
                             h),
    GNUNET_MQ_handler_end ()
  };
  struct GNUNET_STATISTICS_GetHandle *gh;
  struct GNUNET_STATISTICS_GetHandle *gn;
 
  if (NULL != h->backoff_task)
    return GNUNET_NO;
  if (NULL != h->mq)
    return GNUNET_YES;
  h->mq = GNUNET_CLIENT_connect (h->cfg,
                                 "statistics",
                                 handlers,
                                 &mq_error_handler,
                                 h);
  if (NULL == h->mq)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Failed to connect to statistics service!\n");
    return GNUNET_NO;
  }
  gn = h->action_head;
  while (NULL != (gh = gn))
  {
    gn = gh->next;
    if (gh->type == ACTION_WATCH)
    {
      GNUNET_CONTAINER_DLL_remove (h->action_head,
                                   h->action_tail,
                                   gh);
      free_action_item (gh);
    }
  }
  for (unsigned int i = 0; i < h->watches_size; i++)
    if (NULL != h->watches[i])
      schedule_watch_request (h,
                              h->watches[i]);
  return GNUNET_YES;
}

References ACTION_WATCH, GNUNET_ARM_Handle::cfg, free_action_item(), gh, GNUNET_CLIENT_connect(), GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT_CONFIRM, GNUNET_MESSAGE_TYPE_STATISTICS_END, GNUNET_MESSAGE_TYPE_STATISTICS_VALUE, GNUNET_MESSAGE_TYPE_STATISTICS_WATCH_VALUE, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_NO, GNUNET_YES, h, handlers, LOG, GNUNET_ARM_Handle::mq, mq_error_handler(), and schedule_watch_request().

Referenced by schedule_action().

Here is the call graph for this function:

Here is the caller graph for this function:

reconnect_task()

static void reconnect_task ( void *  cls )

static

We've waited long enough, reconnect now.

Parameters

cls	the struct GNUNET_STATISTICS_Handle to reconnect

Definition at line 715 of file statistics_api.c.

{
  struct GNUNET_STATISTICS_Handle *h = cls;
 
  h->backoff_task = NULL;
  schedule_action (h);
}

References h, and schedule_action().

Referenced by reconnect_later().

Here is the call graph for this function:

Here is the caller graph for this function:

transmit_get()

static void transmit_get ( struct GNUNET_STATISTICS_Handle *  handle )

static

Transmit a GET request (and if successful, start to receive the response).

Parameters

handle

statistics handle

Definition at line 771 of file statistics_api.c.

{
  struct GNUNET_STATISTICS_GetHandle *c;
  struct GNUNET_MessageHeader *hdr;
  struct GNUNET_MQ_Envelope *env;
  size_t slen1;
  size_t slen2;
 
  GNUNET_assert (NULL != (c = handle->current));
  slen1 = strlen (c->subsystem) + 1;
  slen2 = strlen (c->name) + 1;
  env = GNUNET_MQ_msg_extra (hdr,
                             slen1 + slen2,
                             GNUNET_MESSAGE_TYPE_STATISTICS_GET);
  GNUNET_assert (slen1 + slen2 ==
                 GNUNET_STRINGS_buffer_fill ((char *) &hdr[1],
                                             slen1 + slen2,
                                             2,
                                             c->subsystem,
                                             c->name));
  GNUNET_MQ_notify_sent (env,
                         &schedule_action,
                         handle);
  GNUNET_MQ_send (handle->mq,
                  env);
}

References env, GNUNET_assert, GNUNET_MESSAGE_TYPE_STATISTICS_GET, GNUNET_MQ_msg_extra, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_STRINGS_buffer_fill(), handle, GNUNET_DNS_Handle::mq, GNUNET_STATISTICS_GetHandle::name, schedule_action(), and GNUNET_STATISTICS_GetHandle::subsystem.

Referenced by schedule_action().

Here is the call graph for this function:

Here is the caller graph for this function:

transmit_watch()

static void transmit_watch ( struct GNUNET_STATISTICS_Handle *  handle )

static

Transmit a WATCH request (and if successful, start to receive the response).

Parameters

handle

statistics handle

Definition at line 806 of file statistics_api.c.

{
  struct GNUNET_MessageHeader *hdr;
  struct GNUNET_MQ_Envelope *env;
  size_t slen1;
  size_t slen2;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Transmitting watch request for `%s'\n",
       handle->current->name);
  slen1 = strlen (handle->current->subsystem) + 1;
  slen2 = strlen (handle->current->name) + 1;
  env = GNUNET_MQ_msg_extra (hdr,
                             slen1 + slen2,
                             GNUNET_MESSAGE_TYPE_STATISTICS_WATCH);
  GNUNET_assert (slen1 + slen2 ==
                 GNUNET_STRINGS_buffer_fill ((char *) &hdr[1],
                                             slen1 + slen2,
                                             2,
                                             handle->current->subsystem,
                                             handle->current->name));
  GNUNET_MQ_notify_sent (env,
                         &schedule_action,
                         handle);
  GNUNET_MQ_send (handle->mq,
                  env);
  GNUNET_assert (NULL == handle->current->cont);
  free_action_item (handle->current);
  handle->current = NULL;
  schedule_action (handle);
}

References env, free_action_item(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_STATISTICS_WATCH, GNUNET_MQ_msg_extra, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_STRINGS_buffer_fill(), handle, LOG, GNUNET_DNS_Handle::mq, and schedule_action().

Referenced by schedule_action().

Here is the call graph for this function:

Here is the caller graph for this function:

transmit_set()

static void transmit_set ( struct GNUNET_STATISTICS_Handle *  handle )

static

Transmit a SET/UPDATE request.

Parameters

handle

statistics handle

Definition at line 845 of file statistics_api.c.

{
  struct GNUNET_STATISTICS_SetMessage *r;
  struct GNUNET_MQ_Envelope *env;
  size_t slen;
  size_t nlen;
 
  slen = strlen (handle->current->subsystem) + 1;
  nlen = strlen (handle->current->name) + 1;
  env = GNUNET_MQ_msg_extra (r,
                             slen + nlen,
                             GNUNET_MESSAGE_TYPE_STATISTICS_SET);
  r->flags = 0;
  r->value = GNUNET_htonll (handle->current->value);
  if (handle->current->make_persistent)
    r->flags |= htonl (GNUNET_STATISTICS_SETFLAG_PERSISTENT);
  if (handle->current->type == ACTION_UPDATE)
    r->flags |= htonl (GNUNET_STATISTICS_SETFLAG_RELATIVE);
  GNUNET_assert (slen + nlen ==
                 GNUNET_STRINGS_buffer_fill ((char *) &r[1],
                                             slen + nlen,
                                             2,
                                             handle->current->subsystem,
                                             handle->current->name));
  GNUNET_assert (NULL == handle->current->cont);
  free_action_item (handle->current);
  handle->current = NULL;
  update_memory_statistics (handle);
  GNUNET_MQ_notify_sent (env,
                         &schedule_action,
                         handle);
  GNUNET_MQ_send (handle->mq,
                  env);
}

References ACTION_UPDATE, env, GNUNET_STATISTICS_SetMessage::flags, free_action_item(), GNUNET_assert, GNUNET_htonll(), GNUNET_MESSAGE_TYPE_STATISTICS_SET, GNUNET_MQ_msg_extra, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_STATISTICS_SETFLAG_PERSISTENT, GNUNET_STATISTICS_SETFLAG_RELATIVE, GNUNET_STRINGS_buffer_fill(), handle, GNUNET_DNS_Handle::mq, schedule_action(), update_memory_statistics(), and GNUNET_STATISTICS_SetMessage::value.

Referenced by schedule_action().

Here is the call graph for this function:

Here is the caller graph for this function:

add_setter_action()

static void add_setter_action ( struct GNUNET_STATISTICS_Handle *  h, const char *  name, int  make_persistent, uint64_t  value, enum ActionType  type  )

static

Queue a request to change a statistic.

Parameters

h	statistics handle
name	name of the value
make_persistent	should the value be kept across restarts?
value	new value or change
type	type of the action (ACTION_SET or ACTION_UPDATE)

Definition at line 1214 of file statistics_api.c.

{
  struct GNUNET_STATISTICS_GetHandle *ai;
  size_t slen;
  size_t nlen;
  size_t nsize;
  int64_t delta;
 
  slen = strlen (h->subsystem) + 1;
  nlen = strlen (name) + 1;
  nsize = sizeof(struct GNUNET_STATISTICS_SetMessage) + slen + nlen;
  if (nsize >= GNUNET_MAX_MESSAGE_SIZE)
  {
    GNUNET_break (0);
    return;
  }
  for (ai = h->action_head; NULL != ai; ai = ai->next)
  {
    if (! ((0 == strcmp (ai->subsystem,
                         h->subsystem)) &&
           (0 == strcmp (ai->name,
                         name)) &&
           ((ACTION_UPDATE == ai->type) ||
            (ACTION_SET == ai->type))))
      continue;
    if (ACTION_SET == ai->type)
    {
      if (ACTION_UPDATE == type)
      {
        delta = (int64_t) value;
        if (delta > 0)
        {
          /* update old set by new delta */
          ai->value += delta;
        }
        else
        {
          /* update old set by new delta, but never go negative */
          if (ai->value < -delta)
            ai->value = 0;
          else
            ai->value += delta;
        }
      }
      else
      {
        /* new set overrides old set */
        ai->value = value;
      }
    }
    else
    {
      if (ACTION_UPDATE == type)
      {
        /* make delta cumulative */
        delta = (int64_t) value;
        ai->value += delta;
      }
      else
      {
        /* drop old 'update', use new 'set' instead */
        ai->value = value;
        ai->type = type;
      }
    }
    ai->timeout
      = GNUNET_TIME_relative_to_absolute (SET_TRANSMIT_TIMEOUT);
    ai->make_persistent
      = make_persistent;
    return;
  }
  /* no existing entry matches, create a fresh one */
  ai = GNUNET_new (struct GNUNET_STATISTICS_GetHandle);
  ai->sh = h;
  ai->subsystem = GNUNET_strdup (h->subsystem);
  ai->name = GNUNET_strdup (name);
  ai->timeout = GNUNET_TIME_relative_to_absolute (SET_TRANSMIT_TIMEOUT);
  ai->make_persistent = make_persistent;
  ai->msize = nsize;
  ai->value = value;
  ai->type = type;
  GNUNET_CONTAINER_DLL_insert_tail (h->action_head,
                                    h->action_tail,
                                    ai);
  schedule_action (h);
}

References ACTION_SET, ACTION_UPDATE, ai, delta, GNUNET_break, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_MAX_MESSAGE_SIZE, GNUNET_new, GNUNET_strdup, GNUNET_TIME_relative_to_absolute(), h, name, GNUNET_TRANSPORT_AddressIdentifier::next, schedule_action(), SET_TRANSMIT_TIMEOUT, type, and value.

Referenced by GNUNET_STATISTICS_set(), and GNUNET_STATISTICS_update().

Here is the call graph for this function:

Here is the caller graph for this function: