pq_event.c File Reference

event notifications via Postgres More...

#include "platform.h"
#include "pq.h"
#include <pthread.h>

Include dependency graph for pq_event.c:

Go to the source code of this file.

Data Structures
struct	GNUNET_DB_EventHandler
	Handle for an active LISTENer to the database. More...
struct	NotifyContext
	Closure for do_notify(). More...

Functions
static void	es_to_sh (const struct GNUNET_DB_EventHeaderP *es, struct GNUNET_ShortHashCode *sh)
	Convert es to a short hash.
static char *	sh_to_channel (struct GNUNET_ShortHashCode *sh, char identifier[64])
	Convert sh to a Postgres identifier.
static enum GNUNET_GenericReturnValue	channel_to_sh (const char *identifier, struct GNUNET_ShortHashCode *sh)
	Convert sh to a Postgres identifier.
static char *	es_to_channel (const struct GNUNET_DB_EventHeaderP *es, char identifier[64])
	Convert es to a Postgres identifier.
static enum GNUNET_GenericReturnValue	do_notify (void *cls, const struct GNUNET_ShortHashCode *sh, void *value)
	Function called on every event handler that needs to be triggered.
void	GNUNET_PQ_event_do_poll (struct GNUNET_PQ_Context *db)
	Poll for events right now.
static void	do_scheduler_notify (void *cls)
	The GNUnet scheduler notifies us that we need to trigger the DB event poller.
static void	do_poll (void *cls)
	The GNUnet scheduler notifies us that we need to trigger the DB event poller directly after having posted an event.
void	GNUNET_PQ_event_poll_ (struct GNUNET_PQ_Context *db)
	Schedule polling for notifications that libpq may have queued while executing a synchronous query.
static void	scheduler_fd_cb (void *cls, int fd)
	Function called when the Postgres FD changes and we need to update the scheduler event loop task.
static void	manage_subscribe (struct GNUNET_PQ_Context *db, const char *cmd, struct GNUNET_DB_EventHandler *eh)
	Helper function to trigger an SQL cmd on db.
static enum GNUNET_GenericReturnValue	register_notify (void *cls, const struct GNUNET_ShortHashCode *sh, void *value)
	Re-subscribe to notifications after disconnect.
void	GNUNET_PQ_event_reconnect_ (struct GNUNET_PQ_Context *db, int fd)
	Internal API.
static void	event_timeout (void *cls)
	Function run on timeout for an event.
struct GNUNET_DB_EventHandler *	GNUNET_PQ_event_listen (struct GNUNET_PQ_Context *db, const struct GNUNET_DB_EventHeaderP *es, struct GNUNET_TIME_Relative timeout, GNUNET_DB_EventCallback cb, void *cb_cls)
	Register callback to be invoked on events of type es.
void	GNUNET_PQ_event_listen_cancel (struct GNUNET_DB_EventHandler *eh)
	Stop notifications.
char *	GNUNET_PQ_get_event_notify_channel (const struct GNUNET_DB_EventHeaderP *es)
	Compute the channel that one should notify upon for the given event specification.
void	GNUNET_PQ_event_notify (struct GNUNET_PQ_Context *db, const struct GNUNET_DB_EventHeaderP *es, const void *extra, size_t extra_size)
	Notify all that listen on es of an event.

Detailed Description

event notifications via Postgres

Author

Christian Grothoff

Definition in file pq_event.c.

Function Documentation

es_to_sh()

static void es_to_sh ( const struct GNUNET_DB_EventHeaderP *  es, struct GNUNET_ShortHashCode *  sh  )

static

Convert es to a short hash.

Parameters

	es	spec to hash to an identifier
[out]	sh	short hash to set

Definition at line 69 of file pq_event.c.

{
  struct GNUNET_HashCode h_channel;
 
  GNUNET_CRYPTO_hash (es,
                      ntohs (es->size),
                      &h_channel);
  GNUNET_static_assert (sizeof (*sh) <= sizeof (h_channel));
  memcpy (sh,
          &h_channel,
          sizeof (*sh));
}

References GNUNET_CRYPTO_hash(), GNUNET_static_assert, sh, and GNUNET_DB_EventHeaderP::size.

Referenced by es_to_channel(), and GNUNET_PQ_event_listen().

Here is the call graph for this function:

