GNUnet 0.21.1
gnunet-service-statistics.c File Reference

program that tracks statistics More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_statistics_service.h"
#include "gnunet_time_lib.h"
#include "statistics.h"
Include dependency graph for gnunet-service-statistics.c:

Go to the source code of this file.

Data Structures

struct  WatchEntry
 Watch entry. More...
 
struct  StatsEntry
 Entry in the statistics list. More...
 
struct  SubsystemEntry
 We keep the statistics organized by subsystem for faster lookup during SET operations. More...
 
struct  ClientEntry
 Information about one of our clients. More...
 

Functions

static void save ()
 Write persistent statistics to disk. More...
 
static void transmit (struct ClientEntry *ce, const struct StatsEntry *e)
 Transmit the given stats value. More...
 
static void * client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *c, struct GNUNET_MQ_Handle *mq)
 Callback called when a client connects to the service. More...
 
static int check_get (void *cls, const struct GNUNET_MessageHeader *message)
 Check integrity of GET-message. More...
 
static void handle_get (void *cls, const struct GNUNET_MessageHeader *message)
 Handle GET-message. More...
 
static void notify_change (struct StatsEntry *se)
 Notify all clients listening about a change to a value. More...
 
static struct SubsystemEntryfind_subsystem_entry (struct ClientEntry *ce, const char *service)
 Find the subsystem entry of the given name for the specified client. More...
 
static struct StatsEntryfind_stat_entry (struct SubsystemEntry *se, const char *name)
 Find the statistics entry of the given subsystem. More...
 
static int check_set (void *cls, const struct GNUNET_STATISTICS_SetMessage *msg)
 Check format of SET-message. More...
 
static void handle_set (void *cls, const struct GNUNET_STATISTICS_SetMessage *msg)
 Handle SET-message. More...
 
static int check_watch (void *cls, const struct GNUNET_MessageHeader *message)
 Check integrity of WATCH-message. More...
 
static void handle_watch (void *cls, const struct GNUNET_MessageHeader *message)
 Handle WATCH-message. More...
 
static void handle_disconnect (void *cls, const struct GNUNET_MessageHeader *message)
 Handle DISCONNECT-message. More...
 
static void do_shutdown ()
 Actually perform the shutdown. More...
 
static void shutdown_task (void *cls)
 Task run during shutdown. More...
 
static void client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *app_cls)
 A client disconnected. More...
 
static int inject_message (void *cls, const struct GNUNET_MessageHeader *message)
 We've read a struct GNUNET_STATISTICS_SetMessage * from disk. More...
 
static void load ()
 Load persistent values from disk. More...
 
static void run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
 Process statistics requests. More...
 
 GNUNET_SERVICE_MAIN ("statistics", GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_var_size(set, GNUNET_MESSAGE_TYPE_STATISTICS_SET, struct GNUNET_STATISTICS_SetMessage, NULL), GNUNET_MQ_hd_var_size(get, GNUNET_MESSAGE_TYPE_STATISTICS_GET, struct GNUNET_MessageHeader, NULL), GNUNET_MQ_hd_var_size(watch, GNUNET_MESSAGE_TYPE_STATISTICS_WATCH, struct GNUNET_MessageHeader, NULL), GNUNET_MQ_hd_fixed_size(disconnect, GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT, struct GNUNET_MessageHeader, NULL), GNUNET_MQ_handler_end())
 Define "main" method using service macro. More...
 

Variables

static const struct GNUNET_CONFIGURATION_Handlecfg
 Our configuration. More...
 
static struct SubsystemEntrysub_head
 Head of linked list of subsystems with active statistics. More...
 
static struct SubsystemEntrysub_tail
 Tail of linked list of subsystems with active statistics. More...
 
static unsigned int client_count
 Number of connected clients. More...
 
static struct GNUNET_NotificationContextnc
 Our notification context. More...
 
static uint32_t uidgen
 Counter used to generate unique values. More...
 
static int in_shutdown
 Set to GNUNET_YES if we are shutting down as soon as possible. More...
 

Detailed Description

program that tracks statistics

Author
Christian Grothoff

Definition in file gnunet-service-statistics.c.

Function Documentation

◆ save()

static void save ( )
static

Write persistent statistics to disk.

Definition at line 238 of file gnunet-service-statistics.c.

