postgres-based datastore backend More...

#include "platform.h"
#include "gnunet_datastore_plugin.h"
#include "gnunet_pq_lib.h"

Include dependency graph for plugin_datastore_postgres.c:

Data Structures
struct	Plugin
	Handle for a plugin. More...

struct	ProcessResultContext
	Closure for process_result. More...

struct	ReplCtx
	Context for #repl_iter() function. More...

struct	ProcessKeysContext
	Closure for process_keys. More...

Macros
#define	BUSY_TIMEOUT GNUNET_TIME_UNIT_SECONDS
	After how many ms "busy" should a DB operation fail for good? A low value makes sure that we are more responsive to requests (especially PUTs).

#define	RESULT_COLUMNS "repl, type, prio, anonLevel, expire, hash, value, oid"

Functions
static void	reconnect_setup (void cls, struct GNUNET_PQ_Context pq)
	Function called whenever we reconnect to the DB.

static enum GNUNET_GenericReturnValue	init_connection (struct Plugin *plugin)
	Get a database handle.

static void	postgres_plugin_estimate_size (void cls, unsigned long long estimate)
	Get an estimate of how much space the database is currently using.

static void	postgres_plugin_put (void cls, const struct GNUNET_HashCode key, bool absent, uint32_t size, const void data, enum GNUNET_BLOCK_Type type, uint32_t priority, uint32_t anonymity, uint32_t replication, struct GNUNET_TIME_Absolute expiration, PluginPutCont cont, void cont_cls)
	Store an item in the datastore.

static void	process_result (void cls, PGresult res, unsigned int num_results)
	Function invoked to process the result and call the processor of cls.

static void	postgres_plugin_get_key (void cls, uint64_t next_uid, bool random, const struct GNUNET_HashCode key, enum GNUNET_BLOCK_Type type, PluginDatumProcessor proc, void *proc_cls)
	Get one of the results for a particular key in the datastore.

static void	postgres_plugin_get_zero_anonymity (void cls, uint64_t next_uid, enum GNUNET_BLOCK_Type type, PluginDatumProcessor proc, void proc_cls)
	Select a subset of the items in the datastore and call the given iterator for each of them.

static int	repl_proc (void cls, const struct GNUNET_HashCode key, uint32_t size, const void *data, enum GNUNET_BLOCK_Type type, uint32_t priority, uint32_t anonymity, uint32_t replication, struct GNUNET_TIME_Absolute expiration, uint64_t uid)
	Wrapper for the iterator for 'sqlite_plugin_replication_get'.

static void	postgres_plugin_get_replication (void cls, PluginDatumProcessor proc, void proc_cls)
	Get a random item for replication.

static void	postgres_plugin_get_expiration (void cls, PluginDatumProcessor proc, void proc_cls)
	Get a random item for expiration.

static void	process_keys (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.

static void	postgres_plugin_get_keys (void cls, PluginKeyProcessor proc, void proc_cls)
	Get all of the keys in the datastore.

static void	postgres_plugin_drop (void *cls)
	Drop database.

static void	postgres_plugin_remove_key (void cls, const struct GNUNET_HashCode key, uint32_t size, const void data, PluginRemoveCont cont, void cont_cls)
	Remove a particular key in the datastore.

void *	libgnunet_plugin_datastore_postgres_init (void *cls)
	Entry point for the plugin.

void *	libgnunet_plugin_datastore_postgres_done (void *cls)
	Exit point from the plugin.

Detailed Description

postgres-based datastore backend

Author: Christian Grothoff

Definition in file plugin_datastore_postgres.c.

Macro Definition Documentation

◆ BUSY_TIMEOUT

#define BUSY_TIMEOUT GNUNET_TIME_UNIT_SECONDS

After how many ms "busy" should a DB operation fail for good? A low value makes sure that we are more responsive to requests (especially PUTs).

A high value guarantees a higher success rate (SELECTs in iterate can take several seconds despite LIMIT=1).

The default value of 1s should ensure that users do not experience huge latencies while at the same time allowing operations to succeed with reasonable probability.

Definition at line 41 of file plugin_datastore_postgres.c.

◆ RESULT_COLUMNS

#define RESULT_COLUMNS "repl, type, prio, anonLevel, expire, hash, value, oid"

Function Documentation

◆ reconnect_setup()

static void reconnect_setup	(	void *	cls,
		struct GNUNET_PQ_Context *	pq
	)

static

Function called whenever we reconnect to the DB.

Sets up the options, possibly the tables and the prepared statements.

Parameters

cls	the `struct Plugin`
pq	database handle

Definition at line 74 of file plugin_datastore_postgres.c.

{
  struct Plugin *plugin = cls;
#define RESULT_COLUMNS "repl, type, prio, anonLevel, expire, hash, value, oid"
  struct GNUNET_PQ_PreparedStatement ps[] = {
    GNUNET_PQ_make_prepare ("get",
                            "SELECT " RESULT_COLUMNS
                            " FROM datastore.gn090"
                            " WHERE oid >= $1::bigint AND"
                            " (rvalue >= $2 OR 0 = $3::smallint) AND"
                            " (hash = $4 OR 0 = $5::smallint) AND"
                            " (type = $6 OR 0 = $7::smallint)"
                            " ORDER BY oid ASC LIMIT 1"),
    GNUNET_PQ_make_prepare ("put",
                            "INSERT INTO datastore.gn090"
                            " (repl, type, prio, anonLevel, expire, rvalue, hash, vhash, value) "
                            "VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)"),
    GNUNET_PQ_make_prepare ("update",
                            "UPDATE datastore.gn090"
                            " SET prio = prio + $1,"
                            " repl = repl + $2,"
                            " expire = GREATEST(expire, $3)"
                            " WHERE hash = $4 AND vhash = $5"),
    GNUNET_PQ_make_prepare ("decrepl",
                            "UPDATE datastore.gn090"
                            " SET repl = GREATEST (repl - 1, 0)"
                            " WHERE oid = $1"),
    GNUNET_PQ_make_prepare ("select_non_anonymous",
                            "SELECT " RESULT_COLUMNS
                            " FROM datastore.gn090"
                            " WHERE anonLevel = 0 AND type = $1 AND oid >= $2::bigint"
                            " ORDER BY oid ASC LIMIT 1"),
    GNUNET_PQ_make_prepare ("select_expiration_order",
                            "(SELECT " RESULT_COLUMNS
                            " FROM datastore.gn090"
                            " WHERE expire < $1 ORDER BY prio ASC LIMIT 1) "
                            "UNION "
                            "(SELECT " RESULT_COLUMNS
                            " FROM datastore.gn090"
                            " ORDER BY prio ASC LIMIT 1)"
                            " ORDER BY expire ASC LIMIT 1"),
    GNUNET_PQ_make_prepare ("select_replication_order",
                            "SELECT " RESULT_COLUMNS
                            " FROM datastore.gn090"
                            " ORDER BY repl DESC,RANDOM() LIMIT 1"),
    GNUNET_PQ_make_prepare ("delrow",
                            "DELETE FROM datastore.gn090"
                            " WHERE oid=$1"),
    GNUNET_PQ_make_prepare ("remove",
                            "DELETE FROM datastore.gn090"
                            " WHERE hash = $1 AND"
                            " value = $2"),
    GNUNET_PQ_make_prepare ("get_keys",
                            "SELECT hash"
                            " FROM datastore.gn090"),
    GNUNET_PQ_make_prepare ("estimate_size",
                            "SELECT CASE WHEN NOT EXISTS"
                            "  (SELECT 1 FROM datastore.gn090)"
                            "  THEN 0"
                            "  ELSE (SELECT SUM(LENGTH(value))+256*COUNT(*)"
                            "        FROM datastore.gn090)"
                            "END AS total"),
    GNUNET_PQ_PREPARED_STATEMENT_END
  };
#undef RESULT_COLUMNS
 
  if (GNUNET_SYSERR ==
      GNUNET_PQ_load_versioning (pq))
  {
    plugin->ready = false;
    return;
  }
  if (GNUNET_OK !=
      GNUNET_PQ_run_sql (pq,
                         "datastore-"))
  {
    plugin->ready = false;
    return;
  }
  if (GNUNET_OK !=
      GNUNET_PQ_prepare_statements (pq,
                                    ps))
  {
    plugin->ready = false;
    return;
  }
  plugin->ready = true;
}

References GNUNET_OK, GNUNET_PQ_load_versioning(), GNUNET_PQ_make_prepare(), GNUNET_PQ_prepare_statements(), GNUNET_PQ_PREPARED_STATEMENT_END, GNUNET_PQ_run_sql(), GNUNET_SYSERR, plugin, ps, and RESULT_COLUMNS.

Referenced by init_connection().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_connection()

static enum GNUNET_GenericReturnValue 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 172 of file plugin_datastore_postgres.c.

{
  plugin->dbh = GNUNET_PQ_init (plugin->env->cfg,
                                "datastore-postgres",
                                &reconnect_setup,
                                plugin);
  if (NULL == plugin->dbh)
    return GNUNET_SYSERR;
  if (! plugin->ready)
    return GNUNET_NO;
  return GNUNET_OK;
}

References GNUNET_NO, GNUNET_OK, GNUNET_PQ_init(), GNUNET_SYSERR, plugin, and reconnect_setup().

Referenced by libgnunet_plugin_datastore_postgres_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ postgres_plugin_estimate_size()

static void postgres_plugin_estimate_size	(	void *	cls,
		unsigned long long *	estimate
	)

static

Get an estimate of how much space the database is currently using.

Parameters

cls	our `struct Plugin *`

Returns: number of bytes used on disk

Definition at line 194 of file plugin_datastore_postgres.c.

{
  struct Plugin *plugin = cls;
  uint64_t total;
  struct GNUNET_PQ_QueryParam params[] = {
    GNUNET_PQ_query_param_end
  };
  struct GNUNET_PQ_ResultSpec rs[] = {
    GNUNET_PQ_result_spec_uint64 ("total",
                                  &total),
    GNUNET_PQ_result_spec_end
  };
  enum GNUNET_DB_QueryStatus ret;
 
  if (NULL == estimate)
    return;
  ret = GNUNET_PQ_eval_prepared_singleton_select (plugin->dbh,
                                                  "estimate_size",
                                                  params,
                                                  rs);
  if (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != ret)
  {
    *estimate = 0LL;
    return;
  }
  *estimate = total;
}

References GNUNET_DB_STATUS_SUCCESS_ONE_RESULT, GNUNET_PQ_eval_prepared_singleton_select(), GNUNET_PQ_query_param_end, GNUNET_PQ_result_spec_end, GNUNET_PQ_result_spec_uint64(), plugin, and ret.

Referenced by libgnunet_plugin_datastore_postgres_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ postgres_plugin_put()

static void postgres_plugin_put	(	void *	cls,
		const struct GNUNET_HashCode *	key,
		bool	absent,
		uint32_t	size,
		const void *	data,
		enum GNUNET_BLOCK_Type	type,
		uint32_t	priority,
		uint32_t	anonymity,
		uint32_t	replication,
		struct GNUNET_TIME_Absolute	expiration,
		PluginPutCont	cont,
		void *	cont_cls
	)

static

Store an item in the datastore.

Parameters

cls	closure with the `struct Plugin`
key	key for the item
absent	true if the key was not found in the bloom filter
size	number of bytes in data
data	content stored
type	type of the content
priority	priority of the content
anonymity	anonymity-level for the content
replication	replication-level for the content
expiration	expiration time for the content
cont	continuation called with success or failure status
cont_cls	continuation closure

Definition at line 241 of file plugin_datastore_postgres.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_HashCode vhash;
  enum GNUNET_DB_QueryStatus ret;
 
  GNUNET_CRYPTO_hash (data,
                      size,
                      &vhash);
  if (! absent)
  {
    struct GNUNET_PQ_QueryParam params[] = {
      GNUNET_PQ_query_param_uint32 (&priority),
      GNUNET_PQ_query_param_uint32 (&replication),
      GNUNET_PQ_query_param_absolute_time (&expiration),
      GNUNET_PQ_query_param_auto_from_type (key),
      GNUNET_PQ_query_param_auto_from_type (&vhash),
      GNUNET_PQ_query_param_end
    };
    ret = GNUNET_PQ_eval_prepared_non_select (plugin->dbh,
                                              "update",
                                              params);
    if (0 > ret)
    {
      cont (cont_cls,
            key,
            size,
            GNUNET_SYSERR,
            _ ("Postgresql exec failure"));
      return;
    }
    if (0 != ret)
    {
      cont (cont_cls,
            key,
            size,
            GNUNET_NO,
            NULL);
      return;
    }
  }
 
  {
    uint32_t utype = (uint32_t) type;
    uint64_t rvalue = GNUNET_CRYPTO_random_u64 (UINT64_MAX);
    struct GNUNET_PQ_QueryParam params[] = {
      GNUNET_PQ_query_param_uint32 (&replication),
      GNUNET_PQ_query_param_uint32 (&utype),
      GNUNET_PQ_query_param_uint32 (&priority),
      GNUNET_PQ_query_param_uint32 (&anonymity),
      GNUNET_PQ_query_param_absolute_time (&expiration),
      GNUNET_PQ_query_param_uint64 (&rvalue),
      GNUNET_PQ_query_param_auto_from_type (key),
      GNUNET_PQ_query_param_auto_from_type (&vhash),
      GNUNET_PQ_query_param_fixed_size (data, size),
      GNUNET_PQ_query_param_end
    };
 
    ret = GNUNET_PQ_eval_prepared_non_select (plugin->dbh,
                                              "put",
                                              params);
    if (0 > ret)
    {
      cont (cont_cls,
            key,
            size,
            GNUNET_SYSERR,
            "Postgresql exec failure");
      return;
    }
  }
  plugin->env->duc (plugin->env->cls,
                    size + GNUNET_DATASTORE_ENTRY_OVERHEAD);
  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
                   "datastore-postgres",
                   "Stored %u bytes in database\n",
                   (unsigned int) size);
  cont (cont_cls,
        key,
        size,
        GNUNET_OK,
        NULL);
}

References _, anonymity, GNUNET_TESTING_PluginFunctions::cls, data, expiration, GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_random_u64(), GNUNET_DATASTORE_ENTRY_OVERHEAD, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log_from, GNUNET_NO, GNUNET_OK, 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(), GNUNET_PQ_query_param_uint64(), GNUNET_SYSERR, key, plugin, replication, ret, size, and type.

Referenced by libgnunet_plugin_datastore_postgres_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_result()

static void process_result	(	void *	cls,
		PGresult *	res,
		unsigned int	num_results
	)

static

Function invoked to process the result and call the processor of cls.

Parameters

cls	our `struct ProcessResultContext`
res	result from exec
num_results	number of results in res

Definition at line 368 of file plugin_datastore_postgres.c.

{
  struct ProcessResultContext *prc = cls;
  struct Plugin *plugin = prc->plugin;
 
  if (0 == num_results)
  {
    /* no result */
    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
                     "datastore-postgres",
                     "Ending iteration (no more results)\n");
    prc->proc (prc->proc_cls, NULL, 0, NULL, 0, 0, 0, 0,
               GNUNET_TIME_UNIT_ZERO_ABS, 0);
    return;
  }
  if (1 != num_results)
  {
    GNUNET_break (0);
    prc->proc (prc->proc_cls, NULL, 0, NULL, 0, 0, 0, 0,
               GNUNET_TIME_UNIT_ZERO_ABS, 0);
    return;
  }
  /* Technically we don't need the loop here, but nicer in case
     we ever relax the condition above. */
  for (unsigned int i = 0; i < num_results; i++)
  {
    int iret;
    uint64_t rowid;
    uint32_t utype;
    uint32_t anonymity;
    uint32_t replication;
    uint32_t priority;
    size_t size;
    void *data;
    struct GNUNET_TIME_Absolute expiration_time;
    struct GNUNET_HashCode key;
    struct GNUNET_PQ_ResultSpec rs[] = {
      GNUNET_PQ_result_spec_uint32 ("repl", &replication),
      GNUNET_PQ_result_spec_uint32 ("type", &utype),
      GNUNET_PQ_result_spec_uint32 ("prio", &priority),
      GNUNET_PQ_result_spec_uint32 ("anonLevel", &anonymity),
      GNUNET_PQ_result_spec_absolute_time ("expire", &expiration_time),
      GNUNET_PQ_result_spec_auto_from_type ("hash", &key),
      GNUNET_PQ_result_spec_variable_size ("value", &data, &size),
      GNUNET_PQ_result_spec_uint64 ("oid", &rowid),
      GNUNET_PQ_result_spec_end
    };
 
    if (GNUNET_OK !=
        GNUNET_PQ_extract_result (res,
                                  rs,
                                  i))
    {
      GNUNET_break (0);
      prc->proc (prc->proc_cls, NULL, 0, NULL, 0, 0, 0, 0,
                 GNUNET_TIME_UNIT_ZERO_ABS, 0);
      return;
    }
 
    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
                     "datastore-postgres",
                     "Found result of size %u bytes and type %u in database\n",
                     (unsigned int) size,
                     (unsigned int) utype);
    iret = prc->proc (prc->proc_cls,
                      &key,
                      size,
                      data,
                      (enum GNUNET_BLOCK_Type) utype,
                      priority,
                      anonymity,
                      replication,
                      expiration_time,
                      rowid);
    if (iret == GNUNET_NO)
    {
      struct GNUNET_PQ_QueryParam param[] = {
        GNUNET_PQ_query_param_uint64 (&rowid),
        GNUNET_PQ_query_param_end
      };
 
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Processor asked for item %u to be removed.\n",
                  (unsigned int) rowid);
      if (0 <
          GNUNET_PQ_eval_prepared_non_select (plugin->dbh,
                                              "delrow",
                                              param))
      {
        GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
                         "datastore-postgres",
                         "Deleting %u bytes from database\n",
                         (unsigned int) size);
        plugin->env->duc (plugin->env->cls,
                          -(size + GNUNET_DATASTORE_ENTRY_OVERHEAD));
        GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
                         "datastore-postgres",
                         "Deleted %u bytes from database\n",
                         (unsigned int) size);
      }
    }
    GNUNET_PQ_cleanup_result (rs);
  }   /* for (i) */
}

References anonymity, GNUNET_TESTING_PluginFunctions::cls, data, GNUNET_break, GNUNET_DATASTORE_ENTRY_OVERHEAD, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_log_from, GNUNET_NO, GNUNET_OK, GNUNET_PQ_cleanup_result(), GNUNET_PQ_eval_prepared_non_select(), GNUNET_PQ_extract_result(), GNUNET_PQ_query_param_end, GNUNET_PQ_query_param_uint64(), 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_uint64(), GNUNET_PQ_result_spec_variable_size(), GNUNET_TIME_UNIT_ZERO_ABS, key, plugin, ProcessResultContext::plugin, ProcessResultContext::proc, ProcessResultContext::proc_cls, replication, res, and size.

Referenced by postgres_plugin_get_expiration(), postgres_plugin_get_key(), postgres_plugin_get_replication(), and postgres_plugin_get_zero_anonymity().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ postgres_plugin_get_key()

static void postgres_plugin_get_key	(	void *	cls,
		uint64_t	next_uid,
		bool	random,
		const struct GNUNET_HashCode *	key,
		enum GNUNET_BLOCK_Type	type,
		PluginDatumProcessor	proc,
		void *	proc_cls
	)

static

Get one of the results for a particular key in the datastore.

Parameters

cls	closure with the `struct Plugin`
next_uid	return the result with lowest uid >= next_uid
random	if true, return a random result instead of using next_uid
key	maybe NULL (to match all entries)
type	entries of which type are relevant? Use 0 for any type.
proc	function to call on the matching value; will be called with NULL if nothing matches
proc_cls	closure for proc

Definition at line 490 of file plugin_datastore_postgres.c.

{
  struct Plugin *plugin = cls;
  uint32_t utype = type;
  uint16_t use_rvalue = random;
  uint16_t use_key = NULL != key;
  uint16_t use_type = GNUNET_BLOCK_TYPE_ANY != type;
  uint64_t rvalue;
  struct ProcessResultContext prc;
  enum GNUNET_DB_QueryStatus res;
 
  if (random)
  {
    rvalue = GNUNET_CRYPTO_random_u64 (UINT64_MAX);
    next_uid = 0;
  }
  else
  {
    rvalue = 0;
  }
 
  {
    struct GNUNET_PQ_QueryParam params[] = {
      GNUNET_PQ_query_param_uint64 (&next_uid),
      GNUNET_PQ_query_param_uint64 (&rvalue),
      GNUNET_PQ_query_param_uint16 (&use_rvalue),
      GNUNET_PQ_query_param_auto_from_type (key),
      GNUNET_PQ_query_param_uint16 (&use_key),
      GNUNET_PQ_query_param_uint32 (&utype),
      GNUNET_PQ_query_param_uint16 (&use_type),
      GNUNET_PQ_query_param_end
    };
    prc.plugin = plugin;
    prc.proc = proc;
    prc.proc_cls = proc_cls;
 
    res = GNUNET_PQ_eval_prepared_multi_select (plugin->dbh,
                                                "get",
                                                params,
                                                &process_result,
                                                &prc);
  }
  if (0 > res)
    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0,
          GNUNET_TIME_UNIT_ZERO_ABS, 0);
}

References GNUNET_BLOCK_TYPE_ANY, GNUNET_CRYPTO_random_u64(), GNUNET_PQ_eval_prepared_multi_select(), GNUNET_PQ_query_param_auto_from_type, GNUNET_PQ_query_param_end, GNUNET_PQ_query_param_uint16(), GNUNET_PQ_query_param_uint32(), GNUNET_PQ_query_param_uint64(), GNUNET_TIME_UNIT_ZERO_ABS, key, plugin, ProcessResultContext::plugin, ProcessResultContext::proc, ProcessResultContext::proc_cls, process_result(), res, and type.

Referenced by libgnunet_plugin_datastore_postgres_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ postgres_plugin_get_zero_anonymity()

static void postgres_plugin_get_zero_anonymity	(	void *	cls,
		uint64_t	next_uid,
		enum GNUNET_BLOCK_Type	type,
		PluginDatumProcessor	proc,
		void *	proc_cls
	)

static

Select a subset of the items in the datastore and call the given iterator for each of them.

Parameters

cls	our `struct Plugin *`
next_uid	return the result with lowest uid >= next_uid
type	entries of which type should be considered? Must not be zero (ANY).
proc	function to call on the matching value; will be called with NULL if no value matches
proc_cls	closure for proc

Definition at line 557 of file plugin_datastore_postgres.c.

{
  struct Plugin *plugin = cls;
  uint32_t utype = type;
  struct GNUNET_PQ_QueryParam params[] = {
    GNUNET_PQ_query_param_uint32 (&utype),
    GNUNET_PQ_query_param_uint64 (&next_uid),
    GNUNET_PQ_query_param_end
  };
  struct ProcessResultContext prc;
  enum GNUNET_DB_QueryStatus res;
 
  prc.plugin = plugin;
  prc.proc = proc;
  prc.proc_cls = proc_cls;
  res = GNUNET_PQ_eval_prepared_multi_select (plugin->dbh,
                                              "select_non_anonymous",
                                              params,
                                              &process_result,
                                              &prc);
  if (0 > res)
    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0,
          GNUNET_TIME_UNIT_ZERO_ABS, 0);
}

References GNUNET_PQ_eval_prepared_multi_select(), GNUNET_PQ_query_param_end, GNUNET_PQ_query_param_uint32(), GNUNET_PQ_query_param_uint64(), GNUNET_TIME_UNIT_ZERO_ABS, plugin, ProcessResultContext::plugin, ProcessResultContext::proc, ProcessResultContext::proc_cls, process_result(), res, and type.

Referenced by libgnunet_plugin_datastore_postgres_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ repl_proc()

static int repl_proc	(	void *	cls,
		const struct GNUNET_HashCode *	key,
		uint32_t	size,
		const void *	data,
		enum GNUNET_BLOCK_Type	type,
		uint32_t	priority,
		uint32_t	anonymity,
		uint32_t	replication,
		struct GNUNET_TIME_Absolute	expiration,
		uint64_t	uid
	)

static

Wrapper for the iterator for 'sqlite_plugin_replication_get'.

Decrements the replication counter and calls the original iterator.

Parameters

cls	closure with the `struct ReplCtx *`
key	key for the content
size	number of bytes in data
data	content stored
type	type of the content
priority	priority of the content
anonymity	anonymity-level for the content
replication	replication-level for the content
expiration	expiration time for the content
uid	unique identifier for the datum; maybe 0 if no unique identifier is available

Returns: GNUNET_SYSERR to abort the iteration, GNUNET_OK to continue (continue on call to "next", of course), GNUNET_NO to delete the item and continue (if supported)

Definition at line 631 of file plugin_datastore_postgres.c.

{
  struct ReplCtx *rc = cls;
  struct Plugin *plugin = rc->plugin;
  int ret;
  struct GNUNET_PQ_QueryParam params[] = {
    GNUNET_PQ_query_param_uint64 (&uid),
    GNUNET_PQ_query_param_end
  };
  enum GNUNET_DB_QueryStatus qret;
 
  ret = rc->proc (rc->proc_cls,
                  key,
                  size,
                  data,
                  type,
                  priority,
                  anonymity,
                  replication,
                  expiration,
                  uid);
  if (NULL == key)
    return ret;
  qret = GNUNET_PQ_eval_prepared_non_select (plugin->dbh,
                                             "decrepl",
                                             params);
  if (0 > qret)
    return GNUNET_SYSERR;
  return ret;
}

References anonymity, data, expiration, GNUNET_PQ_eval_prepared_non_select(), GNUNET_PQ_query_param_end, GNUNET_PQ_query_param_uint64(), GNUNET_SYSERR, key, plugin, ReplCtx::plugin, ReplCtx::proc, ReplCtx::proc_cls, replication, ret, size, and type.

Referenced by postgres_plugin_get_replication().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ postgres_plugin_get_replication()

static void postgres_plugin_get_replication	(	void *	cls,
		PluginDatumProcessor	proc,
		void *	proc_cls
	)

static

Get a random item for replication.

Returns a single, not expired, random item from those with the highest replication counters. The item's replication counter is decremented by one IF it was positive before. Call proc with all values ZERO or NULL if the datastore is empty.

Parameters

cls	closure with the `struct Plugin`
proc	function to call the value (once only).
proc_cls	closure for proc

Definition at line 684 of file plugin_datastore_postgres.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_PQ_QueryParam params[] = {
    GNUNET_PQ_query_param_end
  };
  struct ReplCtx rc;
  struct ProcessResultContext prc;
  enum GNUNET_DB_QueryStatus res;
 
  rc.plugin = plugin;
  rc.proc = proc;
  rc.proc_cls = proc_cls;
  prc.plugin = plugin;
  prc.proc = &repl_proc;
  prc.proc_cls = &rc;
  res = GNUNET_PQ_eval_prepared_multi_select (plugin->dbh,
                                              "select_replication_order",
                                              params,
                                              &process_result,
                                              &prc);
  if (0 > res)
    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0,
          GNUNET_TIME_UNIT_ZERO_ABS, 0);
}

References GNUNET_PQ_eval_prepared_multi_select(), GNUNET_PQ_query_param_end, GNUNET_TIME_UNIT_ZERO_ABS, plugin, ProcessResultContext::plugin, ReplCtx::plugin, ProcessResultContext::proc, ReplCtx::proc, ProcessResultContext::proc_cls, ReplCtx::proc_cls, process_result(), repl_proc(), and res.

Referenced by libgnunet_plugin_datastore_postgres_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ postgres_plugin_get_expiration()

static void postgres_plugin_get_expiration	(	void *	cls,
		PluginDatumProcessor	proc,
		void *	proc_cls
	)

static

Get a random item for expiration.

Call proc with all values ZERO or NULL if the datastore is empty.

Parameters

cls	closure with the `struct Plugin`
proc	function to call the value (once only).
proc_cls	closure for proc

Definition at line 722 of file plugin_datastore_postgres.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_TIME_Absolute now = { 0 };
  struct GNUNET_PQ_QueryParam params[] = {
    GNUNET_PQ_query_param_absolute_time (&now),
    GNUNET_PQ_query_param_end
  };
  struct ProcessResultContext prc;
 
  now = GNUNET_TIME_absolute_get ();
  prc.plugin = plugin;
  prc.proc = proc;
  prc.proc_cls = proc_cls;
  (void) GNUNET_PQ_eval_prepared_multi_select (plugin->dbh,
                                               "select_expiration_order",
                                               params,
                                               &process_result,
                                               &prc);
}

References GNUNET_PQ_eval_prepared_multi_select(), GNUNET_PQ_query_param_absolute_time(), GNUNET_PQ_query_param_end, GNUNET_TIME_absolute_get(), plugin, ProcessResultContext::plugin, ProcessResultContext::proc, ProcessResultContext::proc_cls, and process_result().

Referenced by libgnunet_plugin_datastore_postgres_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_keys()

static void process_keys	(	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.

Parameters

cls	closure with a `struct ProcessKeysContext`
result	the postgres result
num_results	the number of results in result

Definition at line 772 of file plugin_datastore_postgres.c.

{
  struct ProcessKeysContext *pkc = cls;
 
  for (unsigned i = 0; i < num_results; i++)
  {
    struct GNUNET_HashCode key;
    struct GNUNET_PQ_ResultSpec rs[] = {
      GNUNET_PQ_result_spec_auto_from_type ("hash",
                                            &key),
      GNUNET_PQ_result_spec_end
    };
 
    if (GNUNET_OK !=
        GNUNET_PQ_extract_result (result,
                                  rs,
                                  i))
    {
      GNUNET_break (0);
      continue;
    }
    pkc->proc (pkc->proc_cls,
               &key,
               1);
    GNUNET_PQ_cleanup_result (rs);
  }
}

References GNUNET_break, GNUNET_OK, GNUNET_PQ_cleanup_result(), GNUNET_PQ_extract_result(), GNUNET_PQ_result_spec_auto_from_type, GNUNET_PQ_result_spec_end, key, ProcessKeysContext::proc, ProcessKeysContext::proc_cls, and result.

Referenced by postgres_plugin_get_keys().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ postgres_plugin_get_keys()

static void postgres_plugin_get_keys	(	void *	cls,
		PluginKeyProcessor	proc,
		void *	proc_cls
	)

static

Get all of the keys in the datastore.

Parameters

cls	closure with the `struct Plugin *`
proc	function to call on each key
proc_cls	closure for proc

Definition at line 811 of file plugin_datastore_postgres.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_PQ_QueryParam params[] = {
    GNUNET_PQ_query_param_end
  };
  struct ProcessKeysContext pkc;
 
  pkc.proc = proc;
  pkc.proc_cls = proc_cls;
  (void) GNUNET_PQ_eval_prepared_multi_select (plugin->dbh,
                                               "get_keys",
                                               params,
                                               &process_keys,
                                               &pkc);
  proc (proc_cls,
        NULL,
        0);
}

References GNUNET_PQ_eval_prepared_multi_select(), GNUNET_PQ_query_param_end, plugin, ProcessKeysContext::proc, ProcessKeysContext::proc_cls, and process_keys().

Referenced by libgnunet_plugin_datastore_postgres_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ postgres_plugin_drop()

static void postgres_plugin_drop ( void * cls )

static

Drop database.

Parameters

cls	closure with the `struct Plugin *`

Definition at line 840 of file plugin_datastore_postgres.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_PQ_ExecuteStatement es[] = {
    GNUNET_PQ_make_execute ("DROP TABLE gn090"),
    GNUNET_PQ_EXECUTE_STATEMENT_END
  };
 
  if (GNUNET_OK !=
      GNUNET_PQ_exec_statements (plugin->dbh,
                                 es))
    GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING,
                     "postgres",
                     "Failed to drop table from database.\n");
}

References GNUNET_ERROR_TYPE_WARNING, GNUNET_log_from, GNUNET_OK, GNUNET_PQ_exec_statements(), GNUNET_PQ_EXECUTE_STATEMENT_END, GNUNET_PQ_make_execute(), and plugin.

Referenced by libgnunet_plugin_datastore_postgres_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ postgres_plugin_remove_key()

static void postgres_plugin_remove_key	(	void *	cls,
		const struct GNUNET_HashCode *	key,
		uint32_t	size,
		const void *	data,
		PluginRemoveCont	cont,
		void *	cont_cls
	)

static

Remove a particular key in the datastore.

Parameters

cls	closure
key	key for the content
size	number of bytes in data
data	content stored
cont	continuation called with success or failure status
cont_cls	continuation closure for cont

Definition at line 868 of file plugin_datastore_postgres.c.

{
  struct Plugin *plugin = cls;
  enum GNUNET_DB_QueryStatus ret;
  struct GNUNET_PQ_QueryParam params[] = {
    GNUNET_PQ_query_param_auto_from_type (key),
    GNUNET_PQ_query_param_fixed_size (data, size),
    GNUNET_PQ_query_param_end
  };
 
  ret = GNUNET_PQ_eval_prepared_non_select (plugin->dbh,
                                            "remove",
                                            params);
  if (0 > ret)
  {
    cont (cont_cls,
          key,
          size,
          GNUNET_SYSERR,
          _ ("Postgresql exec failure"));
    return;
  }
  if (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS == ret)
  {
    cont (cont_cls,
          key,
          size,
          GNUNET_NO,
          NULL);
    return;
  }
  plugin->env->duc (plugin->env->cls,
                    -(size + GNUNET_DATASTORE_ENTRY_OVERHEAD));
  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
                   "datastore-postgres",
                   "Deleted %u bytes from database\n",
                   (unsigned int) size);
  cont (cont_cls,
        key,
        size,
        GNUNET_OK,
        NULL);
}

References _, GNUNET_TESTING_PluginFunctions::cls, data, GNUNET_DATASTORE_ENTRY_OVERHEAD, GNUNET_DB_STATUS_SUCCESS_NO_RESULTS, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log_from, GNUNET_NO, GNUNET_OK, GNUNET_PQ_eval_prepared_non_select(), GNUNET_PQ_query_param_auto_from_type, GNUNET_PQ_query_param_end, GNUNET_PQ_query_param_fixed_size(), GNUNET_SYSERR, key, plugin, ret, and size.

Referenced by libgnunet_plugin_datastore_postgres_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ libgnunet_plugin_datastore_postgres_init()

void * libgnunet_plugin_datastore_postgres_init ( void * cls )

Entry point for the plugin.

Parameters

cls	the `struct GNUNET_DATASTORE_PluginEnvironment*`

Returns: our struct Plugin *

Definition at line 928 of file plugin_datastore_postgres.c.

{
  struct GNUNET_DATASTORE_PluginEnvironment *env = cls;
  struct GNUNET_DATASTORE_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_DATASTORE_PluginFunctions);
  api->cls = plugin;
  api->estimate_size = &postgres_plugin_estimate_size;
  api->put = &postgres_plugin_put;
  api->get_key = &postgres_plugin_get_key;
  api->get_replication = &postgres_plugin_get_replication;
  api->get_expiration = &postgres_plugin_get_expiration;
  api->get_zero_anonymity = &postgres_plugin_get_zero_anonymity;
  api->get_keys = &postgres_plugin_get_keys;
  api->drop = &postgres_plugin_drop;
  api->remove_key = &postgres_plugin_remove_key;
  return api;
}

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, GNUNET_DATASTORE_PluginEnvironment::cls, env, GNUNET_BLOCK_PluginFunctions::get_key, GNUNET_free, GNUNET_new, GNUNET_OK, init_connection(), plugin, postgres_plugin_drop(), postgres_plugin_estimate_size(), postgres_plugin_get_expiration(), postgres_plugin_get_key(), postgres_plugin_get_keys(), postgres_plugin_get_replication(), postgres_plugin_get_zero_anonymity(), postgres_plugin_put(), and postgres_plugin_remove_key().

Here is the call graph for this function:

◆ libgnunet_plugin_datastore_postgres_done()

void * libgnunet_plugin_datastore_postgres_done ( void * cls )

Exit point from the plugin.

Parameters

cls	our `struct Plugin *`

Returns: always NULL

Definition at line 966 of file plugin_datastore_postgres.c.

{
  struct GNUNET_DATASTORE_PluginFunctions *api = cls;
  struct Plugin *plugin = api->cls;
 
  GNUNET_PQ_disconnect (plugin->dbh);
  GNUNET_free (plugin);
  GNUNET_free (api);
  return NULL;
}

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, GNUNET_DATASTORE_PluginFunctions::cls, GNUNET_free, GNUNET_PQ_disconnect(), and plugin.

Here is the call graph for this function:

Data Structures

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ BUSY_TIMEOUT

◆ RESULT_COLUMNS

Function Documentation

◆ reconnect_setup()

◆ init_connection()

◆ postgres_plugin_estimate_size()

◆ postgres_plugin_put()

◆ process_result()

◆ postgres_plugin_get_key()

◆ postgres_plugin_get_zero_anonymity()

◆ repl_proc()

◆ postgres_plugin_get_replication()

◆ postgres_plugin_get_expiration()

◆ process_keys()

◆ postgres_plugin_get_keys()

◆ postgres_plugin_drop()

◆ postgres_plugin_remove_key()

◆ libgnunet_plugin_datastore_postgres_init()

◆ libgnunet_plugin_datastore_postgres_done()