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 SubsystemEntry *	find_subsystem_entry (struct ClientEntry *ce, const char *service)
	Find the subsystem entry of the given name for the specified client. More...
static struct StatsEntry *	find_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_Handle *	cfg
	Our configuration. More...
static struct SubsystemEntry *	sub_head
	Head of linked list of subsystems with active statistics. More...
static struct SubsystemEntry *	sub_tail
	Tail of linked list of subsystems with active statistics. More...
static unsigned int	client_count
	Number of connected clients. More...
static struct GNUNET_NotificationContext *	nc
	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.

{
  struct SubsystemEntry *se;
  struct StatsEntry *pos;
  char *fn;
  struct GNUNET_BIO_WriteHandle *wh;
  uint16_t size;
  unsigned long long total;
  size_t nlen;
  size_t slen;
  struct GNUNET_STATISTICS_SetMessage *msg;
 
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg,
                                                            "STATISTICS",
                                                            "DATABASE",
                                                            &fn))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               "STATISTICS",
                               "DATABASE");
    return;
  }
  (void) GNUNET_DISK_directory_create_for_file (fn);
  wh = GNUNET_BIO_write_open_file (fn);
  total = 0;
  while (NULL != (se = sub_head))
  {
    GNUNET_CONTAINER_DLL_remove (sub_head, sub_tail, se);
    slen = strlen (se->service) + 1;
    while (NULL != (pos = se->stat_head))
    {
      GNUNET_CONTAINER_DLL_remove (se->stat_head, se->stat_tail, pos);
      if ((pos->persistent) && (NULL != wh))
      {
        nlen = strlen (pos->name) + 1;
        size = sizeof(struct GNUNET_STATISTICS_SetMessage) + nlen + slen;
        GNUNET_assert (size < UINT16_MAX);
        msg = GNUNET_malloc (size);
 
        msg->header.size = htons ((uint16_t) size);
        msg->header.type = htons (GNUNET_MESSAGE_TYPE_STATISTICS_SET);
        GNUNET_assert (nlen + slen ==
                       GNUNET_STRINGS_buffer_fill ((char *) &msg[1],
                                                   nlen + slen,
                                                   2,
                                                   se->service,
                                                   pos->name));
        msg->flags =
          htonl (pos->persistent ? GNUNET_STATISTICS_SETFLAG_PERSISTENT : 0);
        msg->value = GNUNET_htonll (pos->value);
        if (GNUNET_OK != GNUNET_BIO_write (wh, "statistics-save-msg", msg,
                                           size))
        {
          GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "write", fn);
          if (GNUNET_OK != GNUNET_BIO_write_close (wh, NULL))
            GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "close", fn);
          wh = NULL;
        }
        else
        {
          total += size;
        }
        GNUNET_free (msg);
      }
      GNUNET_free (pos);
    }
    GNUNET_free (se);
  }
  if (NULL != wh)
  {
    if (GNUNET_OK != GNUNET_BIO_write_close (wh, NULL))
      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "close", fn);
    if (0 == total)
      GNUNET_break (0 == unlink (fn));
    else
      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                  _ ("Wrote %llu bytes of statistics to `%s'\n"),
                  total,
                  fn);
  }
  GNUNET_free (fn);
}

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, StatsEntry::value, and wh.

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

ce	receiver of the value
e	value to transmit

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