239{
240 struct SubsystemEntry *se;
241 struct StatsEntry *pos;
242 char *fn;
243 struct GNUNET_BIO_WriteHandle *wh;
244 uint16_t size;
245 unsigned long long total;
246 size_t nlen;
247 size_t slen;
249
251 "STATISTICS",
252 "DATABASE",
253 &fn))
254 {
256 "STATISTICS",
257 "DATABASE");
258 return;
259 }
262 total = 0;
263 while (NULL != (se = sub_head))
264 {
266 slen = strlen (se->service) + 1;
267 while (NULL != (pos = se->stat_head))
268 {
270 if ((pos->persistent) && (NULL != wh))
271 {
272 nlen = strlen (pos->name) + 1;
273 size = sizeof(struct GNUNET_STATISTICS_SetMessage) + nlen + slen;
274 GNUNET_assert (size < UINT16_MAX);
276
277 msg->header.size = htons ((uint16_t) size);
279 GNUNET_assert (nlen + slen ==
280 GNUNET_STRINGS_buffer_fill ((char *) &msg[1],
281 nlen + slen,
282 2,
283 se->service,
284 pos->name));
285 msg->flags =
287 msg->value = GNUNET_htonll (pos->value);
288 if (GNUNET_OK != GNUNET_BIO_write (wh, "statistics-save-msg", msg,
289 size))
290 {
292 if (GNUNET_OK != GNUNET_BIO_write_close (wh, NULL))
294 wh = NULL;
295 }
296 else
297 {
298 total += size;
299 }
301 }
302 GNUNET_free (pos);
303 }
304 GNUNET_free (se);
305 }
306 if (NULL != wh)
307 {
308 if (GNUNET_OK != GNUNET_BIO_write_close (wh, NULL))
310 if (0 == total)
311 GNUNET_break (0 == unlink (fn));
312 else
314 _ ("Wrote %llu bytes of statistics to `%s'\n"),
315 total,
316 fn);
317 }
318 GNUNET_free (fn);
319}
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
static struct SubsystemEntry * sub_tail
Tail of linked list of subsystems with active statistics.
static struct SubsystemEntry * sub_head
Head of linked list of subsystems with active statistics.
enum GNUNET_GenericReturnValue GNUNET_BIO_write_close(struct GNUNET_BIO_WriteHandle *h, char **emsg)
Close an IO handle.
Definition: bio.c:556
struct GNUNET_BIO_WriteHandle * GNUNET_BIO_write_open_file(const char *fn)
Open a file for writing.
Definition: bio.c:508
enum GNUNET_GenericReturnValue GNUNET_BIO_write(struct GNUNET_BIO_WriteHandle *h, const char *what, const void *buffer, size_t n)
Write a buffer to a handle.
Definition: bio.c:752
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_filename(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be the name of a file or directory.
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create_for_file(const char *filename)
Create the directory structure for storing a file.
Definition: disk.c:582
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_log(kind,...)
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:37
@ GNUNET_OK
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_INFO
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
#define GNUNET_MESSAGE_TYPE_STATISTICS_SET
Set a statistical 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:44
static unsigned int size
Size of the "table".
Definition: peer.c:68
#define _(String)
GNU gettext support macro.
Definition: platform.h:178
#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
Handle for buffered writing.
Definition: bio.c:466
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
Message to set a statistic.
Definition: statistics.h:92
Entry in the statistics list.
uint64_t value
Our value.
int persistent
Is this value persistent?
const char * name
Name for the value stored by this entry, allocated at the end of this struct.
We keep the statistics organized by subsystem for faster lookup during SET operations.
struct StatsEntry * stat_head
Head of list of values kept for this subsystem.
struct StatsEntry * stat_tail
Tail of list of values kept for this subsystem.
const char * service
Name of the subsystem this entry is for, allocated at the end of this struct, do not free().

References _, cfg, GNUNET_assert, GNUNET_BIO_write(), GNUNET_BIO_write_close(), GNUNET_BIO_write_open_file(), GNUNET_break, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONTAINER_DLL_remove, GNUNET_DISK_directory_create_for_file(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_htonll(), GNUNET_log, GNUNET_log_config_missing(), GNUNET_log_strerror_file, GNUNET_malloc, GNUNET_MESSAGE_TYPE_STATISTICS_SET, GNUNET_OK, GNUNET_STATISTICS_SETFLAG_PERSISTENT, GNUNET_STRINGS_buffer_fill(), msg, StatsEntry::name, StatsEntry::persistent, SubsystemEntry::service, GNUNET_MessageHeader::size, size, SubsystemEntry::stat_head, SubsystemEntry::stat_tail, sub_head, sub_tail, GNUNET_MessageHeader::type, and StatsEntry::value.

Referenced by do_shutdown(), GNUNET_STRINGS_parse_ipv6_policy(), iterate_save_entries(), iterate_save_links(), iterate_save_messages(), and save_message_store().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ transmit()

static void transmit ( struct ClientEntry ce,
const struct StatsEntry e 
)
static

Transmit the given stats value.

Parameters
cereceiver of the value
evalue to transmit

Definition at line 329 of file gnunet-service-statistics.c.

330{
331 struct GNUNET_MQ_Envelope *env;
333 size_t size;
334
335 size = strlen (e->subsystem->service) + 1 + strlen (e->name) + 1;
338 m->uid = htonl (e->uid);
339 if (e->persistent)
340 m->uid |= htonl (GNUNET_STATISTICS_PERSIST_BIT);
341 m->value = GNUNET_htonll (e->value);
343 size,
344 2,
345 e->subsystem->service,
346 e->name));
348 "Transmitting value for `%s:%s' (%d): %llu\n",
349 e->subsystem->service,
350 e->name,
351 e->persistent,
352 (unsigned long long) e->value);
353 GNUNET_MQ_send (ce->mq, env);
354}
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static struct GNUNET_ARM_MonitorHandle * m
Monitor connection with ARM.
Definition: gnunet-arm.c:104
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message,...
@ GNUNET_ERROR_TYPE_DEBUG
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:304
#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:63
#define GNUNET_MESSAGE_TYPE_STATISTICS_VALUE
Response to a STATISTICS_GET message (with value).
#define GNUNET_STATISTICS_PERSIST_BIT
Flag for the struct GNUNET_STATISTICS_ReplyMessage UID only.
Definition: statistics.h:65
struct GNUNET_MQ_Handle * mq
Queue for transmissions to client.
Statistics message.
Definition: statistics.h:41
struct SubsystemEntry * subsystem
Subsystem this entry belongs to.
uint32_t uid
Unique ID.