Here is the caller graph for this function:

sh_to_channel()

static char * sh_to_channel ( struct GNUNET_ShortHashCode *  sh, char  identifier[64]  )

static

Convert sh to a Postgres identifier.

Parameters

	sh	short hash to convert to an identifier
[out]	identifier	by default, Postgres supports NAMEDATALEN=64 character identifiers

Returns

end position of the identifier

Definition at line 93 of file pq_event.c.

{
  char *end;
 
  end = GNUNET_STRINGS_data_to_string (sh,
                                       sizeof (*sh),
                                       identifier,
                                       63);
  GNUNET_assert (NULL != end);
  *end = '\0';
  return end;
}

References end, GNUNET_assert, GNUNET_STRINGS_data_to_string(), and sh.

Referenced by es_to_channel(), and manage_subscribe().

Here is the call graph for this function:

Here is the caller graph for this function:

channel_to_sh()

static enum GNUNET_GenericReturnValue channel_to_sh ( const char *  identifier, struct GNUNET_ShortHashCode *  sh  )

static

Convert sh to a Postgres identifier.

Parameters

	identifier	to convert
[out]	sh	set to short hash

Returns

GNUNET_OK on success

Definition at line 116 of file pq_event.c.

{
  return GNUNET_STRINGS_string_to_data (identifier,
                                        strlen (identifier),
                                        sh,
                                        sizeof (*sh));
}

References GNUNET_STRINGS_string_to_data(), and sh.

Referenced by GNUNET_PQ_event_do_poll().

Here is the call graph for this function:

Here is the caller graph for this function:

es_to_channel()

static char * es_to_channel ( const struct GNUNET_DB_EventHeaderP *  es, char  identifier[64]  )

static

Convert es to a Postgres identifier.

Parameters

	es	spec to hash to an identifier
[out]	identifier	by default, Postgres supports NAMEDATALEN=64 character identifiers

Returns

end position of the identifier

Definition at line 135 of file pq_event.c.

{
  struct GNUNET_ShortHashCode sh;
 
  es_to_sh (es,
            &sh);
  return sh_to_channel (&sh,
                        identifier);
}

References es_to_sh(), sh, and sh_to_channel().

Referenced by GNUNET_PQ_event_notify(), and GNUNET_PQ_get_event_notify_channel().

Here is the call graph for this function:

Here is the caller graph for this function:

do_notify()

static enum GNUNET_GenericReturnValue do_notify ( void *  cls, const struct GNUNET_ShortHashCode *  sh, void *  value  )

static

Function called on every event handler that needs to be triggered.

Parameters

cls	a struct NotifyContext
sh	channel name
value	a struct GNUNET_DB_EventHandler

Returns

GNUNET_OK continue to iterate

Definition at line 174 of file pq_event.c.

{
  struct NotifyContext *ctx = cls;
  struct GNUNET_DB_EventHandler *eh = value;
 
  eh->cb (eh->cb_cls,
          ctx->extra,
          ctx->extra_size);
  return GNUNET_OK;
}

References GNUNET_DB_EventHandler::cb, GNUNET_DB_EventHandler::cb_cls, ctx, GNUNET_OK, and value.

Referenced by GNUNET_PQ_event_do_poll().

Here is the caller graph for this function:

GNUNET_PQ_event_do_poll()

void GNUNET_PQ_event_do_poll

(

struct GNUNET_PQ_Context *

db

)

Poll for events right now.

Useful if we may have triggered an event for ourselves. Not needed when using GNUNET_PQ_event_notify(), but useful when stored procedures may have triggered events. Does nothing if there are no events.

Parameters

[in,out]

db

database to check for events

Definition at line 189 of file pq_event.c.