{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_STATISTICS_ReplyMessage *m;
  size_t size;
 
  size = strlen (e->subsystem->service) + 1 + strlen (e->name) + 1;
  GNUNET_assert (size < GNUNET_MAX_MESSAGE_SIZE);
  env = GNUNET_MQ_msg_extra (m, size, GNUNET_MESSAGE_TYPE_STATISTICS_VALUE);
  m->uid = htonl (e->uid);
  if (e->persistent)
    m->uid |= htonl (GNUNET_STATISTICS_PERSIST_BIT);
  m->value = GNUNET_htonll (e->value);
  GNUNET_assert (size == GNUNET_STRINGS_buffer_fill ((char *) &m[1],
                                                     size,
                                                     2,
                                                     e->subsystem->service,
                                                     e->name));
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Transmitting value for `%s:%s' (%d): %llu\n",
              e->subsystem->service,
              e->name,
              e->persistent,
              (unsigned long long) e->value);
  GNUNET_MQ_send (ce->mq, env);
}

References e, 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, Experiment::name, and size.

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

cls	closure for the service
c	the new client that connected to the service
mq	the message queue used to send messages to the client

Returns

c

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

{
  struct ClientEntry *ce;
 
  ce = GNUNET_new (struct ClientEntry);
  ce->client = c;
  ce->mq = mq;
  client_count++;
  GNUNET_notification_context_add (nc, mq);
  return ce;
}

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

cls	identification of the client
message	the actual message

Returns

GNUNET_OK if message is well-formed

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

{
  const char *service;
  const char *name;
  size_t size;
 
  size = ntohs (message->size) - sizeof(struct GNUNET_MessageHeader);
  if (size != GNUNET_STRINGS_buffer_tokenize ((const char *) &message[1],
                                              size,
                                              2,
                                              &service,
                                              &name))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_OK, GNUNET_STRINGS_buffer_tokenize(), GNUNET_SYSERR, 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

cls	identification of the client
message	the actual message

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

{
  struct ClientEntry *ce = cls;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *end;
  const char *service;
  const char *name;
  size_t slen;
  size_t nlen;
  struct SubsystemEntry *se;
  struct StatsEntry *pos;
  size_t size;
 
  size = ntohs (message->size) - sizeof(struct GNUNET_MessageHeader);
  GNUNET_assert (size ==
                 GNUNET_STRINGS_buffer_tokenize ((const char *) &message[1],
                                                 size,
                                                 2,
                                                 &service,
                                                 &name));
  slen = strlen (service);
  nlen = strlen (name);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received request for statistics on `%s:%s'\n",
              slen ? service : "*",
              nlen ? name : "*");
  for (se = sub_head; NULL != se; se = se->next)
  {
    if (! ((0 == slen) || (0 == strcmp (service, se->service))))
      continue;
    for (pos = se->stat_head; NULL != pos; pos = pos->next)
    {
      if (! ((0 == nlen) || (0 == strcmp (name, pos->name))))
        continue;
      transmit (ce, pos);
    }
  }
  env = GNUNET_MQ_msg (end, GNUNET_MESSAGE_TYPE_STATISTICS_END);
  GNUNET_MQ_send (ce->mq, env);
  GNUNET_SERVICE_client_continue (ce->client);
}

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

se	value that changed

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

{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_STATISTICS_WatchValueMessage *wvm;
  struct WatchEntry *pos;
 
  for (pos = se->we_head; NULL != pos; pos = pos->next)
  {
    if (GNUNET_YES == pos->last_value_set)
    {
      if (pos->last_value == se->value)
        continue;
    }
    else
    {
      pos->last_value_set = GNUNET_YES;
    }
    env = GNUNET_MQ_msg (wvm, GNUNET_MESSAGE_TYPE_STATISTICS_WATCH_VALUE);
    wvm->flags =
      htonl (se->persistent ? GNUNET_STATISTICS_SETFLAG_PERSISTENT : 0);
    wvm->wid = htonl (pos->wid);
    wvm->reserved = htonl (0);
    wvm->value = GNUNET_htonll (se->value);
    GNUNET_MQ_send (pos->ce->mq, env);
    pos->last_value = se->value;
  }
}

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

ce	client looking for the subsystem, may contain a hint to find the entry faster, can be NULL
service	name 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.

