plugin_datacache_postgres.c File Reference

postgres for an implementation of a database backend for the datacache More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_pq_lib.h"
#include "gnunet_datacache_plugin.h"

Include dependency graph for plugin_datacache_postgres.c:

Go to the source code of this file.

Data Structures
struct	Plugin
	Handle for a plugin. More...
struct	HandleResultContext
	Closure for handle_results. More...
struct	ExtractResultContext
	Closure for extract_result_cb. More...

Macros
#define	LOG(kind, ...)   GNUNET_log_from(kind, "datacache-postgres", __VA_ARGS__)
#define	OVERHEAD   (sizeof(struct GNUNET_HashCode) + 24)
	Per-entry overhead estimate. More...

Functions
static int	init_connection (struct Plugin *plugin)
	Get a database handle. More...
static ssize_t	postgres_plugin_put (void *cls, const struct GNUNET_HashCode *key, uint32_t prox, size_t data_size, const char *data, enum GNUNET_BLOCK_Type type, struct GNUNET_TIME_Absolute discard_time, unsigned int path_info_len, const struct GNUNET_PeerIdentity *path_info)
	Store an item in the datastore. More...
static void	handle_results (void *cls, PGresult *result, unsigned int num_results)
	Function to be called with the results of a SELECT statement that has returned num_results results. More...
static unsigned int	postgres_plugin_get (void *cls, const struct GNUNET_HashCode *key, enum GNUNET_BLOCK_Type type, GNUNET_DATACACHE_Iterator iter, void *iter_cls)
	Iterate over the results for a particular key in the datastore. More...
static int	postgres_plugin_del (void *cls)
	Delete the entry with the lowest expiration value from the datacache right now. More...
static unsigned int	postgres_plugin_get_random (void *cls, GNUNET_DATACACHE_Iterator iter, void *iter_cls)
	Obtain a random key-value pair from the datacache. More...
static void	extract_result_cb (void *cls, PGresult *result, unsigned int num_results)
	Function to be called with the results of a SELECT statement that has returned num_results results. More...
static unsigned int	postgres_plugin_get_closest (void *cls, const struct GNUNET_HashCode *key, unsigned int num_results, GNUNET_DATACACHE_Iterator iter, void *iter_cls)
	Iterate over the results that are "close" to a particular key in the datacache. More...
void *	libgnunet_plugin_datacache_postgres_init (void *cls)
	Entry point for the plugin. More...
void *	libgnunet_plugin_datacache_postgres_done (void *cls)
	Exit point from the plugin. More...

Detailed Description

postgres for an implementation of a database backend for the datacache

Author

Christian Grothoff

Definition in file plugin_datacache_postgres.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from(kind, "datacache-postgres", __VA_ARGS__)

Definition at line 31 of file plugin_datacache_postgres.c.

Referenced by extract_result_cb(), handle_results(), libgnunet_plugin_datacache_postgres_init(), postgres_plugin_del(), postgres_plugin_get_closest(), and postgres_plugin_get_random().

OVERHEAD

#define OVERHEAD   (sizeof(struct GNUNET_HashCode) + 24)

Per-entry overhead estimate.

Definition at line 36 of file plugin_datacache_postgres.c.

Referenced by postgres_plugin_del(), and postgres_plugin_put().

Function Documentation

init_connection()

static int init_connection ( struct Plugin *  plugin )

static

Get a database handle.

Parameters

plugin

global context

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 66 of file plugin_datacache_postgres.c.

References GNUNET_DATACACHE_PluginEnvironment::cfg, Plugin::dbh, Plugin::env, GNUNET_OK, GNUNET_PQ_connect_with_cfg(), GNUNET_PQ_exec_statements(), GNUNET_PQ_EXECUTE_STATEMENT_END, GNUNET_PQ_make_execute(), GNUNET_PQ_make_prepare(), GNUNET_PQ_make_try_execute(), GNUNET_PQ_prepare_statements(), GNUNET_PQ_PREPARED_STATEMENT_END, and GNUNET_SYSERR.

Referenced by libgnunet_plugin_datacache_postgres_init().

{
  struct GNUNET_PQ_ExecuteStatement es[] = {
    GNUNET_PQ_make_execute("CREATE TEMPORARY TABLE IF NOT EXISTS gn011dc ("
                           "  type INTEGER NOT NULL,"
                           "  prox INTEGER NOT NULL,"
                           "  discard_time BIGINT NOT NULL,"
                           "  key BYTEA NOT NULL,"
                           "  value BYTEA NOT NULL,"
                           "  path BYTEA DEFAULT NULL)"
                           "WITH OIDS"),
    GNUNET_PQ_make_try_execute("CREATE INDEX IF NOT EXISTS idx_key ON gn011dc (key)"),
    GNUNET_PQ_make_try_execute("CREATE INDEX IF NOT EXISTS idx_dt ON gn011dc (discard_time)"),
    GNUNET_PQ_make_execute("ALTER TABLE gn011dc ALTER value SET STORAGE EXTERNAL"),
    GNUNET_PQ_make_execute("ALTER TABLE gn011dc ALTER key SET STORAGE PLAIN"),
    GNUNET_PQ_EXECUTE_STATEMENT_END
  };
  struct GNUNET_PQ_PreparedStatement ps[] = {
    GNUNET_PQ_make_prepare("getkt",
                           "SELECT discard_time,type,value,path FROM gn011dc "
                           "WHERE key=$1 AND type=$2 AND discard_time >= $3",
                           3),
    GNUNET_PQ_make_prepare("getk",
                           "SELECT discard_time,type,value,path FROM gn011dc "
                           "WHERE key=$1 AND discard_time >= $2",
                           2),
    GNUNET_PQ_make_prepare("getex",
                           "SELECT length(value) AS len,oid,key FROM gn011dc"
                           " WHERE discard_time < $1"
                           " ORDER BY discard_time ASC LIMIT 1",
                           1),
    GNUNET_PQ_make_prepare("getm",
                           "SELECT length(value) AS len,oid,key FROM gn011dc"
                           " ORDER BY prox ASC, discard_time ASC LIMIT 1",
                           0),
    GNUNET_PQ_make_prepare("get_random",
                           "SELECT discard_time,type,value,path,key FROM gn011dc"
                           " WHERE discard_time >= $1"
                           " ORDER BY key ASC LIMIT 1 OFFSET $2",
                           2),
    GNUNET_PQ_make_prepare("get_closest",
                           "SELECT discard_time,type,value,path,key FROM gn011dc "
                           "WHERE key>=$1 AND discard_time >= $2 ORDER BY key ASC LIMIT $3",
                           3),
    GNUNET_PQ_make_prepare("delrow",
                           "DELETE FROM gn011dc WHERE oid=$1",
                           1),
    GNUNET_PQ_make_prepare("put",
                           "INSERT INTO gn011dc (type, prox, discard_time, key, value, path) "
                           "VALUES ($1, $2, $3, $4, $5, $6)",
                           6),
    GNUNET_PQ_PREPARED_STATEMENT_END
  };

  plugin->dbh = GNUNET_PQ_connect_with_cfg(plugin->env->cfg,
                                           "datacache-postgres");
  if (NULL == plugin->dbh)
    return GNUNET_SYSERR;
  if (GNUNET_OK !=
      GNUNET_PQ_exec_statements(plugin->dbh,
                                es))
    {
      PQfinish(plugin->dbh);
      plugin->dbh = NULL;
      return GNUNET_SYSERR;
    }

  if (GNUNET_OK !=
      GNUNET_PQ_prepare_statements(plugin->dbh,
                                   ps))
    {
      PQfinish(plugin->dbh);
      plugin->dbh = NULL;
      return GNUNET_SYSERR;
    }
  return GNUNET_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

postgres_plugin_put()

static ssize_t postgres_plugin_put ( void *  cls, const struct GNUNET_HashCode *  key, uint32_t  prox, size_t  data_size, const char *  data, enum GNUNET_BLOCK_Type  type, struct GNUNET_TIME_Absolute  discard_time, unsigned int  path_info_len, const struct GNUNET_PeerIdentity *  path_info  )

static

Store an item in the datastore.

Parameters

cls	closure (our struct Plugin)
key	key to store data under
prox	proximity of key to my PID
data_size	number of bytes in data
data	data to store
type	type of the value
discard_time	when to discard the value in any case
path_info_len	number of entries in path_info
path_info	a path through the network

Returns

0 if duplicate, -1 on error, number of bytes used otherwise

Definition at line 160 of file plugin_datacache_postgres.c.

References Plugin::dbh, GNUNET_PQ_eval_prepared_non_select(), GNUNET_PQ_query_param_absolute_time(), GNUNET_PQ_query_param_auto_from_type, GNUNET_PQ_query_param_end, GNUNET_PQ_query_param_fixed_size(), GNUNET_PQ_query_param_uint32(), Plugin::num_items, OVERHEAD, plugin, and ret.

Referenced by libgnunet_plugin_datacache_postgres_init().

{
  struct Plugin *plugin = cls;
  uint32_t type32 = (uint32_t)type;
  struct GNUNET_PQ_QueryParam params[] = {
    GNUNET_PQ_query_param_uint32(&type32),
    GNUNET_PQ_query_param_uint32(&prox),
    GNUNET_PQ_query_param_absolute_time(&discard_time),
    GNUNET_PQ_query_param_auto_from_type(key),
    GNUNET_PQ_query_param_fixed_size(data, data_size),
    GNUNET_PQ_query_param_fixed_size(path_info,
                                     path_info_len * sizeof(struct GNUNET_PeerIdentity)),
    GNUNET_PQ_query_param_end
  };
  enum GNUNET_DB_QueryStatus ret;

  ret = GNUNET_PQ_eval_prepared_non_select(plugin->dbh,
                                           "put",
                                           params);
  if (0 > ret)
    return -1;
  plugin->num_items++;
  return data_size + OVERHEAD;
}

Here is the call graph for this function:

Here is the caller graph for this function:

handle_results()

static void handle_results ( void *  cls, PGresult *  result, unsigned int  num_results  )

static

Function to be called with the results of a SELECT statement that has returned num_results results.

Parse the result and call the callback given in cls

Parameters

cls	closure of type struct HandleResultContext
result	the postgres result
num_result	the number of results in result

Definition at line 225 of file plugin_datacache_postgres.c.

References data, data_size, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_PQ_cleanup_result(), GNUNET_PQ_extract_result(), GNUNET_PQ_result_spec_absolute_time(), GNUNET_PQ_result_spec_end, GNUNET_PQ_result_spec_uint32(), GNUNET_PQ_result_spec_variable_size(), GNUNET_SYSERR, GNUNET_YES, HandleResultContext::iter, HandleResultContext::iter_cls, HandleResultContext::key, LOG, and type.

Referenced by postgres_plugin_get().

{
  struct HandleResultContext *hrc = cls;

  for (unsigned int i = 0; i < num_results; i++)
    {
      struct GNUNET_TIME_Absolute expiration_time;
      uint32_t type;
      void *data;
      size_t data_size;
      struct GNUNET_PeerIdentity *path;
      size_t path_len;
      struct GNUNET_PQ_ResultSpec rs[] = {
        GNUNET_PQ_result_spec_absolute_time("discard_time",
                                            &expiration_time),
        GNUNET_PQ_result_spec_uint32("type",
                                     &type),
        GNUNET_PQ_result_spec_variable_size("value",
                                            &data,
                                            &data_size),
        GNUNET_PQ_result_spec_variable_size("path",
                                            (void **)&path,
                                            &path_len),
        GNUNET_PQ_result_spec_end
      };

      if (GNUNET_YES !=
          GNUNET_PQ_extract_result(result,
                                   rs,
                                   i))
        {
          GNUNET_break(0);
          return;
        }
      if (0 != (path_len % sizeof(struct GNUNET_PeerIdentity)))
        {
          GNUNET_break(0);
          path_len = 0;
        }
      path_len %= sizeof(struct GNUNET_PeerIdentity);
      LOG(GNUNET_ERROR_TYPE_DEBUG,
          "Found result of size %u bytes and type %u in database\n",
          (unsigned int)data_size,
          (unsigned int)type);
      if ((NULL != hrc->iter) &&
          (GNUNET_SYSERR ==
           hrc->iter(hrc->iter_cls,
                     hrc->key,
                     data_size,
                     data,
                     (enum GNUNET_BLOCK_Type)type,
                     expiration_time,
                     path_len,
                     path)))
        {
          LOG(GNUNET_ERROR_TYPE_DEBUG,
              "Ending iteration (client error)\n");
          GNUNET_PQ_cleanup_result(rs);
          return;
        }
      GNUNET_PQ_cleanup_result(rs);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

postgres_plugin_get()

static unsigned int postgres_plugin_get ( void *  cls, const struct GNUNET_HashCode *  key, enum GNUNET_BLOCK_Type  type, GNUNET_DATACACHE_Iterator  iter, void *  iter_cls  )

static

Iterate over the results for a particular key in the datastore.

Parameters

cls	closure (our struct Plugin)
key	key to look for
type	entries of which type are relevant?
iter	maybe NULL (to just count)
iter_cls	closure for iter

Returns

the number of results found

Definition at line 304 of file plugin_datacache_postgres.c.

References Plugin::dbh, GNUNET_PQ_eval_prepared_multi_select(), GNUNET_PQ_query_param_absolute_time(), GNUNET_PQ_query_param_auto_from_type, GNUNET_PQ_query_param_end, GNUNET_PQ_query_param_uint32(), GNUNET_TIME_absolute_get(), handle_results(), Plugin::iter, HandleResultContext::iter, Plugin::iter_cls, HandleResultContext::iter_cls, Plugin::key, HandleResultContext::key, plugin, and res.

Referenced by libgnunet_plugin_datacache_postgres_init().

{
  struct Plugin *plugin = cls;
  uint32_t type32 = (uint32_t)type;
  struct GNUNET_TIME_Absolute now;
  struct GNUNET_PQ_QueryParam paramk[] = {
    GNUNET_PQ_query_param_auto_from_type(key),
    GNUNET_PQ_query_param_absolute_time(&now),
    GNUNET_PQ_query_param_end
  };
  struct GNUNET_PQ_QueryParam paramkt[] = {
    GNUNET_PQ_query_param_auto_from_type(key),
    GNUNET_PQ_query_param_uint32(&type32),
    GNUNET_PQ_query_param_absolute_time(&now),
    GNUNET_PQ_query_param_end
  };
  enum GNUNET_DB_QueryStatus res;
  struct HandleResultContext hr_ctx;

  now = GNUNET_TIME_absolute_get();
  hr_ctx.iter = iter;
  hr_ctx.iter_cls = iter_cls;
  hr_ctx.key = key;
  res = GNUNET_PQ_eval_prepared_multi_select(plugin->dbh,
                                             (0 == type) ? "getk" : "getkt",
                                             (0 == type) ? paramk : paramkt,
                                             &handle_results,
                                             &hr_ctx);
  if (res < 0)
    return 0;
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

postgres_plugin_del()

static int postgres_plugin_del ( void *  cls )

static

Delete the entry with the lowest expiration value from the datacache right now.

Parameters

cls	closure (our struct Plugin)

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 350 of file plugin_datacache_postgres.c.

References GNUNET_DATACACHE_PluginEnvironment::cls, Plugin::dbh, GNUNET_DATACACHE_PluginEnvironment::delete_notify, Plugin::env, GNUNET_DB_STATUS_SUCCESS_NO_RESULTS, GNUNET_ERROR_TYPE_DEBUG, GNUNET_OK, GNUNET_PQ_cleanup_result(), GNUNET_PQ_eval_prepared_non_select(), GNUNET_PQ_eval_prepared_singleton_select(), GNUNET_PQ_query_param_absolute_time(), GNUNET_PQ_query_param_end, GNUNET_PQ_query_param_uint32(), GNUNET_PQ_result_spec_auto_from_type, GNUNET_PQ_result_spec_end, GNUNET_PQ_result_spec_uint32(), GNUNET_SYSERR, GNUNET_TIME_absolute_get(), LOG, Plugin::num_items, OVERHEAD, plugin, res, and Plugin::size.

Referenced by libgnunet_plugin_datacache_postgres_init().

{
  struct Plugin *plugin = cls;
  struct GNUNET_PQ_QueryParam pempty[] = {
    GNUNET_PQ_query_param_end
  };
  uint32_t size;
  uint32_t oid;
  struct GNUNET_HashCode key;
  struct GNUNET_PQ_ResultSpec rs[] = {
    GNUNET_PQ_result_spec_uint32("len",
                                 &size),
    GNUNET_PQ_result_spec_uint32("oid",
                                 &oid),
    GNUNET_PQ_result_spec_auto_from_type("key",
                                         &key),
    GNUNET_PQ_result_spec_end
  };
  enum GNUNET_DB_QueryStatus res;
  struct GNUNET_PQ_QueryParam dparam[] = {
    GNUNET_PQ_query_param_uint32(&oid),
    GNUNET_PQ_query_param_end
  };
  struct GNUNET_TIME_Absolute now;
  struct GNUNET_PQ_QueryParam xparam[] = {
    GNUNET_PQ_query_param_absolute_time(&now),
    GNUNET_PQ_query_param_end
  };

  now = GNUNET_TIME_absolute_get();
  res = GNUNET_PQ_eval_prepared_singleton_select(plugin->dbh,
                                                 "getex",
                                                 xparam,
                                                 rs);
  if (0 >= res)
    res = GNUNET_PQ_eval_prepared_singleton_select(plugin->dbh,
                                                   "getm",
                                                   pempty,
                                                   rs);
  if (0 > res)
    return GNUNET_SYSERR;
  if (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS == res)
    {
      /* no result */
      LOG(GNUNET_ERROR_TYPE_DEBUG,
          "Ending iteration (no more results)\n");
      return 0;
    }
  res = GNUNET_PQ_eval_prepared_non_select(plugin->dbh,
                                           "delrow",
                                           dparam);
  if (0 > res)
    {
      GNUNET_PQ_cleanup_result(rs);
      return GNUNET_SYSERR;
    }
  plugin->num_items--;
  plugin->env->delete_notify(plugin->env->cls,
                             &key,
                             size + OVERHEAD);
  GNUNET_PQ_cleanup_result(rs);
  return GNUNET_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

postgres_plugin_get_random()

static unsigned int postgres_plugin_get_random ( void *  cls, GNUNET_DATACACHE_Iterator  iter, void *  iter_cls  )

static

Obtain a random key-value pair from the datacache.

Parameters

cls	closure (our struct Plugin)
iter	maybe NULL (to just count)
iter_cls	closure for iter

Returns

the number of results found, zero (datacache empty) or one

Definition at line 424 of file plugin_datacache_postgres.c.

References data, data_size, Plugin::dbh, GNUNET_break, GNUNET_CRYPTO_QUALITY_NONCE, GNUNET_CRYPTO_random_u32(), GNUNET_DB_STATUS_SUCCESS_NO_RESULTS, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_PQ_cleanup_result(), GNUNET_PQ_eval_prepared_singleton_select(), GNUNET_PQ_query_param_absolute_time(), GNUNET_PQ_query_param_end, GNUNET_PQ_query_param_uint32(), GNUNET_PQ_result_spec_absolute_time(), GNUNET_PQ_result_spec_auto_from_type, GNUNET_PQ_result_spec_end, GNUNET_PQ_result_spec_uint32(), GNUNET_PQ_result_spec_variable_size(), GNUNET_TIME_absolute_get(), Plugin::iter, LOG, Plugin::num_items, plugin, res, and type.

Referenced by libgnunet_plugin_datacache_postgres_init().

{
  struct Plugin *plugin = cls;
  uint32_t off;
  struct GNUNET_TIME_Absolute now;
  struct GNUNET_TIME_Absolute expiration_time;
  size_t data_size;
  void *data;
  size_t path_len;
  struct GNUNET_PeerIdentity *path;
  struct GNUNET_HashCode key;
  uint32_t type;
  enum GNUNET_DB_QueryStatus res;
  struct GNUNET_PQ_QueryParam params[] = {
    GNUNET_PQ_query_param_absolute_time(&now),
    GNUNET_PQ_query_param_uint32(&off),
    GNUNET_PQ_query_param_end
  };
  struct GNUNET_PQ_ResultSpec rs[] = {
    GNUNET_PQ_result_spec_absolute_time("discard_time",
                                        &expiration_time),
    GNUNET_PQ_result_spec_uint32("type",
                                 &type),
    GNUNET_PQ_result_spec_variable_size("value",
                                        &data,
                                        &data_size),
    GNUNET_PQ_result_spec_variable_size("path",
                                        (void **)&path,
                                        &path_len),
    GNUNET_PQ_result_spec_auto_from_type("key",
                                         &key),
    GNUNET_PQ_result_spec_end
  };

  if (0 == plugin->num_items)
    return 0;
  if (NULL == iter)
    return 1;
  now = GNUNET_TIME_absolute_get();
  off = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_NONCE,
                                 plugin->num_items);
  res = GNUNET_PQ_eval_prepared_singleton_select(plugin->dbh,
                                                 "get_random",
                                                 params,
                                                 rs);
  if (0 > res)
    {
      GNUNET_break(0);
      return 0;
    }
  if (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS == res)
    {
      GNUNET_break(0);
      return 0;
    }
  if (0 != (path_len % sizeof(struct GNUNET_PeerIdentity)))
    {
      GNUNET_break(0);
      path_len = 0;
    }
  path_len %= sizeof(struct GNUNET_PeerIdentity);
  LOG(GNUNET_ERROR_TYPE_DEBUG,
      "Found random value with key %s of size %u bytes and type %u in database\n",
      GNUNET_h2s(&key),
      (unsigned int)data_size,
      (unsigned int)type);
  (void)iter(iter_cls,
             &key,
             data_size,
             data,
             (enum GNUNET_BLOCK_Type)type,
             expiration_time,
             path_len,
             path);
  GNUNET_PQ_cleanup_result(rs);
  return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

extract_result_cb()

static void extract_result_cb ( void *  cls, PGresult *  result, unsigned int  num_results  )

static

Function to be called with the results of a SELECT statement that has returned num_results results.

Calls the iter from cls for each result.

Parameters

cls	closure with the struct ExtractResultContext
result	the postgres result
num_result	the number of results in result

Definition at line 531 of file plugin_datacache_postgres.c.

References data, data_size, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_PQ_cleanup_result(), GNUNET_PQ_extract_result(), GNUNET_PQ_result_spec_absolute_time(), GNUNET_PQ_result_spec_auto_from_type, GNUNET_PQ_result_spec_end, GNUNET_PQ_result_spec_uint32(), GNUNET_PQ_result_spec_variable_size(), GNUNET_SYSERR, GNUNET_YES, ExtractResultContext::iter, ExtractResultContext::iter_cls, LOG, and type.

Referenced by postgres_plugin_get_closest().

{
  struct ExtractResultContext *erc = cls;

  if (NULL == erc->iter)
    return;
  for (unsigned int i = 0; i < num_results; i++)
    {
      struct GNUNET_TIME_Absolute expiration_time;
      uint32_t type;
      void *data;
      size_t data_size;
      struct GNUNET_PeerIdentity *path;
      size_t path_len;
      struct GNUNET_HashCode key;
      struct GNUNET_PQ_ResultSpec rs[] = {
        GNUNET_PQ_result_spec_absolute_time("",
                                            &expiration_time),
        GNUNET_PQ_result_spec_uint32("type",
                                     &type),
        GNUNET_PQ_result_spec_variable_size("value",
                                            &data,
                                            &data_size),
        GNUNET_PQ_result_spec_variable_size("path",
                                            (void **)&path,
                                            &path_len),
        GNUNET_PQ_result_spec_auto_from_type("key",
                                             &key),
        GNUNET_PQ_result_spec_end
      };

      if (GNUNET_YES !=
          GNUNET_PQ_extract_result(result,
                                   rs,
                                   i))
        {
          GNUNET_break(0);
          return;
        }
      if (0 != (path_len % sizeof(struct GNUNET_PeerIdentity)))
        {
          GNUNET_break(0);
          path_len = 0;
        }
      path_len %= sizeof(struct GNUNET_PeerIdentity);
      LOG(GNUNET_ERROR_TYPE_DEBUG,
          "Found result of size %u bytes and type %u in database\n",
          (unsigned int)data_size,
          (unsigned int)type);
      if (GNUNET_SYSERR ==
          erc->iter(erc->iter_cls,
                    &key,
                    data_size,
                    data,
                    (enum GNUNET_BLOCK_Type)type,
                    expiration_time,
                    path_len,
                    path))
        {
          LOG(GNUNET_ERROR_TYPE_DEBUG,
              "Ending iteration (client error)\n");
          GNUNET_PQ_cleanup_result(rs);
          break;
        }
      GNUNET_PQ_cleanup_result(rs);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

postgres_plugin_get_closest()

static unsigned int postgres_plugin_get_closest ( void *  cls, const struct GNUNET_HashCode *  key, unsigned int  num_results, GNUNET_DATACACHE_Iterator  iter, void *  iter_cls  )

static

Iterate over the results that are "close" to a particular key in the datacache.

"close" is defined as numerically larger than key (when interpreted as a circular address space), with small distance.

Parameters

cls	closure (internal context for the plugin)
key	area of the keyspace to look into
num_results	number of results that should be returned to iter
iter	maybe NULL (to just count)
iter_cls	closure for iter

Returns

the number of results found

Definition at line 616 of file plugin_datacache_postgres.c.

References Plugin::dbh, extract_result_cb(), GNUNET_DB_STATUS_SUCCESS_NO_RESULTS, GNUNET_ERROR_TYPE_DEBUG, GNUNET_PQ_eval_prepared_multi_select(), GNUNET_PQ_query_param_absolute_time(), GNUNET_PQ_query_param_auto_from_type, GNUNET_PQ_query_param_end, GNUNET_PQ_query_param_uint32(), GNUNET_TIME_absolute_get(), Plugin::iter, ExtractResultContext::iter, Plugin::iter_cls, ExtractResultContext::iter_cls, LOG, plugin, and res.

Referenced by libgnunet_plugin_datacache_postgres_init().

{
  struct Plugin *plugin = cls;
  uint32_t num_results32 = (uint32_t)num_results;
  struct GNUNET_TIME_Absolute now;
  struct GNUNET_PQ_QueryParam params[] = {
    GNUNET_PQ_query_param_auto_from_type(key),
    GNUNET_PQ_query_param_absolute_time(&now),
    GNUNET_PQ_query_param_uint32(&num_results32),
    GNUNET_PQ_query_param_end
  };
  enum GNUNET_DB_QueryStatus res;
  struct ExtractResultContext erc;

  erc.iter = iter;
  erc.iter_cls = iter_cls;
  now = GNUNET_TIME_absolute_get();
  res = GNUNET_PQ_eval_prepared_multi_select(plugin->dbh,
                                             "get_closest",
                                             params,
                                             &extract_result_cb,
                                             &erc);
  if (0 > res)
    {
      LOG(GNUNET_ERROR_TYPE_DEBUG,
          "Ending iteration (postgres error)\n");
      return 0;
    }
  if (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS == res)
    {
      /* no result */
      LOG(GNUNET_ERROR_TYPE_DEBUG,
          "Ending iteration (no more results)\n");
      return 0;
    }
  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

libgnunet_plugin_datacache_postgres_init()

void* libgnunet_plugin_datacache_postgres_init

(

void *

cls

)

Entry point for the plugin.

Parameters

cls	closure (the struct GNUNET_DATACACHE_PluginEnvironmnet)

Returns

the plugin's closure (our struct Plugin)

Definition at line 666 of file plugin_datacache_postgres.c.

References Plugin::api, GNUNET_DATACACHE_PluginEnvironment::cls, GNUNET_DATACACHE_PluginFunctions::cls, GNUNET_DATACACHE_PluginFunctions::del, Plugin::env, GNUNET_DATACACHE_PluginFunctions::get, GNUNET_DATACACHE_PluginFunctions::get_closest, GNUNET_DATACACHE_PluginFunctions::get_random, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_new, GNUNET_OK, init_connection(), LOG, plugin, postgres_plugin_del(), postgres_plugin_get(), postgres_plugin_get_closest(), postgres_plugin_get_random(), postgres_plugin_put(), and GNUNET_DATACACHE_PluginFunctions::put.

{
  struct GNUNET_DATACACHE_PluginEnvironment *env = cls;
  struct GNUNET_DATACACHE_PluginFunctions *api;
  struct Plugin *plugin;

  plugin = GNUNET_new(struct Plugin);
  plugin->env = env;

  if (GNUNET_OK != init_connection(plugin))
    {
      GNUNET_free(plugin);
      return NULL;
    }

  api = GNUNET_new(struct GNUNET_DATACACHE_PluginFunctions);
  api->cls = plugin;
  api->get = &postgres_plugin_get;
  api->put = &postgres_plugin_put;
  api->del = &postgres_plugin_del;
  api->get_random = &postgres_plugin_get_random;
  api->get_closest = &postgres_plugin_get_closest;
  LOG(GNUNET_ERROR_TYPE_INFO,
      "Postgres datacache running\n");
  return api;
}

Here is the call graph for this function:

libgnunet_plugin_datacache_postgres_done()

void* libgnunet_plugin_datacache_postgres_done

(

void *

cls

)

Exit point from the plugin.

Parameters

cls	closure (our struct Plugin)

Returns

NULL

Definition at line 701 of file plugin_datacache_postgres.c.

References Plugin::api, GNUNET_DATACACHE_PluginFunctions::cls, Plugin::dbh, GNUNET_free, and plugin.

{
  struct GNUNET_DATACACHE_PluginFunctions *api = cls;
  struct Plugin *plugin = api->cls;

  PQfinish(plugin->dbh);
  GNUNET_free(plugin);
  GNUNET_free(api);
  return NULL;
}