{
  PGnotify *n;
  unsigned int cnt = 0;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "PG poll job active\n");
  if (1 !=
      PQconsumeInput (db->conn))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to read from Postgres: %s\n",
                PQerrorMessage (db->conn));
    if (CONNECTION_BAD != PQstatus (db->conn))
      return;
    GNUNET_PQ_reconnect_ (db);
    return;
  }
  while (NULL != (n = PQnotifies (db->conn)))
  {
    struct GNUNET_ShortHashCode sh;
    struct NotifyContext ctx = {
      .extra = NULL
    };
 
    cnt++;
    if ('X' != toupper ((int) n->relname[0]))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Ignoring notification for unsupported channel identifier `%s'\n",
                  n->relname);
      PQfreemem (n);
      continue;
    }
    if (GNUNET_OK !=
        channel_to_sh (&n->relname[1],
                       &sh))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Ignoring notification for unsupported channel identifier `%s'\n",
                  n->relname);
      PQfreemem (n);
      continue;
    }
    if ( (NULL != n->extra) &&
         (GNUNET_OK !=
          GNUNET_STRINGS_string_to_data_alloc (n->extra,
                                               strlen (n->extra),
                                               &ctx.extra,
                                               &ctx.extra_size)))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Ignoring notification for unsupported extra data `%s' on channel `%s'\n",
                  n->extra,
                  n->relname);
      PQfreemem (n);
      continue;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Received notification %s with extra data `%.*s'\n",
                n->relname,
                (int) ctx.extra_size,
                (const char *) ctx.extra);
    GNUNET_CONTAINER_multishortmap_get_multiple (db->channel_map,
                                                 &sh,
                                                 &do_notify,
                                                 &ctx);
    GNUNET_free (ctx.extra);
    PQfreemem (n);
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "PG poll job finishes after %u events\n",
              cnt);
}

References channel_to_sh(), ctx, db, do_notify(), GNUNET_CONTAINER_multishortmap_get_multiple(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_OK, GNUNET_PQ_reconnect_(), GNUNET_STRINGS_string_to_data_alloc(), and sh.

Referenced by do_poll(), and do_scheduler_notify().

Here is the call graph for this function:

Here is the caller graph for this function:

do_scheduler_notify()

static void do_scheduler_notify ( void *  cls )

static

The GNUnet scheduler notifies us that we need to trigger the DB event poller.

Parameters

cls	a struct GNUNET_PQ_Context *

Definition at line 272 of file pq_event.c.

{
  struct GNUNET_PQ_Context *db = cls;
 
  db->event_task = NULL;
  if (NULL == db->rfd)
    GNUNET_PQ_reconnect_ (db);
  GNUNET_PQ_event_do_poll (db);
  if (NULL != db->event_task)
  {
    /* GNUNET_PQ_reconnect_() above could have actually
       created another event_task, stop it */
    GNUNET_SCHEDULER_cancel (db->event_task);
    db->event_task = NULL;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Resubscribing\n");
  if (NULL == db->rfd)
  {
    db->resubscribe_backoff
      = GNUNET_TIME_relative_max (db->resubscribe_backoff,
                                  GNUNET_TIME_UNIT_SECONDS);
    db->resubscribe_backoff
      = GNUNET_TIME_STD_BACKOFF (db->resubscribe_backoff);
    db->event_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
                                                   &do_scheduler_notify,
                                                   db);
    return;
  }
  db->resubscribe_backoff = GNUNET_TIME_UNIT_SECONDS;
  db->event_task
    = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                     db->rfd,
                                     &do_scheduler_notify,
                                     db);
}

References db, do_scheduler_notify(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_PQ_event_do_poll(), GNUNET_PQ_reconnect_(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_read_net(), GNUNET_SCHEDULER_cancel(), GNUNET_TIME_relative_max(), GNUNET_TIME_STD_BACKOFF, GNUNET_TIME_UNIT_FOREVER_REL, and GNUNET_TIME_UNIT_SECONDS.

Referenced by do_scheduler_notify(), and scheduler_fd_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

do_poll()

static void do_poll ( void *  cls )

static

The GNUnet scheduler notifies us that we need to trigger the DB event poller directly after having posted an event.

Parameters

cls	a struct GNUNET_PQ_Context *

Definition at line 318 of file pq_event.c.

{
  struct GNUNET_PQ_Context *db = cls;
 
  db->poller_task = NULL;
  GNUNET_PQ_event_do_poll (db);
}

References db, and GNUNET_PQ_event_do_poll().

Referenced by GNUNET_PQ_event_poll_().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_event_poll_()

void GNUNET_PQ_event_poll_

(

struct GNUNET_PQ_Context *

db

)

Schedule polling for notifications that libpq may have queued while executing a synchronous query.

Parameters

db	the DB handle

Definition at line 328 of file pq_event.c.

{
  if ( (NULL == db->conn) ||
       (0 == GNUNET_CONTAINER_multishortmap_size (db->channel_map)) ||
       (NULL != db->poller_task) )
    return;
  db->poller_task = GNUNET_SCHEDULER_add_now (&do_poll,
                                               db);
}

References db, do_poll(), GNUNET_CONTAINER_multishortmap_size(), and GNUNET_SCHEDULER_add_now().

Referenced by GNUNET_PQ_event_notify(), GNUNET_PQ_exec_prepared(), and GNUNET_PQ_exec_statements().

Here is the call graph for this function:

Here is the caller graph for this function:

scheduler_fd_cb()

static void scheduler_fd_cb ( void *  cls, int  fd  )

static

Function called when the Postgres FD changes and we need to update the scheduler event loop task.

Parameters

cls	a struct GNUNET_PQ_Context *
fd	the file descriptor, possibly -1

Definition at line 347 of file pq_event.c.

{
  struct GNUNET_PQ_Context *db = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "New poll FD is %d\n",
              fd);
  if (NULL != db->event_task)
  {
    GNUNET_SCHEDULER_cancel (db->event_task);
    db->event_task = NULL;
  }
  GNUNET_free (db->rfd);
  if (-1 == fd)
    return;
  if (0 == GNUNET_CONTAINER_multishortmap_size (db->channel_map))
    return;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Activating poll job on %d\n",
              fd);
  db->rfd = GNUNET_NETWORK_socket_box_native (fd);
  db->event_task
    = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_ZERO,
                                     db->rfd,
                                     &do_scheduler_notify,
                                     db);
}

References db, do_scheduler_notify(), GNUNET_CONTAINER_multishortmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NETWORK_socket_box_native(), GNUNET_SCHEDULER_add_read_net(), GNUNET_SCHEDULER_cancel(), and GNUNET_TIME_UNIT_ZERO.

Referenced by GNUNET_PQ_event_listen(), and GNUNET_PQ_event_reconnect_().

Here is the call graph for this function:

Here is the caller graph for this function:

manage_subscribe()

static void manage_subscribe ( struct GNUNET_PQ_Context *  db, const char *  cmd, struct GNUNET_DB_EventHandler *  eh  )

static

Helper function to trigger an SQL cmd on db.

Parameters

db	database to send command to
cmd	prefix of the command to send
eh	details about the event

Definition at line 385 of file pq_event.c.

{
  char sql[16 + 64];
  char *end;
  PGresult *result;
 
  if (NULL == db->conn)
    return;
  end = stpcpy (sql,
                cmd);
  end = sh_to_channel (&eh->sh,
                       end);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Executing PQ command `%s'\n",
              sql);
  result = PQexec (db->conn,
                   sql);
  if (PGRES_COMMAND_OK != PQresultStatus (result))
  {
    GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
                     "pq",
                     "Failed to execute `%s': %s/%s/%s/%s/%s",
                     sql,
                     PQresultErrorField (result,
                                         PG_DIAG_MESSAGE_PRIMARY),
                     PQresultErrorField (result,
                                         PG_DIAG_MESSAGE_DETAIL),
                     PQresultErrorMessage (result),
                     PQresStatus (PQresultStatus (result)),
                     PQerrorMessage (db->conn));
  }
  PQclear (result);
}