{
  size_t slen;
  struct SubsystemEntry *se;
 
  if (NULL != ce)
    se = ce->subsystem;
  else
    se = NULL;
  if ((NULL == se) || (0 != strcmp (service, se->service)))
  {
    for (se = sub_head; NULL != se; se = se->next)
      if (0 == strcmp (service, se->service))
        break;
    if (NULL != ce)
      ce->subsystem = se;
  }
  if (NULL != se)
    return se;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Allocating new subsystem entry `%s'\n",
              service);
  slen = strlen (service) + 1;
  se = GNUNET_malloc (sizeof(struct SubsystemEntry) + slen);
  GNUNET_memcpy (&se[1], service, slen);
  se->service = (const char *) &se[1];
  GNUNET_CONTAINER_DLL_insert (sub_head, sub_tail, se);
  if (NULL != ce)
    ce->subsystem = se;
  return se;
}

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

se	subsystem to look in
name	name of the entry to look for

Returns

statistics entry, or NULL if not found

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

{
  struct StatsEntry *pos;
 
  for (pos = se->stat_head; NULL != pos; pos = pos->next)
    if (0 == strcmp (name, pos->name))
      return pos;
  return NULL;
}

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

cls	the struct ClientEntry
msg	the actual message

Returns

GNUNET_OK if message is well-formed

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

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

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

cls	the struct ClientEntry
msg	the actual message

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

{
  struct ClientEntry *ce = cls;
  const char *service;
  const char *name;
  size_t nlen;
  uint16_t msize;
  uint16_t size;
  struct SubsystemEntry *se;
  struct StatsEntry *pos;
  uint32_t flags;
  uint64_t value;
  int64_t delta;
  int changed;
  int initial_set;
 
  msize = ntohs (msg->header.size);
  size = msize - sizeof(struct GNUNET_STATISTICS_SetMessage);
  GNUNET_assert (size == GNUNET_STRINGS_buffer_tokenize ((const char *) &msg[1],
                                                         size,
                                                         2,
                                                         &service,
                                                         &name));
  se = find_subsystem_entry (ce, service);
  flags = ntohl (msg->flags);
  value = GNUNET_ntohll (msg->value);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received request to update statistic on `%s:%s' (%u) to/by %llu\n",
              service,
              name,
              (unsigned int) flags,
              (unsigned long long) value);
  pos = find_stat_entry (se, name);
  if (NULL != pos)
  {
    initial_set = 0;
    if (0 == (flags & GNUNET_STATISTICS_SETFLAG_RELATIVE))
    {
      changed = (pos->value != value);
      pos->value = value;
    }
    else
    {
      delta = (int64_t) value;
      if ((delta < 0) && (pos->value < -delta))
      {
        changed = (0 != pos->value);
        pos->value = 0;
      }
      else
      {
        changed = (0 != delta);
        GNUNET_break ((delta <= 0) || (pos->value + delta > pos->value));
        pos->value += delta;
      }
    }
    if (GNUNET_NO == pos->set)
    {
      pos->set = GNUNET_YES;
      initial_set = 1;
    }
    pos->persistent = (0 != (flags & GNUNET_STATISTICS_SETFLAG_PERSISTENT));
    if (pos != se->stat_head)
    {
      /* move to front for faster setting next time! */
      GNUNET_CONTAINER_DLL_remove (se->stat_head, se->stat_tail, pos);
      GNUNET_CONTAINER_DLL_insert (se->stat_head, se->stat_tail, pos);
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Statistic `%s:%s' updated to value %llu (%d).\n",
                service,
                name,
                (unsigned long long) pos->value,
                pos->persistent);
    if ((changed) || (1 == initial_set))
      notify_change (pos);
    GNUNET_SERVICE_client_continue (ce->client);
    return;
  }
  /* not found, create a new entry */
  nlen = strlen (name) + 1;
  pos = GNUNET_malloc (sizeof(struct StatsEntry) + nlen);
  GNUNET_memcpy (&pos[1], name, nlen);
  pos->name = (const char *) &pos[1];
  pos->subsystem = se;
  if ((0 == (flags & GNUNET_STATISTICS_SETFLAG_RELATIVE)) ||
      (0 < (int64_t) GNUNET_ntohll (msg->value)))
  {
    pos->value = GNUNET_ntohll (msg->value);
    pos->set = GNUNET_YES;
  }
  else
  {
    pos->set = GNUNET_NO;
  }
  pos->uid = uidgen++;
  pos->persistent = (0 != (flags & GNUNET_STATISTICS_SETFLAG_PERSISTENT));
  GNUNET_CONTAINER_DLL_insert (se->stat_head, se->stat_tail, pos);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "New statistic on `%s:%s' with value %llu created.\n",
              service,
              name,
              (unsigned long long) pos->value);
  if (NULL != ce)
    GNUNET_SERVICE_client_continue (ce->client);
}

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

cls	the struct ClientEntry *
message	the actual message

Returns

GNUNET_OK if message is well-formed

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

{
  size_t size;
  const char *service;
  const char *name;
 
  size = ntohs (message->size) - sizeof(struct GNUNET_MessageHeader);
  if (size != GNUNET_STRINGS_buffer_tokenize ((const char *) &message[1],
                                              size,
                                              2,
                                              &service,
                                              &name))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_OK, GNUNET_STRINGS_buffer_tokenize(), GNUNET_SYSERR, 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

cls	the struct ClientEntry *
message	the actual message

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

{
  struct ClientEntry *ce = cls;
  const char *service;
  const char *name;
  uint16_t msize;
  uint16_t size;
  struct SubsystemEntry *se;
  struct StatsEntry *pos;
  struct WatchEntry *we;
  size_t nlen;
 
  if (NULL == nc)
  {
    GNUNET_SERVICE_client_drop (ce->client);
    return;
  }
  GNUNET_SERVICE_client_mark_monitor (ce->client);
  msize = ntohs (message->size);
  size = msize - sizeof(struct GNUNET_MessageHeader);
  GNUNET_assert (size ==
                 GNUNET_STRINGS_buffer_tokenize ((const char *) &message[1],
                                                 size,
                                                 2,
                                                 &service,
                                                 &name));
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received request to watch statistic on `%s:%s'\n",
              service,
              name);
  se = find_subsystem_entry (ce, service);
  pos = find_stat_entry (se, name);
  if (NULL == pos)
  {
    nlen = strlen (name) + 1;
    pos = GNUNET_malloc (sizeof(struct StatsEntry) + nlen);
    GNUNET_memcpy (&pos[1], name, nlen);
    pos->name = (const char *) &pos[1];
    pos->subsystem = se;
    GNUNET_CONTAINER_DLL_insert (se->stat_head, se->stat_tail, pos);
    pos->uid = uidgen++;
    pos->set = GNUNET_NO;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "New statistic on `%s:%s' with value %llu created.\n",
                service,
                name,
                (unsigned long long) pos->value);
  }
  we = GNUNET_new (struct WatchEntry);
  we->ce = ce;
  we->last_value_set = GNUNET_NO;
  we->wid = ce->max_wid++;
  GNUNET_CONTAINER_DLL_insert (pos->we_head, pos->we_tail, we);
  if (0 != pos->value)
    notify_change (pos);
  GNUNET_SERVICE_client_continue (ce->client);
}

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

cls	the struct ClientEntry *
message	the actual message

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