References env, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_htonll(), GNUNET_log, GNUNET_MAX_MESSAGE_SIZE, GNUNET_MESSAGE_TYPE_STATISTICS_VALUE, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_STATISTICS_PERSIST_BIT, GNUNET_STRINGS_buffer_fill(), m, ClientEntry::mq, StatsEntry::name, StatsEntry::persistent, SubsystemEntry::service, size, StatsEntry::subsystem, StatsEntry::uid, and StatsEntry::value.

Referenced by handle_get().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ client_connect_cb()

static void * client_connect_cb ( void *  cls,
struct GNUNET_SERVICE_Client c,
struct GNUNET_MQ_Handle mq 
)
static

Callback called when a client connects to the service.

Parameters
clsclosure for the service
cthe new client that connected to the service
mqthe message queue used to send messages to the client
Returns
c

Definition at line 366 of file gnunet-service-statistics.c.

369{
370 struct ClientEntry *ce;
371
372 ce = GNUNET_new (struct ClientEntry);
373 ce->client = c;
374 ce->mq = mq;
375 client_count++;
377 return ce;
378}
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
static unsigned int client_count
Number of connected clients.
static struct GNUNET_NotificationContext * nc
Our notification context.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
void GNUNET_notification_context_add(struct GNUNET_NotificationContext *nc, struct GNUNET_MQ_Handle *mq)
Add a subscriber to the notification context.
Definition: nc.c:161
Information about one of our clients.
struct GNUNET_SERVICE_Client * client
Handle identifying the client.

References ClientEntry::client, client_count, GNUNET_new, GNUNET_notification_context_add(), mq, ClientEntry::mq, and nc.

Here is the call graph for this function:

◆ check_get()

static int check_get ( void *  cls,
const struct GNUNET_MessageHeader message 
)
static

Check integrity of GET-message.

Parameters
clsidentification of the client
messagethe actual message
Returns
GNUNET_OK if message is well-formed

Definition at line 389 of file gnunet-service-statistics.c.

390{
391 const char *service;
392 const char *name;
393 size_t size;
394
395 size = ntohs (message->size) - sizeof(struct GNUNET_MessageHeader);
396 if (size != GNUNET_STRINGS_buffer_tokenize ((const char *) &message[1],
397 size,
398 2,
399 &service,
400 &name))
401 {
402 GNUNET_break (0);
403 return GNUNET_SYSERR;
404 }
405 return GNUNET_OK;
406}
static char * name
Name (label) of the records to list.
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
@ GNUNET_SYSERR
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:72
Header for all communications.

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

Here is the call graph for this function:

◆ handle_get()

static void handle_get ( void *  cls,
const struct GNUNET_MessageHeader message 
)
static

Handle GET-message.

Parameters
clsidentification of the client
messagethe actual message

Definition at line 416 of file gnunet-service-statistics.c.

417{
418 struct ClientEntry *ce = cls;
419 struct GNUNET_MQ_Envelope *env;
421 const char *service;
422 const char *name;
423 size_t slen;
424 size_t nlen;
425 struct SubsystemEntry *se;
426 struct StatsEntry *pos;
427 size_t size;
428
429 size = ntohs (message->size) - sizeof(struct GNUNET_MessageHeader);
431 GNUNET_STRINGS_buffer_tokenize ((const char *) &message[1],
432 size,
433 2,
434 &service,
435 &name));
436 slen = strlen (service);
437 nlen = strlen (name);
439 "Received request for statistics on `%s:%s'\n",
440 slen ? service : "*",
441 nlen ? name : "*");
442 for (se = sub_head; NULL != se; se = se->next)
443 {
444 if (! ((0 == slen) || (0 == strcmp (service, se->service))))
445 continue;
446 for (pos = se->stat_head; NULL != pos; pos = pos->next)
447 {
448 if (! ((0 == nlen) || (0 == strcmp (name, pos->name))))
449 continue;
450 transmit (ce, pos);
451 }
452 }
454 GNUNET_MQ_send (ce->mq, env);
456}
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:34
static void transmit(struct ClientEntry *ce, const struct StatsEntry *e)
Transmit the given stats value.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:78
#define GNUNET_MESSAGE_TYPE_STATISTICS_END
Response to a STATISTICS_GET message (end of value stream).
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2408
struct StatsEntry * next
This is a linked list.
struct SubsystemEntry * next
Subsystems are kept in a DLL.

References ClientEntry::client, end, env, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_STATISTICS_END, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SERVICE_client_continue(), GNUNET_STRINGS_buffer_tokenize(), ClientEntry::mq, name, StatsEntry::name, StatsEntry::next, SubsystemEntry::next, service, SubsystemEntry::service, GNUNET_MessageHeader::size, size, SubsystemEntry::stat_head, sub_head, and transmit().

Here is the call graph for this function:

◆ notify_change()

static void notify_change ( struct StatsEntry se)
static

Notify all clients listening about a change to a value.

Parameters
sevalue that changed

Definition at line 465 of file gnunet-service-statistics.c.

466{
467 struct GNUNET_MQ_Envelope *env;
469 struct WatchEntry *pos;
470
471 for (pos = se->we_head; NULL != pos; pos = pos->next)
472 {
473 if (GNUNET_YES == pos->last_value_set)
474 {
475 if (pos->last_value == se->value)
476 continue;
477 }
478 else
479 {
481 }
483 wvm->flags =
485 wvm->wid = htonl (pos->wid);
486 wvm->reserved = htonl (0);
487 wvm->value = GNUNET_htonll (se->value);
488 GNUNET_MQ_send (pos->ce->mq, env);
489 pos->last_value = se->value;
490 }
491}
@ GNUNET_YES
#define GNUNET_MESSAGE_TYPE_STATISTICS_WATCH_VALUE
Changes to a watched value.
Message transmitted if a watched value changes.
Definition: statistics.h:116
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
struct WatchEntry * we_head
Watch context for changes to this value, or NULL for none.
struct WatchEntry * next
Watch entries are kept in a linked list.
uint64_t last_value
Last value we communicated to the client for this watch entry.
int last_value_set
Is last_value valid GNUNET_NO : last_value is n/a, GNUNET_YES: last_value is valid.
uint32_t wid
Unique watch number for this client and this watched value.
struct ClientEntry * ce
For which client is this watch entry?

References WatchEntry::ce, env, GNUNET_STATISTICS_WatchValueMessage::flags, GNUNET_htonll(), GNUNET_MESSAGE_TYPE_STATISTICS_WATCH_VALUE, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_STATISTICS_SETFLAG_PERSISTENT, GNUNET_YES, WatchEntry::last_value, WatchEntry::last_value_set, ClientEntry::mq, WatchEntry::next, StatsEntry::persistent, GNUNET_STATISTICS_WatchValueMessage::reserved, StatsEntry::value, GNUNET_STATISTICS_WatchValueMessage::value, StatsEntry::we_head, WatchEntry::wid, and GNUNET_STATISTICS_WatchValueMessage::wid.

Referenced by handle_set(), and handle_watch().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ find_subsystem_entry()

static struct SubsystemEntry * find_subsystem_entry ( struct ClientEntry ce,
const char *  service 
)
static

Find the subsystem entry of the given name for the specified client.

Parameters
ceclient looking for the subsystem, may contain a hint to find the entry faster, can be NULL
servicename of the subsystem to look for
Returns
subsystem entry, never NULL (subsystem entry is created if necessary)

Definition at line 503 of file gnunet-service-statistics.c.

504{
505 size_t slen;
506 struct SubsystemEntry *se;
507
508 if (NULL != ce)
509 se = ce->subsystem;
510 else
511 se = NULL;
512 if ((NULL == se) || (0 != strcmp (service, se->service)))
513 {
514 for (se = sub_head; NULL != se; se = se->next)
515 if (0 == strcmp (service, se->service))
516 break;
517 if (NULL != ce)
518 ce->subsystem = se;
519 }
520 if (NULL != se)
521 return se;
523 "Allocating new subsystem entry `%s'\n",
524 service);
525 slen = strlen (service) + 1;
526 se = GNUNET_malloc (sizeof(struct SubsystemEntry) + slen);
527 GNUNET_memcpy (&se[1], service, slen);
528 se->service = (const char *) &se[1];
530 if (NULL != ce)
531 ce->subsystem = se;
532 return se;
533}
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
struct SubsystemEntry * subsystem
Which subsystem is this client writing to (SET/UPDATE)?

References GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_malloc, GNUNET_memcpy, SubsystemEntry::next, service, SubsystemEntry::service, sub_head, sub_tail, and ClientEntry::subsystem.

Referenced by handle_set(), and handle_watch().

Here is the caller graph for this function:

◆ find_stat_entry()

static struct StatsEntry * find_stat_entry ( struct SubsystemEntry se,
const char *  name 
)
static

Find the statistics entry of the given subsystem.

Parameters
sesubsystem to look in
namename of the entry to look for
Returns
statistics entry, or NULL if not found

Definition at line 544 of file gnunet-service-statistics.c.

545{
546 struct StatsEntry *pos;
547
548 for (pos = se->stat_head; NULL != pos; pos = pos->next)
549 if (0 == strcmp (name, pos->name))
550 return pos;
551 return NULL;
552}

References name, StatsEntry::name, StatsEntry::next, and SubsystemEntry::stat_head.

Referenced by handle_set(), and handle_watch().

Here is the caller graph for this function:

◆ check_set()

static int check_set ( void *  cls,
const struct GNUNET_STATISTICS_SetMessage msg 
)
static

Check format of SET-message.

Parameters
clsthe struct ClientEntry
msgthe actual message
Returns
GNUNET_OK if message is well-formed

Definition at line 563 of file gnunet-service-statistics.c.

564{
565 const char *service;
566 const char *name;
567 size_t msize;
568
569 msize = ntohs (msg->header.size) - sizeof(*msg);
570 if (msize != GNUNET_STRINGS_buffer_tokenize ((const char *) &msg[1],
571 msize,
572 2,
573 &service,
574 &name))
575 {
576 GNUNET_break (0);
577 return GNUNET_SYSERR;
578 }
579 return GNUNET_OK;
580}

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

Referenced by inject_message().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_set()

static void handle_set ( void *  cls,
const struct GNUNET_STATISTICS_SetMessage msg 
)
static

Handle SET-message.

Parameters
clsthe struct ClientEntry
msgthe actual message

Definition at line 590 of file gnunet-service-statistics.c.

591{
592 struct ClientEntry *ce = cls;
593 const char *service;
594 const char *name;
595 size_t nlen;
596 uint16_t msize;
597 uint16_t size;
598 struct SubsystemEntry *se;
599 struct StatsEntry *pos;
600 uint32_t flags;
601 uint64_t value;
602 int64_t delta;
603 int changed;
604 int initial_set;
605
606 msize = ntohs (msg->header.size);
607 size = msize - sizeof(struct GNUNET_STATISTICS_SetMessage);
609 size,
610 2,
611 &service,
612 &name));
613 se = find_subsystem_entry (ce, service);
614 flags = ntohl (msg->flags);
615 value = GNUNET_ntohll (msg->value);
617 "Received request to update statistic on `%s:%s' (%u) to/by %llu\n",
618 service,
619 name,
620 (unsigned int) flags,
621 (unsigned long long) value);
622 pos = find_stat_entry (se, name);
623 if (NULL != pos)
624 {
625 initial_set = 0;
627 {
628 changed = (pos->value != value);
629 pos->value = value;
630 }
631 else
632 {
633 delta = (int64_t) value;
634 if ((delta < 0) && (pos->value < -delta))
635 {
636 changed = (0 != pos->value);
637 pos->value = 0;
638 }
639 else
640 {
641 changed = (0 != delta);
642 GNUNET_break ((delta <= 0) || (pos->value + delta > pos->value));
643 pos->value += delta;
644 }
645 }
646 if (GNUNET_NO == pos->set)
647 {
648 pos->set = GNUNET_YES;
649 initial_set = 1;
650 }
652 if (pos != se->stat_head)
653 {
654 /* move to front for faster setting next time! */
657 }
659 "Statistic `%s:%s' updated to value %llu (%d).\n",
660 service,
661 name,
662 (unsigned long long) pos->value,
663 pos->persistent);
664 if ((changed) || (1 == initial_set))
665 notify_change (pos);
667 return;
668 }
669 /* not found, create a new entry */
670 nlen = strlen (name) + 1;
671 pos = GNUNET_malloc (sizeof(struct StatsEntry) + nlen);
672 GNUNET_memcpy (&pos[1], name, nlen);
673 pos->name = (const char *) &pos[1];
674 pos->subsystem = se;
676 (0 < (int64_t) GNUNET_ntohll (msg->value)))
677 {
678 pos->value = GNUNET_ntohll (msg->value);
679 pos->set = GNUNET_YES;
680 }
681 else
682 {
683 pos->set = GNUNET_NO;
684 }
685 pos->uid = uidgen++;
689 "New statistic on `%s:%s' with value %llu created.\n",
690 service,
691 name,
692 (unsigned long long) pos->value);
693 if (NULL != ce)
695}
static char * value
Value of the record to add/remove.
static struct SubsystemEntry * find_subsystem_entry(struct ClientEntry *ce, const char *service)
Find the subsystem entry of the given name for the specified client.
static void notify_change(struct StatsEntry *se)
Notify all clients listening about a change to a value.
static struct StatsEntry * find_stat_entry(struct SubsystemEntry *se, const char *name)
Find the statistics entry of the given subsystem.
static uint32_t uidgen
Counter used to generate unique values.
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:54
@ GNUNET_NO
static struct GNUNET_TIME_Relative delta
Definition: speedup.c:36
#define GNUNET_STATISTICS_SETFLAG_RELATIVE
The value being set is a relative change.
Definition: statistics.h:75
uint32_t flags
0 for absolute value, 1 for relative value; 2 to make persistent (see GNUNET_STATISTICS_SETFLAG_*).
Definition: statistics.h:102
int set
Is this value set? GNUNET_NO: value is n/a, GNUNET_YES: value is valid.

References ClientEntry::client, delta, find_stat_entry(), find_subsystem_entry(), GNUNET_STATISTICS_SetMessage::flags, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_ntohll(), GNUNET_SERVICE_client_continue(), GNUNET_STATISTICS_SETFLAG_PERSISTENT, GNUNET_STATISTICS_SETFLAG_RELATIVE, GNUNET_STRINGS_buffer_tokenize(), GNUNET_YES, msg, name, StatsEntry::name, notify_change(), StatsEntry::persistent, service, StatsEntry::set, GNUNET_MessageHeader::size, size, SubsystemEntry::stat_head, SubsystemEntry::stat_tail, StatsEntry::subsystem, StatsEntry::uid, uidgen, value, and StatsEntry::value.

Referenced by inject_message().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ check_watch()

static int check_watch ( void *  cls,
const struct GNUNET_MessageHeader message 
)
static

Check integrity of WATCH-message.

Parameters
clsthe struct ClientEntry *
messagethe actual message
Returns
GNUNET_OK if message is well-formed

Definition at line 706 of file gnunet-service-statistics.c.

707{
708 size_t size;
709 const char *service;
710 const char *name;
711
712 size = ntohs (message->size) - sizeof(struct GNUNET_MessageHeader);
713 if (size != GNUNET_STRINGS_buffer_tokenize ((const char *) &message[1],
714 size,
715 2,
716 &service,
717 &name))
718 {
719 GNUNET_break (0);
720 return GNUNET_SYSERR;
721 }
722 return GNUNET_OK;
723}

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

Here is the call graph for this function:

◆ handle_watch()

static void handle_watch ( void *  cls,
const struct GNUNET_MessageHeader message 
)
static

Handle WATCH-message.

Parameters
clsthe struct ClientEntry *
messagethe actual message

Definition at line 733 of file gnunet-service-statistics.c.

734{
735 struct ClientEntry *ce = cls;
736 const char *service;
737 const char *name;
738 uint16_t msize;
739 uint16_t size;
740 struct SubsystemEntry *se;
741 struct StatsEntry *pos;
742 struct WatchEntry *we;
743 size_t nlen;
744
745 if (NULL == nc)
746 {
748 return;
749 }
751 msize = ntohs (message->size);
752 size = msize - sizeof(struct GNUNET_MessageHeader);
754 GNUNET_STRINGS_buffer_tokenize ((const char *) &message[1],
755 size,
756 2,
757 &service,
758 &name));
760 "Received request to watch statistic on `%s:%s'\n",
761 service,
762 name);
763 se = find_subsystem_entry (ce, service);
764 pos = find_stat_entry (se, name);
765 if (NULL == pos)
766 {
767 nlen = strlen (name) + 1;
768 pos = GNUNET_malloc (sizeof(struct StatsEntry) + nlen);
769 GNUNET_memcpy (&pos[1], name, nlen);
770 pos->name = (const char *) &pos[1];
771 pos->subsystem = se;
773 pos->uid = uidgen++;
774 pos->set = GNUNET_NO;
776 "New statistic on `%s:%s' with value %llu created.\n",
777 service,
778 name,
779 (unsigned long long) pos->value);
780 }
781 we = GNUNET_new (struct WatchEntry);
782 we->ce = ce;
784 we->wid = ce->max_wid++;
786 if (0 != pos->value)
787 notify_change (pos);
789}
void GNUNET_SERVICE_client_mark_monitor(struct GNUNET_SERVICE_Client *c)
Set the 'monitor' flag on this client.
Definition: service.c:2572
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2489
uint32_t max_wid
Maximum watch ID used by this client so far.
struct WatchEntry * we_tail
Watch context for changes to this value, or NULL for none.

References WatchEntry::ce, ClientEntry::client, find_stat_entry(), find_subsystem_entry(), GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_new, GNUNET_NO, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_SERVICE_client_mark_monitor(), GNUNET_STRINGS_buffer_tokenize(), WatchEntry::last_value_set, ClientEntry::max_wid, name, StatsEntry::name, nc, notify_change(), service, StatsEntry::set, GNUNET_MessageHeader::size, size, SubsystemEntry::stat_head, SubsystemEntry::stat_tail, StatsEntry::subsystem, StatsEntry::uid, uidgen, StatsEntry::value, StatsEntry::we_head, StatsEntry::we_tail, and WatchEntry::wid.

Here is the call graph for this function:

◆ handle_disconnect()

static void handle_disconnect ( void *  cls,
const struct GNUNET_MessageHeader message 
)
static

Handle DISCONNECT-message.

Sync to disk and send back a GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT_CONFIRM message.

Parameters
clsthe struct ClientEntry *
messagethe actual message

Definition at line 801 of file gnunet-service-statistics.c.

802{
803 struct ClientEntry *ce = cls;
804 struct GNUNET_MQ_Envelope *env;
806
808 GNUNET_MQ_send (ce->mq, env);
810}
#define GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT_CONFIRM
Service confirms disconnect and that it is done processing all requests from the client.

References ClientEntry::client, env, GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT_CONFIRM, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SERVICE_client_continue(), ClientEntry::mq, and msg.

Here is the call graph for this function:

◆ do_shutdown()

static void do_shutdown ( )
static

Actually perform the shutdown.

Definition at line 817 of file gnunet-service-statistics.c.

818{
819 struct WatchEntry *we;
820 struct StatsEntry *pos;
821 struct SubsystemEntry *se;
822
823 if (NULL == nc)
824 return;
825 save ();
827 nc = NULL;
829 while (NULL != (se = sub_head))
830 {
832 while (NULL != (pos = se->stat_head))
833 {
835 while (NULL != (we = pos->we_head))
836 {
837 GNUNET_break (0);
839 GNUNET_free (we);
840 }
841 GNUNET_free (pos);
842 }
843 GNUNET_free (se);
844 }
845}
static void save()
Write persistent statistics to disk.
void GNUNET_notification_context_destroy(struct GNUNET_NotificationContext *nc)
Destroy the context, force disconnect for all subscribers.
Definition: nc.c:138

References client_count, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_notification_context_destroy(), nc, save(), SubsystemEntry::stat_head, SubsystemEntry::stat_tail, sub_head, sub_tail, StatsEntry::we_head, and StatsEntry::we_tail.

Referenced by client_disconnect_cb(), and shutdown_task().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ shutdown_task()

static void shutdown_task ( void *  cls)
static

Task run during shutdown.

Parameters
clsunused

Definition at line 854 of file gnunet-service-statistics.c.

855{
857 if (0 != client_count)
858 return;
859 do_shutdown ();
860}
static int in_shutdown
Set to GNUNET_YES if we are shutting down as soon as possible.
static void do_shutdown()
Actually perform the shutdown.

References client_count, do_shutdown(), GNUNET_YES, and in_shutdown.

Referenced by run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ client_disconnect_cb()

static void client_disconnect_cb ( void *  cls,
struct GNUNET_SERVICE_Client client,
void *  app_cls 
)
static

A client disconnected.

Remove all of its data structure entries.

Parameters
clsclosure, NULL
clientidentification of the client
app_clsthe struct ClientEntry *

Definition at line 871 of file gnunet-service-statistics.c.

874{
875 struct ClientEntry *ce = app_cls;
876 struct WatchEntry *we;
877 struct WatchEntry *wen;
878 struct StatsEntry *pos;
879 struct SubsystemEntry *se;
880
881 client_count--;
882 for (se = sub_head; NULL != se; se = se->next)
883 {
884 for (pos = se->stat_head; NULL != pos; pos = pos->next)
885 {
886 wen = pos->we_head;
887 while (NULL != (we = wen))
888 {
889 wen = we->next;
890 if (we->ce != ce)
891 continue;
893 GNUNET_free (we);
894 }
895 }
896 }
897 GNUNET_free (ce);
898 if ((0 == client_count) && (GNUNET_YES == in_shutdown))
899 do_shutdown ();
900}

References WatchEntry::ce, client_count, do_shutdown(), GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_YES, in_shutdown, WatchEntry::next, StatsEntry::next, SubsystemEntry::next, SubsystemEntry::stat_head, sub_head, StatsEntry::we_head, and StatsEntry::we_tail.

Here is the call graph for this function:

◆ inject_message()

static int inject_message ( void *  cls,
const struct GNUNET_MessageHeader message 
)
static

We've read a struct GNUNET_STATISTICS_SetMessage * from disk.

Check that it is well-formed, and if so pass it to the handler for set messages.

Parameters
clsNULL
messagethe message found on disk
Returns
GNUNET_OK on success, GNUNET_NO to stop further processing (no error) GNUNET_SYSERR to stop further processing with error

Definition at line 915 of file gnunet-service-statistics.c.

916{
917 uint16_t msize = ntohs (message->size);
918 const struct GNUNET_STATISTICS_SetMessage *sm;
919
920 sm = (const struct GNUNET_STATISTICS_SetMessage *) message;
921 if ((sizeof(struct GNUNET_STATISTICS_SetMessage) > msize) ||
922 (GNUNET_OK != check_set (NULL, sm)))
923 {
924 GNUNET_break (0);
925 return GNUNET_SYSERR;
926 }
927 handle_set (NULL, sm);
928 return GNUNET_OK;
929}
static void handle_set(void *cls, const struct GNUNET_STATISTICS_SetMessage *msg)
Handle SET-message.
static int check_set(void *cls, const struct GNUNET_STATISTICS_SetMessage *msg)
Check format of SET-message.

References check_set(), GNUNET_break, GNUNET_OK, GNUNET_SYSERR, handle_set(), and GNUNET_MessageHeader::size.

Referenced by load().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ load()

static void load ( )
static

Load persistent values from disk.

Disk format is exactly the same format that we also use for setting the values over the network.

Definition at line 937 of file gnunet-service-statistics.c.

938{
939 char *fn;
940 struct GNUNET_BIO_ReadHandle *rh;
941 uint64_t fsize;
942 char *buf;
944
946 "STATISTICS",
947 "DATABASE",
948 &fn))
949 {
951 "STATISTICS",
952 "DATABASE");
953 return;
954 }
955 if ((GNUNET_OK !=
957 (0 == fsize))
958 {
959 GNUNET_free (fn);
960 return;
961 }
962 buf = GNUNET_malloc (fsize);
964 if (! rh)
965 {
966 GNUNET_free (buf);
967 GNUNET_free (fn);
968 return;
969 }
970 if (GNUNET_OK != GNUNET_BIO_read (rh, fn, buf, fsize))
971 {
974 GNUNET_free (buf);
975 GNUNET_free (fn);
976 return;
977 }
979 _ ("Loading %llu bytes of statistics from `%s'\n"),
980 (unsigned long long) fsize,
981 fn);
982 mst = GNUNET_MST_create (&inject_message, NULL);
984 GNUNET_OK ==
985 GNUNET_MST_from_buffer (mst, buf, (size_t) fsize, GNUNET_YES, GNUNET_NO));
986 GNUNET_MST_destroy (mst);
987 GNUNET_free (buf);
989 GNUNET_free (fn);
990}
static int inject_message(void *cls, const struct GNUNET_MessageHeader *message)
We've read a struct GNUNET_STATISTICS_SetMessage * from disk.
enum GNUNET_GenericReturnValue GNUNET_BIO_read(struct GNUNET_BIO_ReadHandle *h, const char *what, void *result, size_t len)
Read some contents into a buffer.
Definition: bio.c:291
enum GNUNET_GenericReturnValue GNUNET_BIO_read_close(struct GNUNET_BIO_ReadHandle *h, char **emsg)
Close an open handle.
Definition: bio.c:162
struct GNUNET_BIO_ReadHandle * GNUNET_BIO_read_open_file(const char *fn)
Open a file for reading.
Definition: bio.c:114
enum GNUNET_GenericReturnValue GNUNET_DISK_file_size(const char *filename, uint64_t *size, int include_symbolic_links, int single_file_mode)
Get the size of the file (or directory) of the given file (in bytes).
Definition: disk.c:221
enum GNUNET_GenericReturnValue GNUNET_MST_from_buffer(struct GNUNET_MessageStreamTokenizer *mst, const char *buf, size_t size, int purge, int one_shot)
Add incoming data to the receive buffer and call the callback for all complete messages.
Definition: mst.c:101
struct GNUNET_MessageStreamTokenizer * GNUNET_MST_create(GNUNET_MessageTokenizerCallback cb, void *cb_cls)
Create a message stream tokenizer.
Definition: mst.c:86
void GNUNET_MST_destroy(struct GNUNET_MessageStreamTokenizer *mst)
Destroys a tokenizer.
Definition: mst.c:404
Handle for buffered reading.
Definition: bio.c:69
Handle to a message stream tokenizer.
Definition: mst.c:45

References _, cfg, GNUNET_BIO_read(), GNUNET_BIO_read_close(), GNUNET_BIO_read_open_file(), GNUNET_break, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_DISK_file_size(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_log_config_missing(), GNUNET_log_strerror_file, GNUNET_malloc, GNUNET_MST_create(), GNUNET_MST_destroy(), GNUNET_MST_from_buffer(), GNUNET_NO, GNUNET_OK, GNUNET_YES, and inject_message().

Referenced by calculate_load(), GNUNET_LOAD_get_average(), GNUNET_LOAD_get_load(), GNUNET_LOAD_update(), GNUNET_LOAD_value_set_decline(), internal_update(), and run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ run()

static void run ( void *  cls,
const struct GNUNET_CONFIGURATION_Handle c,
struct GNUNET_SERVICE_Handle service 
)
static

Process statistics requests.

Parameters
clsclosure
cconfiguration to use
servicethe initialized service

Definition at line 1001 of file gnunet-service-statistics.c.

1004{
1005 cfg = c;
1007 load ();
1009}
static void shutdown_task(void *cls)
Task run during shutdown.
static void load()
Load persistent values from disk.
struct GNUNET_NotificationContext * GNUNET_notification_context_create(unsigned int queue_length)
Create a new notification context.
Definition: nc.c:122
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received,...
Definition: scheduler.c:1340

References cfg, GNUNET_notification_context_create(), GNUNET_SCHEDULER_add_shutdown(), load(), nc, and shutdown_task().

Here is the call graph for this function:

◆ GNUNET_SERVICE_MAIN()

Define "main" method using service macro.

Variable Documentation

◆ cfg

const struct GNUNET_CONFIGURATION_Handle* cfg
static

Our configuration.

Definition at line 201 of file gnunet-service-statistics.c.

Referenced by load(), run(), and save().

◆ sub_head

struct SubsystemEntry* sub_head
static

Head of linked list of subsystems with active statistics.

Definition at line 206 of file gnunet-service-statistics.c.

Referenced by client_disconnect_cb(), do_shutdown(), find_subsystem_entry(), handle_get(), and save().

◆ sub_tail

struct SubsystemEntry* sub_tail
static

Tail of linked list of subsystems with active statistics.

Definition at line 211 of file gnunet-service-statistics.c.

Referenced by do_shutdown(), find_subsystem_entry(), and save().

◆ client_count

unsigned int client_count
static

Number of connected clients.

Definition at line 216 of file gnunet-service-statistics.c.

Referenced by client_connect_cb(), client_disconnect_cb(), do_shutdown(), and shutdown_task().

◆ nc

struct GNUNET_NotificationContext* nc
static

Our notification context.

Definition at line 221 of file gnunet-service-statistics.c.

Referenced by client_connect_cb(), do_shutdown(), handle_watch(), and run().

◆ uidgen

uint32_t uidgen
static

Counter used to generate unique values.

Definition at line 226 of file gnunet-service-statistics.c.

Referenced by handle_set(), and handle_watch().

◆ in_shutdown

int in_shutdown
static

Set to GNUNET_YES if we are shutting down as soon as possible.

Definition at line 231 of file gnunet-service-statistics.c.

Referenced by client_disconnect_cb(), and shutdown_task().