References db, end, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_log_from, result, GNUNET_DB_EventHandler::sh, and sh_to_channel().

Referenced by GNUNET_PQ_event_listen(), GNUNET_PQ_event_listen_cancel(), and register_notify().

Here is the call graph for this function:

Here is the caller graph for this function:

register_notify()

static enum GNUNET_GenericReturnValue register_notify ( void *  cls, const struct GNUNET_ShortHashCode *  sh, void *  value  )

static

Re-subscribe to notifications after disconnect.

Parameters

cls	the DB context
sh	the short hash of the channel
value	the event handler

Returns

GNUNET_OK to continue to iterate

Definition at line 431 of file pq_event.c.

{
  struct GNUNET_PQ_Context *db = cls;
  struct GNUNET_DB_EventHandler *eh = value;
 
  manage_subscribe (db,
                    "LISTEN X",
                    eh);
  return GNUNET_OK;
}

References db, GNUNET_OK, manage_subscribe(), and value.

Referenced by GNUNET_PQ_event_reconnect_().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_event_reconnect_()

void GNUNET_PQ_event_reconnect_	(	struct GNUNET_PQ_Context *	db,
		int	fd
	)

Internal API.

Reconnect should re-register notifications after a disconnect.

Parameters

db	the DB handle
fd	socket to listen on

Definition at line 446 of file pq_event.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Change in PQ event FD to %d\n",
              fd);
  scheduler_fd_cb (db,
                   fd);
  GNUNET_CONTAINER_multishortmap_iterate (db->channel_map,
                                          &register_notify,
                                          db);
}

References db, GNUNET_CONTAINER_multishortmap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, register_notify(), and scheduler_fd_cb().

Referenced by GNUNET_PQ_reconnect_().

Here is the call graph for this function:

Here is the caller graph for this function:

event_timeout()

static void event_timeout ( void *  cls )

static

Function run on timeout for an event.

Triggers the notification, but does NOT clear the handler.

Parameters

cls	a struct GNUNET_DB_EventHandler *

Definition at line 467 of file pq_event.c.

{
  struct GNUNET_DB_EventHandler *eh = cls;
 
  eh->timeout_task = NULL;
  eh->cb (eh->cb_cls,
          NULL,
          0);
}

References GNUNET_DB_EventHandler::cb, GNUNET_DB_EventHandler::cb_cls, and GNUNET_DB_EventHandler::timeout_task.

Referenced by GNUNET_PQ_event_listen().

Here is the caller graph for this function:

GNUNET_PQ_event_listen()

struct GNUNET_DB_EventHandler * GNUNET_PQ_event_listen	(	struct GNUNET_PQ_Context *	db,
		const struct GNUNET_DB_EventHeaderP *	es,
		struct GNUNET_TIME_Relative	timeout,
		GNUNET_DB_EventCallback	cb,
		void *	cb_cls
	)

Register callback to be invoked on events of type es.

Unlike many other calls, this function is thread-safe and may be called from threads that are different from the one that setup db. However, the cb will always be called from the thread that runs GNUNET_PQ_event_do_poll() or the GNUnet scheduler.

Parameters

db	database context to use
es	specification of the event to listen for
timeout	when to trigger cb based on timeout
cb	function to call when the event happens, possibly multiple times (until GNUNET_PQ_event_listen_cancel() is invoked), including on timeout
cb_cls	closure for cb

Returns

handle useful to cancel the listener

Definition at line 479 of file pq_event.c.

{
  struct GNUNET_DB_EventHandler *eh;
  bool sub;
 
  eh = GNUNET_new (struct GNUNET_DB_EventHandler);
  eh->db = db;
  es_to_sh (es,
            &eh->sh);
  eh->cb = cb;
  eh->cb_cls = cb_cls;
  sub = (NULL ==
         GNUNET_CONTAINER_multishortmap_get (db->channel_map,
                                             &eh->sh));
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multishortmap_put (db->channel_map,
                                                     &eh->sh,
                                                     eh,
                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
  if (NULL == db->event_task)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Starting event scheduler\n");
    scheduler_fd_cb (db,
                     PQsocket (db->conn));
  }
  if (sub)
    manage_subscribe (db,
                      "LISTEN X",
                      eh);
  eh->timeout_task = GNUNET_SCHEDULER_add_delayed (timeout,
                                                   &event_timeout,
                                                   eh);
  return eh;
}

References GNUNET_DB_EventHandler::cb, GNUNET_DB_EventHandler::cb_cls, db, GNUNET_DB_EventHandler::db, es_to_sh(), event_timeout(), GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multishortmap_get(), GNUNET_CONTAINER_multishortmap_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), manage_subscribe(), scheduler_fd_cb(), GNUNET_DB_EventHandler::sh, timeout, and GNUNET_DB_EventHandler::timeout_task.

Here is the call graph for this function:

GNUNET_PQ_event_listen_cancel()

void GNUNET_PQ_event_listen_cancel

(

struct GNUNET_DB_EventHandler *

eh

)

Stop notifications.

Unlike many other calls, this function is thread-safe and may be called from threads that are different from the one that setup db. However, the cb will always be called from the thread that runs GNUNET_PQ_event_do_poll() or the GNUnet scheduler.

Parameters

eh	handle to unregister.

Definition at line 521 of file pq_event.c.

{
  struct GNUNET_PQ_Context *db = eh->db;
 
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multishortmap_remove (db->channel_map,
                                                        &eh->sh,
                                                        eh));
  if (NULL ==
      GNUNET_CONTAINER_multishortmap_get (db->channel_map,
                                          &eh->sh))
    manage_subscribe (db,
                      "UNLISTEN X",
                      eh);
  if (0 == GNUNET_CONTAINER_multishortmap_size (db->channel_map))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Stopping PQ event scheduler job\n");
    GNUNET_free (db->rfd);
    if (NULL != db->event_task)
    {
      GNUNET_SCHEDULER_cancel (db->event_task);
      db->event_task = NULL;
    }
  }
  if (NULL != eh->timeout_task)
  {
    GNUNET_SCHEDULER_cancel (eh->timeout_task);
    eh->timeout_task = NULL;
  }
  GNUNET_free (eh);
}

References db, GNUNET_DB_EventHandler::db, GNUNET_assert, GNUNET_CONTAINER_multishortmap_get(), GNUNET_CONTAINER_multishortmap_remove(), GNUNET_CONTAINER_multishortmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_OK, GNUNET_SCHEDULER_cancel(), manage_subscribe(), GNUNET_DB_EventHandler::sh, and GNUNET_DB_EventHandler::timeout_task.

Here is the call graph for this function:

GNUNET_PQ_get_event_notify_channel()

char * GNUNET_PQ_get_event_notify_channel

(

const struct GNUNET_DB_EventHeaderP *

es

)

Compute the channel that one should notify upon for the given event specification.

Parameters

es	event specification

Returns

channel to notify upon

Definition at line 556 of file pq_event.c.

{
  char sql[16 + 64 + 8];
  char *end;
 
  end = stpcpy (sql,
                "X");
  end = es_to_channel (es,
                       end);
  GNUNET_assert (NULL != end);
  return GNUNET_strdup (sql);
}

References end, es_to_channel(), GNUNET_assert, and GNUNET_strdup.

Here is the call graph for this function:

GNUNET_PQ_event_notify()

void GNUNET_PQ_event_notify	(	struct GNUNET_PQ_Context *	db,
		const struct GNUNET_DB_EventHeaderP *	es,
		const void *	extra,
		size_t	extra_size
	)

Notify all that listen on es of an event.

Unlike many other calls, this function is thread-safe and may be called from threads that are different from the one that setup db. However, the cb will always be called from the thread that runs GNUNET_PQ_event_do_poll() or the GNUnet scheduler.

Parameters

db	database context to use
es	specification of the event to generate
extra	additional event data provided
extra_size	number of bytes in extra

Definition at line 571 of file pq_event.c.

{
  char sql[16 + 64 + extra_size * 8 / 5 + 8];
  char *end;
  PGresult *result;
 
  end = stpcpy (sql,
                "NOTIFY X");
  end = es_to_channel (es,
                       end);
  end = stpcpy (end,
                ", '");
  end = GNUNET_STRINGS_data_to_string (extra,
                                       extra_size,
                                       end,
                                       sizeof (sql) - (end - sql) - 1);
  GNUNET_assert (NULL != end);
  *end = '\0';
  end = stpcpy (end,
                "'");
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Executing command `%s'\n",
              sql);
  result = PQexec (db->conn,
                   sql);
  if (PGRES_COMMAND_OK != PQresultStatus (result))
  {
    GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
                     "pq",
                     "Failed to execute `%s': %s/%s/%s/%s/%s",
                     sql,
                     PQresultErrorField (result,
                                         PG_DIAG_MESSAGE_PRIMARY),
                     PQresultErrorField (result,
                                         PG_DIAG_MESSAGE_DETAIL),
                     PQresultErrorMessage (result),
                     PQresStatus (PQresultStatus (result)),
                     PQerrorMessage (db->conn));
  }
  PQclear (result);
  /* Make sure we do not miss this notification in case it was
     for *us*, we need to trigger polling here.
     Just waiting for the db socket to be readable won't work,
     as postgres only queues notifications we triggered for
     ourselves in an internal data structure. */
  GNUNET_PQ_event_poll_ (db);
}

References db, end, es_to_channel(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_log_from, GNUNET_PQ_event_poll_(), GNUNET_STRINGS_data_to_string(), and result.

Here is the call graph for this function: