GNUnet  0.11.x
Data Structures | Macros | Enumerations | Functions
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_HandleGNUNET_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_GetHandleGNUNET_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 '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:
#define GNUNET_TIME_UNIT_SECONDS
One second.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:311

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.

47 {
51  ACTION_GET,
52 
56  ACTION_SET,
57 
62 
67 };
@ ACTION_SET
Set a value.
@ ACTION_GET
Get a value.
@ ACTION_WATCH
Watch a value.
@ ACTION_UPDATE
Update a value.

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.

266 {
267 #if ENABLE_HEAP_STATISTICS
268  uint64_t current_heap_size = 0;
269  uint64_t current_rss = 0;
270 
271  if (GNUNET_NO != h->do_destroy)
272  return;
273 #if HAVE_MALLINFO
274  {
275  struct mallinfo mi;
276 
277  mi = mallinfo ();
278  current_heap_size = mi.uordblks + mi.fordblks;
279  }
280 #endif
281 #if HAVE_GETRUSAGE
282  {
283  struct rusage ru;
284 
285  if (0 == getrusage (RUSAGE_SELF, &ru))
286  {
287  current_rss = 1024LL * ru.ru_maxrss;
288  }
289  }
290 #endif
291  if (current_heap_size > h->peak_heap_size)
292  {
293  h->peak_heap_size = current_heap_size;
295  "# peak heap size",
296  current_heap_size,
297  GNUNET_NO);
298  }
299  if (current_rss > h->peak_rss)
300  {
301  h->peak_rss = current_rss;
303  "# peak resident set size",
304  current_rss,
305  GNUNET_NO);
306  }
307 #endif
308 }
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
@ GNUNET_NO
Definition: gnunet_common.h:94
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.

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
hstatistics handle

Definition at line 730 of file statistics_api.c.

731 {
732  int loss;
734 
735  GNUNET_assert (NULL == h->backoff_task);
736  if (GNUNET_YES == h->do_destroy)
737  {
738  /* So we are shutting down and the service is not reachable.
739  * Chances are that it's down for good and we are not going to connect to
740  * it anymore.
741  * Give up and don't sync the rest of the data.
742  */loss = GNUNET_NO;
743  for (gh = h->action_head; NULL != gh; gh = gh->next)
744  if ((gh->make_persistent) &&
745  (ACTION_SET == gh->type))
746  loss = GNUNET_YES;
747  if (GNUNET_YES == loss)
749  _ ("Could not save some persistent statistics\n"));
750  if (NULL != h->destroy_task)
751  GNUNET_SCHEDULER_cancel (h->destroy_task);
752  h->destroy_task = GNUNET_SCHEDULER_add_now (&do_destroy,
753  h);
754  return;
755  }
756  h->backoff_task
757  = GNUNET_SCHEDULER_add_delayed (h->backoff,
759  h);
760  h->backoff = GNUNET_TIME_STD_BACKOFF (h->backoff);
761 }
static struct GNUNET_TRANSPORT_HelloGetHandle * gh
Pending GNUNET_TRANSPORT_hello_get() operation.
#define GNUNET_log(kind,...)
@ GNUNET_YES
Definition: gnunet_common.h:97
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
@ GNUNET_ERROR_TYPE_WARNING
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1296
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1269
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
static void do_destroy(void *cls)
Task used to destroy the statistics handle.
static void reconnect_task(void *cls)
We've waited long enough, reconnect now.
Linked list of things we still need to do.

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
clsstatistics handle to reconnect
clsstatistics handle

Definition at line 1001 of file statistics_api.c.

1002 {
1003  struct GNUNET_STATISTICS_Handle *h = cls;
1004 
1005  if (NULL != h->backoff_task)
1006  return; /* action already pending */
1007  if (GNUNET_YES != try_connect (h))
1008  {
1009  reconnect_later (h);
1010  return;
1011  }
1012  if (0 < GNUNET_MQ_get_length (h->mq))
1013  return; /* Wait for queue to be reduced more */
1014  /* schedule next action */
1015  while (NULL == h->current)
1016  {
1017  h->current = h->action_head;
1018  if (NULL == h->current)
1019  {
1020  struct GNUNET_MessageHeader *hdr;
1021  struct GNUNET_MQ_Envelope *env;
1022 
1023  if (GNUNET_YES != h->do_destroy)
1024  return; /* nothing to do */
1025  /* let service know that we're done */
1027  "Notifying service that we are done\n");
1028  h->do_destroy = GNUNET_SYSERR; /* in 'TEST' mode */
1029  env = GNUNET_MQ_msg (hdr,
1032  &schedule_action,
1033  h);
1034  GNUNET_MQ_send (h->mq,
1035  env);
1036  return;
1037  }
1038  GNUNET_CONTAINER_DLL_remove (h->action_head,
1039  h->action_tail,
1040  h->current);
1041  switch (h->current->type)
1042  {
1043  case ACTION_GET:
1044  transmit_get (h);
1045  break;
1046 
1047  case ACTION_SET:
1048  case ACTION_UPDATE:
1049  transmit_set (h);
1050  break;
1051 
1052  case ACTION_WATCH:
1053  transmit_watch (h);
1054  break;
1055 
1056  default:
1057  GNUNET_assert (0);
1058  break;
1059  }
1060  }
1061 }
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
@ GNUNET_ERROR_TYPE_DEBUG
unsigned int GNUNET_MQ_get_length(struct GNUNET_MQ_Handle *mq)
Obtain the current length of the message queue.
Definition: mq.c:337
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
void GNUNET_MQ_notify_sent(struct GNUNET_MQ_Envelope *ev, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
Call a callback once the envelope has been sent, that is, sending it can not be canceled anymore.
Definition: mq.c:787
#define GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT
Client is done sending service requests and will now disconnect.
static void reconnect_later(struct GNUNET_STATISTICS_Handle *h)
Reconnect at a later time, respecting back-off.
static void transmit_watch(struct GNUNET_STATISTICS_Handle *handle)
Transmit a WATCH request (and if successful, start to receive the response).
static void schedule_action(void *cls)
Schedule the next action to be performed.
static int try_connect(struct GNUNET_STATISTICS_Handle *h)
Try to (re)connect to the statistics service.
static void transmit_get(struct GNUNET_STATISTICS_Handle *handle)
Transmit a GET request (and if successful, start to receive the response).
static void transmit_set(struct GNUNET_STATISTICS_Handle *handle)
Transmit a SET/UPDATE request.
struct GNUNET_MQ_Handle * mq
Our connection to the ARM service.
Definition: arm_api.c:107
Header for all communications.
Handle for the service.

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
hstatistics handle
watchwatch entry of the value to watch

Definition at line 337 of file statistics_api.c.

339 {
341  size_t slen;
342  size_t nlen;
343  size_t nsize;
344 
345  slen = strlen (watch->subsystem) + 1;
346  nlen = strlen (watch->name) + 1;
347  nsize = sizeof(struct GNUNET_MessageHeader) + slen + nlen;
348  if (nsize >= GNUNET_MAX_MESSAGE_SIZE)
349  {
350  GNUNET_break (0);
351  return;
352  }
354  ai->sh = h;
355  ai->subsystem = GNUNET_strdup (watch->subsystem);
356  ai->name = GNUNET_strdup (watch->name);
357  ai->timeout = GNUNET_TIME_UNIT_FOREVER_ABS;
358  ai->msize = nsize;
359  ai->type = ACTION_WATCH;
360  ai->proc = watch->proc;
361  ai->cls = watch->proc_cls;
362  GNUNET_CONTAINER_DLL_insert_tail (h->action_head,
363  h->action_tail,
364  ai);
365  schedule_action (h);
366 }
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
static int watch
Watch value continuously.
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message,...
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".

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
ghaction item to free

Definition at line 375 of file statistics_api.c.

376 {
377  GNUNET_free (gh->subsystem);
378  GNUNET_free (gh->name);
379  GNUNET_free (gh);
380 }
#define GNUNET_free(ptr)
Wrapper around free.

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
hstatistics handle to disconnect from

Definition at line 389 of file statistics_api.c.

390 {
391  struct GNUNET_STATISTICS_GetHandle *c;
392 
393  h->receiving = GNUNET_NO;
394  if (NULL != (c = h->current))
395  {
396  h->current = NULL;
397  if ((NULL != c->cont) &&
398  (GNUNET_YES != c->aborted))
399  {
400  c->cont (c->cls,
401  GNUNET_SYSERR);
402  c->cont = NULL;
403  }
404  free_action_item (c);
405  }
406  if (NULL != h->mq)
407  {
409  h->mq = NULL;
410  }
411 }
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:837
static void free_action_item(struct GNUNET_STATISTICS_GetHandle *gh)
Free memory associated with the given action item.
GNUNET_STATISTICS_Callback cont
Continuation to call once action is complete.
int aborted
Has the current iteration been aborted; for GET actions.
void * cls
Closure for proc and cont.

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
clsstatistics handle
smsgmessage received from the service, never NULL
Returns
GNUNET_OK if the message was well-formed

Definition at line 422 of file statistics_api.c.

424 {
425  const char *service;
426  const char *name;
427  uint16_t size;
428 
429  size = ntohs (smsg->header.size);
430  size -= sizeof(struct GNUNET_STATISTICS_ReplyMessage);
431  if (size !=
432  GNUNET_STRINGS_buffer_tokenize ((const char *) &smsg[1],
433  size,
434  2,
435  &service,
436  &name))
437  {
438  GNUNET_break (0);
439  return GNUNET_SYSERR;
440  }
441  return GNUNET_OK;
442 }
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
@ GNUNET_OK
Definition: gnunet_common.h:95
unsigned int GNUNET_STRINGS_buffer_tokenize(const char *buffer, size_t size, unsigned int count,...)
Given a buffer of a given size, find "count" 0-terminated strings in the buffer and assign the count ...
Definition: strings.c:96
static unsigned int size
Size of the "table".
Definition: peer.c:67
const char * name
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
Statistics message.
Definition: statistics.h:41
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_STATISTICS_VALUE.
Definition: statistics.h:45

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
clsstatistics handle
msgmessage received from the service, never NULL
Returns
GNUNET_OK if the message was well-formed

Definition at line 453 of file statistics_api.c.

455 {
456  struct GNUNET_STATISTICS_Handle *h = cls;
457  const char *service;
458  const char *name;
459  uint16_t size;
460 
461  if (h->current->aborted)
462  return; /* iteration aborted, don't bother */
463 
464  size = ntohs (smsg->header.size);
465  size -= sizeof(struct GNUNET_STATISTICS_ReplyMessage);
466  GNUNET_assert (size ==
467  GNUNET_STRINGS_buffer_tokenize ((const char *) &smsg[1],
468  size,
469  2,
470  &service,
471  &name));
473  "Received valid statistic on `%s:%s': %llu\n",
474  service, name,
475  (unsigned long long) GNUNET_ntohll (smsg->value));
476  if (GNUNET_OK !=
477  h->current->proc (h->current->cls,
478  service,
479  name,
480  GNUNET_ntohll (smsg->value),
481  (0 !=
482  (ntohl (smsg->uid) & GNUNET_STATISTICS_PERSIST_BIT)) ))
483  {
485  "Processing of remaining statistics aborted by client.\n");
486  h->current->aborted = GNUNET_YES;
487  }
488 }
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:53
#define GNUNET_STATISTICS_PERSIST_BIT
Flag for the struct GNUNET_STATISTICS_ReplyMessage UID only.
Definition: statistics.h:65
#define LOG(kind,...)
uint32_t uid
Unique numerical identifier for the value (will not change during the same client-session).
Definition: statistics.h:53
uint64_t value
The value.
Definition: statistics.h:58

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
clsstatistics handle
msgthe watch value message

Definition at line 498 of file statistics_api.c.

501 {
502  struct GNUNET_STATISTICS_Handle *h = cls;
504  uint32_t wid;
505 
506  GNUNET_break (0 == ntohl (wvm->reserved));
507  wid = ntohl (wvm->wid);
508  if (wid >= h->watches_size)
509  {
510  do_disconnect (h);
511  reconnect_later (h);
512  return;
513  }
514  w = h->watches[wid];
515  if (NULL == w)
516  return;
517  (void) w->proc (w->proc_cls,
518  w->subsystem,
519  w->name,
520  GNUNET_ntohll (wvm->value),
521  0 != (ntohl (wvm->flags) & GNUNET_STATISTICS_PERSIST_BIT));
522 }
static void do_disconnect(struct GNUNET_STATISTICS_Handle *h)
Disconnect from the statistics service.
Entry kept for each value we are watching.
void * proc_cls
Closure for proc.
char * name
What value is this action about? (never NULL)
GNUNET_STATISTICS_Iterator proc
Function to call.
char * subsystem
What subsystem is this action about? (never NULL)
uint32_t reserved
Reserved (always 0).
Definition: statistics.h:139
uint32_t flags
0 for absolute value, 1 for relative value; 2 to make persistent (see GNUNET_STATISTICS_SETFLAG_*).
Definition: statistics.h:126
uint32_t wid
Unique watch identification number (watch requests are enumerated in the order they are received,...
Definition: statistics.h:134

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
clsclosure with the struct GNUNET_STATISTICS_Handle *
errorerror code

Definition at line 534 of file statistics_api.c.

536 {
537  struct GNUNET_STATISTICS_Handle *h = cls;
538 
539  if (GNUNET_NO != h->do_destroy)
540  {
541  h->do_destroy = GNUNET_NO;
542  if (NULL != h->destroy_task)
543  {
544  GNUNET_SCHEDULER_cancel (h->destroy_task);
545  h->destroy_task = NULL;
546  }
548  GNUNET_NO);
549  return;
550  }
551  do_disconnect (h);
552  reconnect_later (h);
553 }
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).

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
clsthe struct GNUNET_STATISTICS_Handle

Definition at line 562 of file statistics_api.c.

563 {
564  struct GNUNET_STATISTICS_Handle *h = cls;
565 
566  h->destroy_task = NULL;
567  h->do_destroy = GNUNET_NO;
569  "Running final destruction\n");
571  GNUNET_NO);
572 }

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
clsour struct GNUNET_STATISTICS_Handle *
msgthe message

Definition at line 584 of file statistics_api.c.

586 {
587  struct GNUNET_STATISTICS_Handle *h = cls;
588 
589  if (GNUNET_SYSERR != h->do_destroy)
590  {
591  /* not in shutdown, why do we get 'TEST'? */
592  GNUNET_break (0);
593  do_disconnect (h);
594  reconnect_later (h);
595  return;
596  }
598  "Received DISCONNNECT_CONFIRM message from statistics, can complete disconnect\n");
599  if (NULL != h->destroy_task)
600  GNUNET_SCHEDULER_cancel (h->destroy_task);
601  h->destroy_task = GNUNET_SCHEDULER_add_now (&do_destroy,
602  h);
603 }

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
clsour struct GNUNET_STATISTICS_Handle *
msgthe message

Definition at line 615 of file statistics_api.c.

617 {
618  struct GNUNET_STATISTICS_Handle *h = cls;
619  struct GNUNET_STATISTICS_GetHandle *c;
620 
622  "Received end of statistics marker\n");
623  if (NULL == (c = h->current))
624  {
625  GNUNET_break (0);
626  do_disconnect (h);
627  reconnect_later (h);
628  return;
629  }
630  h->backoff = GNUNET_TIME_UNIT_MILLISECONDS;
631  h->current = NULL;
632  schedule_action (h);
633  if (NULL != c->cont)
634  {
635  c->cont (c->cls,
636  GNUNET_OK);
637  c->cont = NULL;
638  }
639  free_action_item (c);
640 }
#define GNUNET_TIME_UNIT_MILLISECONDS
One millisecond.

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
hstatistics handle to reconnect
Returns
GNUNET_YES on success, GNUNET_NO on failure.

Definition at line 650 of file statistics_api.c.

651 {
653  GNUNET_MQ_hd_fixed_size (disconnect_confirm,
655  struct GNUNET_MessageHeader,
656  h),
657  GNUNET_MQ_hd_fixed_size (statistics_end,
659  struct GNUNET_MessageHeader,
660  h),
661  GNUNET_MQ_hd_var_size (statistics_value,
664  h),
665  GNUNET_MQ_hd_fixed_size (statistics_watch_value,
668  h),
670  };
672  struct GNUNET_STATISTICS_GetHandle *gn;
673 
674  if (NULL != h->backoff_task)
675  return GNUNET_NO;
676  if (NULL != h->mq)
677  return GNUNET_YES;
679  "statistics",
680  handlers,
682  h);
683  if (NULL == h->mq)
684  {
686  "Failed to connect to statistics service!\n");
687  return GNUNET_NO;
688  }
689  gn = h->action_head;
690  while (NULL != (gh = gn))
691  {
692  gn = gh->next;
693  if (gh->type == ACTION_WATCH)
694  {
695  GNUNET_CONTAINER_DLL_remove (h->action_head,
696  h->action_tail,
697  gh);
699  }
700  }
701  for (unsigned int i = 0; i < h->watches_size; i++)
702  if (NULL != h->watches[i])
704  h->watches[i]);
705  return GNUNET_YES;
706 }
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
struct GNUNET_MQ_Handle * GNUNET_CLIENT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *service_name, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *error_handler_cls)
Create a message queue to connect to a GNUnet service.
Definition: client.c:1064
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_STATISTICS_END
Response to a STATISTICS_GET message (end of value stream).
#define GNUNET_MESSAGE_TYPE_STATISTICS_VALUE
Response to a STATISTICS_GET message (with value).
#define GNUNET_MESSAGE_TYPE_STATISTICS_WATCH_VALUE
Changes to a watched value.
#define GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT_CONFIRM
Service confirms disconnect and that it is done processing all requests from the client.
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.
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 c...
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration that we are using.
Definition: arm_api.c:112
Message handler for a specific message type.
Message transmitted if a watched value changes.
Definition: statistics.h:116

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
clsthe struct GNUNET_STATISTICS_Handle to reconnect

Definition at line 715 of file statistics_api.c.

716 {
717  struct GNUNET_STATISTICS_Handle *h = cls;
718 
719  h->backoff_task = NULL;
720  schedule_action (h);
721 }

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
handlestatistics handle

Definition at line 771 of file statistics_api.c.

772 {
773  struct GNUNET_STATISTICS_GetHandle *c;
774  struct GNUNET_MessageHeader *hdr;
775  struct GNUNET_MQ_Envelope *env;
776  size_t slen1;
777  size_t slen2;
778 
779  GNUNET_assert (NULL != (c = handle->current));
780  slen1 = strlen (c->subsystem) + 1;
781  slen2 = strlen (c->name) + 1;
782  env = GNUNET_MQ_msg_extra (hdr,
783  slen1 + slen2,
785  GNUNET_assert (slen1 + slen2 ==
786  GNUNET_STRINGS_buffer_fill ((char *) &hdr[1],
787  slen1 + slen2,
788  2,
789  c->subsystem,
790  c->name));
793  handle);
795  env);
796 }
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:52
#define GNUNET_MESSAGE_TYPE_STATISTICS_GET
Get a statistical value(s).
size_t GNUNET_STRINGS_buffer_fill(char *buffer, size_t size, unsigned int count,...)
Fill a buffer of the given size with count 0-terminated strings (given as varargs).
Definition: strings.c:45
struct GNUNET_MQ_Handle * mq
Connection to DNS service, or NULL.
Definition: dns_api.c:61
char * name
What value is this action about? (can be NULL)
char * subsystem
What subsystem is this action about? (can be NULL)

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
handlestatistics handle

Definition at line 806 of file statistics_api.c.

807 {
808  struct GNUNET_MessageHeader *hdr;
809  struct GNUNET_MQ_Envelope *env;
810  size_t slen1;
811  size_t slen2;
812 
814  "Transmitting watch request for `%s'\n",
815  handle->current->name);
816  slen1 = strlen (handle->current->subsystem) + 1;
817  slen2 = strlen (handle->current->name) + 1;
818  env = GNUNET_MQ_msg_extra (hdr,
819  slen1 + slen2,
821  GNUNET_assert (slen1 + slen2 ==
822  GNUNET_STRINGS_buffer_fill ((char *) &hdr[1],
823  slen1 + slen2,
824  2,
825  handle->current->subsystem,
826  handle->current->name));
829  handle);
831  env);
832  GNUNET_assert (NULL == handle->current->cont);
833  free_action_item (handle->current);
834  handle->current = NULL;
836 }
#define GNUNET_MESSAGE_TYPE_STATISTICS_WATCH
Watch changes to a statistical value.

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
handlestatistics handle

Definition at line 845 of file statistics_api.c.

846 {
848  struct GNUNET_MQ_Envelope *env;
849  size_t slen;
850  size_t nlen;
851 
852  slen = strlen (handle->current->subsystem) + 1;
853  nlen = strlen (handle->current->name) + 1;
855  slen + nlen,
857  r->flags = 0;
858  r->value = GNUNET_htonll (handle->current->value);
859  if (handle->current->make_persistent)
861  if (handle->current->type == ACTION_UPDATE)
863  GNUNET_assert (slen + nlen ==
864  GNUNET_STRINGS_buffer_fill ((char *) &r[1],
865  slen + nlen,
866  2,
867  handle->current->subsystem,
868  handle->current->name));
869  GNUNET_assert (NULL == handle->current->cont);
870  free_action_item (handle->current);
871  handle->current = NULL;
875  handle);
877  env);
878 }
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:36
#define GNUNET_MESSAGE_TYPE_STATISTICS_SET
Set a statistical value.
#define GNUNET_STATISTICS_SETFLAG_PERSISTENT
The value being set is to be persistent (note that this bit can be combined with GNUNET_STATISTICS_SE...
Definition: statistics.h:83
#define GNUNET_STATISTICS_SETFLAG_RELATIVE
The value being set is a relative change.
Definition: statistics.h:75
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).
Message to set a statistic.
Definition: statistics.h:92
uint32_t flags
0 for absolute value, 1 for relative value; 2 to make persistent (see GNUNET_STATISTICS_SETFLAG_*).
Definition: statistics.h:102

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
hstatistics handle
namename of the value
make_persistentshould the value be kept across restarts?
valuenew value or change
typetype of the action (ACTION_SET or ACTION_UPDATE)

Definition at line 1232 of file statistics_api.c.

1237 {
1239  size_t slen;
1240  size_t nlen;
1241  size_t nsize;
1242  int64_t delta;
1243 
1244  slen = strlen (h->subsystem) + 1;
1245  nlen = strlen (name) + 1;
1246  nsize = sizeof(struct GNUNET_STATISTICS_SetMessage) + slen + nlen;
1247  if (nsize >= GNUNET_MAX_MESSAGE_SIZE)
1248  {
1249  GNUNET_break (0);
1250  return;
1251  }
1252  for (ai = h->action_head; NULL != ai; ai = ai->next)
1253  {
1254  if (! ((0 == strcmp (ai->subsystem,
1255  h->subsystem)) &&
1256  (0 == strcmp (ai->name,
1257  name)) &&
1258  ((ACTION_UPDATE == ai->type) ||
1259  (ACTION_SET == ai->type))))
1260  continue;
1261  if (ACTION_SET == ai->type)
1262  {
1263  if (ACTION_UPDATE == type)
1264  {
1265  delta = (int64_t) value;
1266  if (delta > 0)
1267  {
1268  /* update old set by new delta */
1269  ai->value += delta;
1270  }
1271  else
1272  {
1273  /* update old set by new delta, but never go negative */
1274  if (ai->value < -delta)
1275  ai->value = 0;
1276  else
1277  ai->value += delta;
1278  }
1279  }
1280  else
1281  {
1282  /* new set overrides old set */
1283  ai->value = value;
1284  }
1285  }
1286  else
1287  {
1288  if (ACTION_UPDATE == type)
1289  {
1290  /* make delta cumulative */
1291  delta = (int64_t) value;
1292  ai->value += delta;
1293  }
1294  else
1295  {
1296  /* drop old 'update', use new 'set' instead */
1297  ai->value = value;
1298  ai->type = type;
1299  }
1300  }
1301  ai->timeout
1303  ai->make_persistent
1304  = make_persistent;
1305  return;
1306  }
1307  /* no existing entry matches, create a fresh one */
1309  ai->sh = h;
1310  ai->subsystem = GNUNET_strdup (h->subsystem);
1311  ai->name = GNUNET_strdup (name);
1313  ai->make_persistent = make_persistent;
1314  ai->msize = nsize;
1315  ai->value = value;
1316  ai->type = type;
1317  GNUNET_CONTAINER_DLL_insert_tail (h->action_head,
1318  h->action_tail,
1319  ai);
1320  schedule_action (h);
1321 }
static char * value
Value of the record to add/remove.
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:181
static struct GNUNET_TIME_Relative delta
Definition: speedup.c:35
#define SET_TRANSMIT_TIMEOUT
How long do we wait until a statistics request for setting a value times out? (The update will be los...
struct GNUNET_TRANSPORT_AddressIdentifier * next
Kept in a DLL.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model

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: