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:442

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.

Referenced by add_setter_action().

◆ LOG

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

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 };
Watch a value.
Update a value.
Get a value.
Set 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.

References GNUNET_STATISTICS_Handle::do_destroy, GNUNET_NO, GNUNET_STATISTICS_set(), h, GNUNET_STATISTICS_Handle::peak_heap_size, GNUNET_STATISTICS_Handle::peak_rss, reconnect_later(), and schedule_action().

Referenced by transmit_set().

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 }
int do_destroy
Should this handle auto-destruct once all actions have been processed?
#define GNUNET_NO
Definition: gnunet_common.h:78
uint64_t peak_rss
Maximum resident set side observed so far (if available).
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
uint64_t peak_heap_size
Maximum heap size observed so far (if available).
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.

References _, GNUNET_STATISTICS_Handle::action_head, ACTION_SET, GNUNET_STATISTICS_Handle::backoff, GNUNET_STATISTICS_Handle::backoff_task, GNUNET_STATISTICS_Handle::destroy_task, GNUNET_STATISTICS_Handle::do_destroy, 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, GNUNET_STATISTICS_GetHandle::make_persistent, GNUNET_STATISTICS_GetHandle::next, reconnect_task(), and GNUNET_STATISTICS_GetHandle::type.

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

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)
753  h);
754  return;
755  }
756  h->backoff_task
759  h);
761 }
int do_destroy
Should this handle auto-destruct once all actions have been processed?
int make_persistent
Flag for SET/UPDATE actions.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
enum ActionType type
Is this a ACTION_GET, ACTION_SET, ACTION_UPDATE or ACTION_WATCH?
Linked list of things we still need to do.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
struct GNUNET_TIME_Relative backoff
Time for next connect retry.
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:1253
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:1280
struct GNUNET_SCHEDULER_Task * backoff_task
Task doing exponential back-off trying to reconnect.
static void reconnect_task(void *cls)
We've waited long enough, reconnect now.
static void do_destroy(void *cls)
Task used to destroy the statistics handle.
struct GNUNET_SCHEDULER_Task * destroy_task
Task for running do_destroy().
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
Set a value.
static struct GNUNET_TRANSPORT_HelloGetHandle * gh
Pending GNUNET_TRANSPORT_hello_get() operation.
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_STATISTICS_GetHandle * next
This is a doubly linked list.
struct GNUNET_STATISTICS_GetHandle * action_head
Head of the linked list of pending actions (first action to be performed).
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
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.