{
  struct ClientEntry *ce = cls;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *msg;
 
  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT_CONFIRM);
  GNUNET_MQ_send (ce->mq, env);
  GNUNET_SERVICE_client_continue (ce->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.

{
  struct WatchEntry *we;
  struct StatsEntry *pos;
  struct SubsystemEntry *se;
 
  if (NULL == nc)
    return;
  save ();
  GNUNET_notification_context_destroy (nc);
  nc = NULL;
  GNUNET_assert (0 == client_count);
  while (NULL != (se = sub_head))
  {
    GNUNET_CONTAINER_DLL_remove (sub_head, sub_tail, se);
    while (NULL != (pos = se->stat_head))
    {
      GNUNET_CONTAINER_DLL_remove (se->stat_head, se->stat_tail, pos);
      while (NULL != (we = pos->we_head))
      {
        GNUNET_break (0);
        GNUNET_CONTAINER_DLL_remove (pos->we_head, pos->we_tail, we);
        GNUNET_free (we);
      }
      GNUNET_free (pos);
    }
    GNUNET_free (se);
  }
}

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

cls

unused

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

{
  in_shutdown = GNUNET_YES;
  if (0 != client_count)
    return;
  do_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

cls	closure, NULL
client	identification of the client
app_cls	the struct ClientEntry *

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

{
  struct ClientEntry *ce = app_cls;
  struct WatchEntry *we;
  struct WatchEntry *wen;
  struct StatsEntry *pos;
  struct SubsystemEntry *se;
 
  client_count--;
  for (se = sub_head; NULL != se; se = se->next)
  {
    for (pos = se->stat_head; NULL != pos; pos = pos->next)
    {
      wen = pos->we_head;
      while (NULL != (we = wen))
      {
        wen = we->next;
        if (we->ce != ce)
          continue;
        GNUNET_CONTAINER_DLL_remove (pos->we_head, pos->we_tail, we);
        GNUNET_free (we);
      }
    }
  }
  GNUNET_free (ce);
  if ((0 == client_count) && (GNUNET_YES == in_shutdown))
    do_shutdown ();
}

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

cls	NULL
message	the 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.

{
  uint16_t msize = ntohs (message->size);
  const struct GNUNET_STATISTICS_SetMessage *sm;
 
  sm = (const struct GNUNET_STATISTICS_SetMessage *) message;
  if ((sizeof(struct GNUNET_STATISTICS_SetMessage) > msize) ||
      (GNUNET_OK != check_set (NULL, sm)))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  handle_set (NULL, sm);
  return GNUNET_OK;
}

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.

{
  char *fn;
  struct GNUNET_BIO_ReadHandle *rh;
  uint64_t fsize;
  char *buf;
  struct GNUNET_MessageStreamTokenizer *mst;
 
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg,
                                                            "STATISTICS",
                                                            "DATABASE",
                                                            &fn))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               "STATISTICS",
                               "DATABASE");
    return;
  }
  if ((GNUNET_OK !=
       GNUNET_DISK_file_size (fn, &fsize, GNUNET_NO, GNUNET_YES)) ||
      (0 == fsize))
  {
    GNUNET_free (fn);
    return;
  }
  buf = GNUNET_malloc (fsize);
  rh = GNUNET_BIO_read_open_file (fn);
  if (! rh)
  {
    GNUNET_free (buf);
    GNUNET_free (fn);
    return;
  }
  if (GNUNET_OK != GNUNET_BIO_read (rh, fn, buf, fsize))
  {
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "read", fn);
    GNUNET_break (GNUNET_OK == GNUNET_BIO_read_close (rh, NULL));
    GNUNET_free (buf);
    GNUNET_free (fn);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              _ ("Loading %llu bytes of statistics from `%s'\n"),
              (unsigned long long) fsize,
              fn);
  mst = GNUNET_MST_create (&inject_message, NULL);
  GNUNET_break (
    GNUNET_OK ==
    GNUNET_MST_from_buffer (mst, buf, (size_t) fsize, GNUNET_YES, GNUNET_NO));
  GNUNET_MST_destroy (mst);
  GNUNET_free (buf);
  GNUNET_break (GNUNET_OK == GNUNET_BIO_read_close (rh, NULL));
  GNUNET_free (fn);
}

References _, buf, 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_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

cls	closure
c	configuration to use
service	the initialized service

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

{
  cfg = c;
  nc = GNUNET_notification_context_create (16);
  load ();
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
}

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()

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.

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().