References ACTION_GET, GNUNET_STATISTICS_Handle::action_head, ACTION_SET, GNUNET_STATISTICS_Handle::action_tail, ACTION_UPDATE, ACTION_WATCH, GNUNET_STATISTICS_Handle::backoff_task, GNUNET_STATISTICS_Handle::current, GNUNET_STATISTICS_Handle::do_destroy, 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, GNUNET_STATISTICS_Handle::mq, reconnect_later(), transmit_get(), transmit_set(), transmit_watch(), try_connect(), and GNUNET_STATISTICS_GetHandle::type.

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

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,
1031  GNUNET_MQ_notify_sent (env,
1032  &schedule_action,
1033  h);
1034  GNUNET_MQ_send (h->mq,
1035  env);
1036  return;
1037  }
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 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
int do_destroy
Should this handle auto-destruct once all actions have been processed?
static void reconnect_later(struct GNUNET_STATISTICS_Handle *h)
Reconnect at a later time, respecting back-off.
static void transmit_set(struct GNUNET_STATISTICS_Handle *handle)
Transmit a SET/UPDATE request.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
enum ActionType type
Is this a ACTION_GET, ACTION_SET, ACTION_UPDATE or ACTION_WATCH?
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
Handle for the service.
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
Watch a value.
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:774
unsigned int GNUNET_MQ_get_length(struct GNUNET_MQ_Handle *mq)
Obtain the current length of the message queue.
Definition: mq.c:335
struct GNUNET_SCHEDULER_Task * backoff_task
Task doing exponential back-off trying to reconnect.
static int try_connect(struct GNUNET_STATISTICS_Handle *h)
Try to (re)connect to the statistics service.
#define GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT
Client is done sending service requests and will now disconnect.
struct GNUNET_STATISTICS_GetHandle * action_tail
Tail of the linked list of actions (for fast append).
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct GNUNET_MQ_Handle * mq
Message queue to the service.
Update a value.
Get a value.
static void transmit_get(struct GNUNET_STATISTICS_Handle *handle)
Transmit a GET request (and if successful, start to receive the response).
Set a value.
static void schedule_action(void *cls)
Schedule the next action to be performed.
#define GNUNET_log(kind,...)
struct GNUNET_STATISTICS_GetHandle * current
Action we are currently busy with (action request has been transmitted, we&#39;re now receiving the respo...
Header for all communications.
#define GNUNET_YES
Definition: gnunet_common.h:77
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:353
static void transmit_watch(struct GNUNET_STATISTICS_Handle *handle)
Transmit a WATCH request (and if successful, start to receive the response).
struct GNUNET_STATISTICS_GetHandle * action_head
Head of the linked list of pending actions (first action to be performed).
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.

References GNUNET_STATISTICS_Handle::action_head, GNUNET_STATISTICS_Handle::action_tail, ACTION_WATCH, ai, GNUNET_STATISTICS_GetHandle::cls, GNUNET_break, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_MAX_MESSAGE_SIZE, GNUNET_new, GNUNET_strdup, GNUNET_TIME_UNIT_FOREVER_ABS, h, GNUNET_STATISTICS_GetHandle::msize, GNUNET_STATISTICS_WatchEntry::name, GNUNET_STATISTICS_GetHandle::name, GNUNET_STATISTICS_WatchEntry::proc, GNUNET_STATISTICS_GetHandle::proc, GNUNET_STATISTICS_WatchEntry::proc_cls, schedule_action(), GNUNET_STATISTICS_GetHandle::sh, GNUNET_STATISTICS_WatchEntry::subsystem, GNUNET_STATISTICS_GetHandle::subsystem, GNUNET_STATISTICS_GetHandle::timeout, and GNUNET_STATISTICS_GetHandle::type.

Referenced by GNUNET_STATISTICS_watch(), and try_connect().

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);
358  ai->msize = nsize;
359  ai->type = ACTION_WATCH;
360  ai->proc = watch->proc;
361  ai->cls = watch->proc_cls;
363  h->action_tail,
364  ai);
365  schedule_action (h);
366 }
char * name
What value is this action about? (can be NULL)
void * proc_cls
Closure for proc.
GNUNET_STATISTICS_Iterator proc
Function to call (for GET actions only).
char * subsystem
What subsystem is this action about? (can be NULL)
enum ActionType type
Is this a ACTION_GET, ACTION_SET, ACTION_UPDATE or ACTION_WATCH?
char * name
What value is this action about? (never NULL)
Linked list of things we still need to do.
uint16_t msize
Size of the message that we will be transmitting.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_TIME_Absolute timeout
Timeout for this action.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
Watch a value.
GNUNET_STATISTICS_Iterator proc
Function to call.
struct GNUNET_STATISTICS_GetHandle * action_tail
Tail of the linked list of actions (for fast append).
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
struct GNUNET_STATISTICS_Handle * sh
Main statistics handle.
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message...
static void schedule_action(void *cls)
Schedule the next action to be performed.
void * cls
Closure for proc and cont.
Header for all communications.
char * subsystem
What subsystem is this action about? (never NULL)
struct GNUNET_STATISTICS_GetHandle * action_head
Head of the linked list of pending actions (first action to be performed).
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.

References GNUNET_free, GNUNET_free_non_null, GNUNET_STATISTICS_GetHandle::name, and GNUNET_STATISTICS_GetHandle::subsystem.

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

376 {
379  GNUNET_free (gh);
380 }
char * name
What value is this action about? (can be NULL)
char * subsystem
What subsystem is this action about? (can be NULL)
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
#define GNUNET_free(ptr)
Wrapper around free.
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.

References GNUNET_STATISTICS_GetHandle::aborted, GNUNET_STATISTICS_GetHandle::cls, GNUNET_STATISTICS_GetHandle::cont, GNUNET_STATISTICS_Handle::current, free_action_item(), GNUNET_MQ_destroy(), GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, GNUNET_STATISTICS_Handle::mq, and GNUNET_STATISTICS_Handle::receiving.

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

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  {
408  GNUNET_MQ_destroy (h->mq);
409  h->mq = NULL;
410  }
411 }
int receiving
Are we currently receiving from the service?
Linked list of things we still need to do.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
GNUNET_STATISTICS_Callback cont
Continuation to call once action is complete.
struct GNUNET_MQ_Handle * mq
Message queue to the service.
void * cls
Closure for proc and cont.
struct GNUNET_STATISTICS_GetHandle * current
Action we are currently busy with (action request has been transmitted, we&#39;re now receiving the respo...
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:824
#define GNUNET_YES
Definition: gnunet_common.h:77
static void free_action_item(struct GNUNET_STATISTICS_GetHandle *gh)
Free memory associated with the given action item.
int aborted
Has the current iteration been aborted; for GET actions.
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.

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

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 }
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_STATISTICS_VALUE.
Definition: statistics.h:45
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
Statistics message.
Definition: statistics.h:40
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
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:135
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static unsigned int size
Size of the "table".
Definition: peer.c:67
const char * name
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.

References GNUNET_STATISTICS_GetHandle::aborted, GNUNET_STATISTICS_GetHandle::cls, GNUNET_STATISTICS_Handle::current, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ntohll(), GNUNET_OK, GNUNET_STATISTICS_PERSIST_BIT, GNUNET_STRINGS_buffer_tokenize(), GNUNET_YES, GNUNET_STATISTICS_ReplyMessage::header, LOG, GNUNET_STATISTICS_WatchEntry::name, GNUNET_STATISTICS_GetHandle::proc, service, size, and GNUNET_MessageHeader::size.

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  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 }
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_STATISTICS_VALUE.
Definition: statistics.h:45
#define LOG(kind,...)
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
GNUNET_STATISTICS_Iterator proc
Function to call (for GET actions only).
Statistics message.
Definition: statistics.h:40
uint32_t uid
Unique numerical identifier for the value (will not change during the same client-session).
Definition: statistics.h:53
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
Handle for the service.
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
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:135
static unsigned int size
Size of the "table".
Definition: peer.c:67
#define GNUNET_STATISTICS_PERSIST_BIT
Flag for the struct GNUNET_STATISTICS_ReplyMessage UID only.
Definition: statistics.h:65
const char * name
void * cls
Closure for proc and cont.
struct GNUNET_STATISTICS_GetHandle * current
Action we are currently busy with (action request has been transmitted, we&#39;re now receiving the respo...
#define GNUNET_YES
Definition: gnunet_common.h:77
uint64_t value
The value.
Definition: statistics.h:58
int aborted
Has the current iteration been aborted; for GET actions.
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:48
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.

References do_disconnect(), GNUNET_STATISTICS_WatchValueMessage::flags, GNUNET_break, GNUNET_ntohll(), GNUNET_STATISTICS_PERSIST_BIT, 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, GNUNET_STATISTICS_Handle::watches, GNUNET_STATISTICS_Handle::watches_size, and GNUNET_STATISTICS_WatchValueMessage::wid.

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 reconnect_later(struct GNUNET_STATISTICS_Handle *h)
Reconnect at a later time, respecting back-off.
struct GNUNET_STATISTICS_WatchEntry ** watches
Array of watch entries.
void * proc_cls
Closure for proc.
static void do_disconnect(struct GNUNET_STATISTICS_Handle *h)
Disconnect from the statistics service.
char * name
What value is this action about? (never NULL)
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 reserved
Reserved (always 0).
Definition: statistics.h:139
Handle for the service.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
GNUNET_STATISTICS_Iterator proc
Function to call.
uint32_t wid
Unique watch identification number (watch requests are enumerated in the order they are received...
Definition: statistics.h:134
#define GNUNET_STATISTICS_PERSIST_BIT
Flag for the struct GNUNET_STATISTICS_ReplyMessage UID only.
Definition: statistics.h:65
unsigned int watches_size
Size of the watches array.
Entry kept for each value we are watching.
char * subsystem
What subsystem is this action about? (never NULL)
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:48
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.

References GNUNET_STATISTICS_Handle::destroy_task, GNUNET_STATISTICS_Handle::do_destroy, do_disconnect(), GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_destroy(), and reconnect_later().

Referenced by try_connect().

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  {
545  h->destroy_task = NULL;
546  }
548  GNUNET_NO);
549  return;
550  }
551  do_disconnect (h);
552  reconnect_later (h);
553 }
int do_destroy
Should this handle auto-destruct once all actions have been processed?
static void reconnect_later(struct GNUNET_STATISTICS_Handle *h)
Reconnect at a later time, respecting back-off.
static void do_disconnect(struct GNUNET_STATISTICS_Handle *h)
Disconnect from the statistics service.
#define GNUNET_NO
Definition: gnunet_common.h:78
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).
Handle for the service.
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
struct GNUNET_SCHEDULER_Task * destroy_task
Task for running do_destroy().
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
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.

References GNUNET_STATISTICS_Handle::destroy_task, GNUNET_STATISTICS_Handle::do_destroy, GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, GNUNET_STATISTICS_destroy(), and LOG.

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

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 }
int do_destroy
Should this handle auto-destruct once all actions have been processed?
#define LOG(kind,...)
#define GNUNET_NO
Definition: gnunet_common.h:78
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).
Handle for the service.
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
struct GNUNET_SCHEDULER_Task * destroy_task
Task for running do_destroy().
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.

References GNUNET_STATISTICS_Handle::destroy_task, GNUNET_STATISTICS_Handle::do_destroy, do_destroy(), do_disconnect(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_SYSERR, LOG, and reconnect_later().

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)
602  h);
603 }
int do_destroy
Should this handle auto-destruct once all actions have been processed?
#define LOG(kind,...)
static void reconnect_later(struct GNUNET_STATISTICS_Handle *h)
Reconnect at a later time, respecting back-off.
static void do_disconnect(struct GNUNET_STATISTICS_Handle *h)
Disconnect from the statistics service.
Handle for the service.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
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:1280
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static void do_destroy(void *cls)
Task used to destroy the statistics handle.
struct GNUNET_SCHEDULER_Task * destroy_task
Task for running do_destroy().
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
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.

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

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  }
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 LOG(kind,...)
static void reconnect_later(struct GNUNET_STATISTICS_Handle *h)
Reconnect at a later time, respecting back-off.
static void do_disconnect(struct GNUNET_STATISTICS_Handle *h)
Disconnect from the statistics service.
Linked list of things we still need to do.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
Handle for the service.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
struct GNUNET_TIME_Relative backoff
Time for next connect retry.
#define GNUNET_TIME_UNIT_MILLISECONDS
One millisecond.
GNUNET_STATISTICS_Callback cont
Continuation to call once action is complete.
static void schedule_action(void *cls)
Schedule the next action to be performed.
void * cls
Closure for proc and cont.
struct GNUNET_STATISTICS_GetHandle * current
Action we are currently busy with (action request has been transmitted, we&#39;re now receiving the respo...
static void free_action_item(struct GNUNET_STATISTICS_GetHandle *gh)
Free memory associated with the given action item.
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.

References GNUNET_STATISTICS_Handle::action_head, GNUNET_STATISTICS_Handle::action_tail, ACTION_WATCH, GNUNET_STATISTICS_Handle::backoff_task, GNUNET_STATISTICS_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, LOG, GNUNET_STATISTICS_Handle::mq, mq_error_handler(), GNUNET_STATISTICS_GetHandle::next, schedule_watch_request(), GNUNET_STATISTICS_GetHandle::type, GNUNET_STATISTICS_Handle::watches, and GNUNET_STATISTICS_Handle::watches_size.

Referenced by schedule_action().

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;
678  h->mq = GNUNET_CLIENT_connect (h->cfg,
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  {
696  h->action_tail,
697  gh);
698  free_action_item (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 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration to use.
#define LOG(kind,...)
struct GNUNET_STATISTICS_WatchEntry ** watches
Array of watch entries.
#define GNUNET_MESSAGE_TYPE_STATISTICS_END
Response to a STATISTICS_GET message (end of value stream).
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:1057
Statistics message.
Definition: statistics.h:40
enum ActionType type
Is this a ACTION_GET, ACTION_SET, ACTION_UPDATE or ACTION_WATCH?
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
Linked list of things we still need to do.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_MESSAGE_TYPE_STATISTICS_VALUE
Response to a STATISTICS_GET message (with 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...
Message transmitted if a watched value changes.
Definition: statistics.h:115
Watch a value.
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
#define GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT_CONFIRM
Service confirms disconnect and that it is done processing all requests from the client.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_STATISTICS_WATCH_VALUE
Changes to a watched value.
struct GNUNET_SCHEDULER_Task * backoff_task
Task doing exponential back-off trying to reconnect.
Message handler for a specific message type.
struct GNUNET_STATISTICS_GetHandle * action_tail
Tail of the linked list of actions (for fast append).
struct GNUNET_MQ_Handle * mq
Message queue to the service.
static struct GNUNET_TRANSPORT_HelloGetHandle * gh
Pending GNUNET_TRANSPORT_hello_get() operation.
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...
Header for all communications.
unsigned int watches_size
Size of the watches array.
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_STATISTICS_GetHandle * next
This is a doubly linked list.
static void free_action_item(struct GNUNET_STATISTICS_GetHandle *gh)
Free memory associated with the given action item.
struct GNUNET_STATISTICS_GetHandle * action_head
Head of the linked list of pending actions (first action to be performed).
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
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.

References GNUNET_STATISTICS_Handle::backoff_task, and schedule_action().

Referenced by reconnect_later().

716 {
717  struct GNUNET_STATISTICS_Handle *h = cls;
718 
719  h->backoff_task = NULL;
720  schedule_action (h);
721 }
Handle for the service.
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
struct GNUNET_SCHEDULER_Task * backoff_task
Task doing exponential back-off trying to reconnect.
static void schedule_action(void *cls)
Schedule the next action to be performed.
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.

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

Referenced by schedule_action().

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);
794  GNUNET_MQ_send (handle->mq,
795  env);
796 }
char * name
What value is this action about? (can be NULL)
char * subsystem
What subsystem is this action about? (can be NULL)
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Linked list of things we still need to do.
#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).
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:774
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:65
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct GNUNET_MQ_Handle * mq
Message queue to the service.
static void schedule_action(void *cls)
Schedule the next action to be performed.
struct GNUNET_STATISTICS_GetHandle * current
Action we are currently busy with (action request has been transmitted, we&#39;re now receiving the respo...
Header for all communications.
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:353
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.

References GNUNET_STATISTICS_GetHandle::cont, GNUNET_STATISTICS_Handle::current, 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(), LOG, GNUNET_STATISTICS_Handle::mq, GNUNET_STATISTICS_GetHandle::name, schedule_action(), and GNUNET_STATISTICS_GetHandle::subsystem.

Referenced by schedule_action().

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);
830  GNUNET_MQ_send (handle->mq,
831  env);
832  GNUNET_assert (NULL == handle->current->cont);
833  free_action_item (handle->current);
834  handle->current = NULL;
835  schedule_action (handle);
836 }
char * name
What value is this action about? (can be NULL)
#define LOG(kind,...)
#define GNUNET_MESSAGE_TYPE_STATISTICS_WATCH
Watch changes to a statistical value.
char * subsystem
What subsystem is this action about? (can be NULL)
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#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
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:774
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:65
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
GNUNET_STATISTICS_Callback cont
Continuation to call once action is complete.
struct GNUNET_MQ_Handle * mq
Message queue to the service.
static void schedule_action(void *cls)
Schedule the next action to be performed.
struct GNUNET_STATISTICS_GetHandle * current
Action we are currently busy with (action request has been transmitted, we&#39;re now receiving the respo...
Header for all communications.
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:353
static void free_action_item(struct GNUNET_STATISTICS_GetHandle *gh)
Free memory associated with the given action item.
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.

References ACTION_UPDATE, GNUNET_STATISTICS_GetHandle::cont, GNUNET_STATISTICS_Handle::current, 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(), GNUNET_STATISTICS_GetHandle::make_persistent, GNUNET_STATISTICS_Handle::mq, GNUNET_STATISTICS_GetHandle::name, schedule_action(), GNUNET_STATISTICS_GetHandle::subsystem, GNUNET_STATISTICS_GetHandle::type, update_memory_statistics(), GNUNET_STATISTICS_SetMessage::value, and GNUNET_STATISTICS_GetHandle::value.

Referenced by schedule_action().

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;
854  env = GNUNET_MQ_msg_extra (r,
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;
872  update_memory_statistics (handle);
875  handle);
876  GNUNET_MQ_send (handle->mq,
877  env);
878 }
int make_persistent
Flag for SET/UPDATE actions.
char * name
What value is this action about? (can be NULL)
#define GNUNET_MESSAGE_TYPE_STATISTICS_SET
Set a statistical value.
static void update_memory_statistics(struct GNUNET_STATISTICS_Handle *h)
Obtain statistics about this process&#39;s memory consumption and report those as well (if they changed)...
char * subsystem
What subsystem is this action about? (can be NULL)
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
enum ActionType type
Is this a ACTION_GET, ACTION_SET, ACTION_UPDATE or ACTION_WATCH?
Message to set a statistic.
Definition: statistics.h:91
#define GNUNET_STATISTICS_SETFLAG_RELATIVE
The value being set is a relative change.
Definition: statistics.h:75
#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
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:774
uint64_t value
Associated value.
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:65
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:35
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
GNUNET_STATISTICS_Callback cont
Continuation to call once action is complete.
struct GNUNET_MQ_Handle * mq
Message queue to the service.
Update a value.
uint32_t flags
0 for absolute value, 1 for relative value; 2 to make persistent (see GNUNET_STATISTICS_SETFLAG_*).
Definition: statistics.h:102
static void schedule_action(void *cls)
Schedule the next action to be performed.
struct GNUNET_STATISTICS_GetHandle * current
Action we are currently busy with (action request has been transmitted, we&#39;re now receiving the respo...
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:353
static void free_action_item(struct GNUNET_STATISTICS_GetHandle *gh)
Free memory associated with the given action item.
#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
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.

References GNUNET_STATISTICS_Handle::action_head, ACTION_SET, GNUNET_STATISTICS_Handle::action_tail, 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, GNUNET_STATISTICS_GetHandle::make_persistent, GNUNET_STATISTICS_GetHandle::msize, GNUNET_STATISTICS_GetHandle::name, GNUNET_STATISTICS_GetHandle::next, schedule_action(), SET_TRANSMIT_TIMEOUT, GNUNET_STATISTICS_GetHandle::sh, GNUNET_STATISTICS_GetHandle::subsystem, GNUNET_STATISTICS_Handle::subsystem, GNUNET_STATISTICS_GetHandle::timeout, type, GNUNET_STATISTICS_GetHandle::type, GNUNET_STATISTICS_GetHandle::value, and value.

Referenced by GNUNET_STATISTICS_set(), and GNUNET_STATISTICS_update().

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 cummulative */
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;
1318  h->action_tail,
1319  ai);
1320  schedule_action (h);
1321 }
int make_persistent
Flag for SET/UPDATE actions.
char * name
What value is this action about? (can be NULL)
char * subsystem
Name of our subsystem.
static struct GNUNET_TIME_Relative delta
Definition: speedup.c:35
char * subsystem
What subsystem is this action about? (can be NULL)
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:246
enum ActionType type
Is this a ACTION_GET, ACTION_SET, ACTION_UPDATE or ACTION_WATCH?
Linked list of things we still need to do.
Message to set a statistic.
Definition: statistics.h:91
uint16_t msize
Size of the message that we will be transmitting.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_TIME_Absolute timeout
Timeout for this action.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
static char * value
Value of the record to add/remove.
uint64_t value
Associated value.
struct GNUNET_STATISTICS_GetHandle * action_tail
Tail of the linked list of actions (for fast append).
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
struct GNUNET_STATISTICS_Handle * sh
Main statistics handle.
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message...
Update a value.
#define SET_TRANSMIT_TIMEOUT
How long do we wait until a statistics request for setting a value times out? (The update will be los...
Set a value.
const char * name
static void schedule_action(void *cls)
Schedule the next action to be performed.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
struct GNUNET_STATISTICS_GetHandle * next
This is a doubly linked list.
struct GNUNET_STATISTICS_GetHandle * action_head
Head of the linked list of pending actions (first action to be performed).
Here is the call graph for this function:
Here is the caller graph for this function: