pq_connect.c File Reference

functions to connect to libpq (PostGres) More...

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

Include dependency graph for pq_connect.c:

Go to the source code of this file.

Functions
static void	reset_connection (struct GNUNET_PQ_Context *db)
	Close connection to db and mark it as uninitialized.
static enum GNUNET_GenericReturnValue	prepare_check_patch (struct GNUNET_PQ_Context *db)
	Prepare the "gnunet_pq_check_patch" statement.
static enum GNUNET_GenericReturnValue	prepare_get_oid_by_name (struct GNUNET_PQ_Context *db)
	Prepare the "gnunet_pq_get_oid_by_name" statement.
static enum GNUNET_GenericReturnValue	check_versioning_ok (struct GNUNET_PQ_Context *db)
	Check if the "_v" versioning schema exists (and cache the result in db).
static enum GNUNET_GenericReturnValue	check_patch_applied (struct GNUNET_PQ_Context *db, const char *load_path, unsigned int patch_number)
	Check if the patch with patch_number from the given load_path was already applied on the db.
static void	pq_notice_receiver_cb (void *arg, const PGresult *res)
	Function called by libpq whenever it wants to log something.
static void	pq_notice_processor_cb (void *arg, const char *message)
	Function called by libpq whenever it wants to log something.
enum GNUNET_GenericReturnValue	GNUNET_PQ_exec_sql (struct GNUNET_PQ_Context *db, const char *buf)
	Execute SQL statements from buf against db.
enum GNUNET_GenericReturnValue	GNUNET_PQ_check_current (struct GNUNET_PQ_Context *db, const char *load_suffix)
	Check if the database is current with respect to database migrations using prefix.
enum GNUNET_GenericReturnValue	GNUNET_PQ_run_sql (struct GNUNET_PQ_Context *db, const char *load_suffix)
	Within the db context, run all the SQL files in the load path where the name starts with the load_suffix and ends with consecutive numbers from "[0000-9999].sql".
void	GNUNET_PQ_reconnect_if_down (struct GNUNET_PQ_Context *db)
	Reinitialize the database db if the connection is down.
enum GNUNET_GenericReturnValue	GNUNET_PQ_get_oid_by_name (struct GNUNET_PQ_Context *db, const char *name, Oid *oid)
	Returns the oid for a given datatype by name.
static enum GNUNET_GenericReturnValue	load_initial_oids (struct GNUNET_PQ_Context *db)
	Load the initial set of OIDs for the supported array-datatypes.
void	GNUNET_PQ_reconnect_ (struct GNUNET_PQ_Context *db)
	Reinitialize the database db.
enum GNUNET_GenericReturnValue	GNUNET_PQ_load_versioning (struct GNUNET_PQ_Context *db)
	Setup database versioning.
struct GNUNET_PQ_Context *	GNUNET_PQ_init (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, GNUNET_PQ_ReconnectCallback rc, GNUNET_PQ_RECONNECT_CALLBACK_CLOSURE *rc_cls)
void	GNUNET_PQ_disconnect (struct GNUNET_PQ_Context *db)
	Disconnect from the database, destroying the prepared statements and releasing other associated resources.

Detailed Description

functions to connect to libpq (PostGres)

Author

Christian Grothoff

Özgür Kesim

Definition in file pq_connect.c.

Function Documentation

reset_connection()

static void reset_connection ( struct GNUNET_PQ_Context *  db )

static

Close connection to db and mark it as uninitialized.

Parameters

[in,out]

db

connection to close

Definition at line 37 of file pq_connect.c.

{
  if (NULL == db->conn)
    return;
  PQfinish (db->conn);
  db->conn = NULL;
  db->prepared_check_patch = false;
  db->prepared_get_oid_by_name = false;
}

References db.

Referenced by GNUNET_PQ_reconnect_(), prepare_check_patch(), and prepare_get_oid_by_name().

Here is the caller graph for this function:

prepare_check_patch()

static enum GNUNET_GenericReturnValue prepare_check_patch ( struct GNUNET_PQ_Context *  db )

static

Prepare the "gnunet_pq_check_patch" statement.

Parameters

[in,out]

db

database to prepare statement for

Returns

GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 56 of file pq_connect.c.

{
  PGresult *res;
 
  if (db->prepared_check_patch)
    return GNUNET_OK;
  res = PQprepare (db->conn,
                   "gnunet_pq_check_patch",
                   "SELECT"
                   " applied_by"
                   " FROM _v.patches"
                   " WHERE patch_name = $1"
                   " LIMIT 1",
                   1,
                   NULL);
  if (PGRES_COMMAND_OK !=
      PQresultStatus (res))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to run SQL logic to setup database versioning logic: %s/%s\n",
                PQresultErrorMessage (res),
                PQerrorMessage (db->conn));
    PQclear (res);
    reset_connection (db);
    return GNUNET_SYSERR;
  }
  PQclear (res);
  db->prepared_check_patch = true;
  return GNUNET_OK;
}

References db, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_OK, GNUNET_SYSERR, res, and reset_connection().

Referenced by check_patch_applied().

Here is the call graph for this function:

Here is the caller graph for this function:

prepare_get_oid_by_name()

static enum GNUNET_GenericReturnValue prepare_get_oid_by_name ( struct GNUNET_PQ_Context *  db )

static

Prepare the "gnunet_pq_get_oid_by_name" statement.

Parameters

[in,out]

db

database to prepare statement for

Returns

GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 96 of file pq_connect.c.

{
  PGresult *res;
 
  if (db->prepared_get_oid_by_name)
    return GNUNET_OK;
  res = PQprepare (db->conn,
                   "gnunet_pq_get_oid_by_name",
                   "SELECT typname, oid"
                   "  FROM pg_type"
                   " WHERE oid = to_regtype($1)",
                   1,
                   NULL);
  if (PGRES_COMMAND_OK != PQresultStatus (res))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to run SQL statement prepare OID lookups: %s/%s\n",
                PQresultErrorMessage (res),
                PQerrorMessage (db->conn));
    PQclear (res);
    reset_connection (db);
    return GNUNET_SYSERR;
  }
  PQclear (res);
  db->prepared_get_oid_by_name = true;
  return GNUNET_OK;
}

References db, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_OK, GNUNET_SYSERR, res, and reset_connection().

Referenced by GNUNET_PQ_reconnect_().

Here is the call graph for this function:

Here is the caller graph for this function:

check_versioning_ok()

static enum GNUNET_GenericReturnValue check_versioning_ok ( struct GNUNET_PQ_Context *  db )

static

Check if the "_v" versioning schema exists (and cache the result in db).

Parameters

[in,out]

db

connection to check

Returns

GNUNET_OK if versioning is OK GNUNET_NO if it is not loaded GNUNET_SYSERR if we encountered an error

Definition at line 135 of file pq_connect.c.

{
  PGresult *res;
  ExecStatusType est;
 
  if (GNUNET_OK == db->versioning_ok)
    return GNUNET_OK;
  if (GNUNET_NO == db->versioning_ok)
    return GNUNET_NO;
  res = PQexec (db->conn,
                "SELECT"
                " schema_name"
                " FROM information_schema.schemata"
                " WHERE schema_name='_v';");
  est = PQresultStatus (res);
  if ( (PGRES_COMMAND_OK != est) &&
       (PGRES_TUPLES_OK != est) )
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to run statement to check versioning schema. Bad!\n");
    PQclear (res);
    return GNUNET_SYSERR;
  }
  if (0 == PQntuples (res))
  {
    PQclear (res);
    db->versioning_ok = GNUNET_NO;
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "_v schema not found\n");
    return GNUNET_NO;
  }
  PQclear (res);
  db->versioning_ok = GNUNET_OK;
  return GNUNET_OK;
}

References db, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, and res.

Referenced by check_patch_applied(), and GNUNET_PQ_load_versioning().

Here is the caller graph for this function:

check_patch_applied()

static enum GNUNET_GenericReturnValue check_patch_applied ( struct GNUNET_PQ_Context *  db, const char *  load_path, unsigned int  patch_number  )

static

Check if the patch with patch_number from the given load_path was already applied on the db.

Parameters

[in]	db	database to check
	load_path	file system path to database setup files
	patch_number	number of the patch to check

Returns

GNUNET_OK if patch is applied GNUNET_NO if patch is not applied GNUNET_SYSERR on internal error (DB failure)

Definition at line 184 of file pq_connect.c.

{
  const char *load_path_suffix;
  size_t slen = strlen (load_path) + 10;
  char patch_name[slen];
 
  if (GNUNET_SYSERR ==
      check_versioning_ok (db))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR; /* no versioning, cannot check */
  }
  load_path_suffix = strrchr (load_path,
                              '/');
  if (NULL == load_path_suffix)
    load_path_suffix = load_path;
  else
    load_path_suffix++; /* skip '/' */
  GNUNET_snprintf (patch_name,
                   sizeof (patch_name),
                   "%s%04u",
                   load_path_suffix,
                   patch_number);
  {
    struct GNUNET_PQ_QueryParam params[] = {
      GNUNET_PQ_query_param_string (patch_name),
      GNUNET_PQ_query_param_end
    };
    char *applied_by;
    struct GNUNET_PQ_ResultSpec rs[] = {
      GNUNET_PQ_result_spec_string ("applied_by",
                                    &applied_by),
      GNUNET_PQ_result_spec_end
    };
    enum GNUNET_DB_QueryStatus qs;
 
    if (GNUNET_OK !=
        prepare_check_patch (db))
    {
      GNUNET_break (0);
      return GNUNET_SYSERR;
    }
    qs = GNUNET_PQ_eval_prepared_singleton_select (db,
                                                   "gnunet_pq_check_patch",
                                                   params,
                                                   rs);
    switch (qs)
    {
    case GNUNET_DB_STATUS_SUCCESS_ONE_RESULT:
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Database version %s already applied by %s\n",
                  patch_name,
                  applied_by);
      GNUNET_PQ_cleanup_result (rs);
      return GNUNET_OK;
    case GNUNET_DB_STATUS_SUCCESS_NO_RESULTS:
      return GNUNET_NO;
    case GNUNET_DB_STATUS_SOFT_ERROR:
      GNUNET_break (0);
      return GNUNET_SYSERR;
    case GNUNET_DB_STATUS_HARD_ERROR:
      GNUNET_break (0);
      return GNUNET_SYSERR;
    }
    GNUNET_assert (0);
    return GNUNET_SYSERR;
  }
}

References check_versioning_ok(), db, GNUNET_assert, GNUNET_break, GNUNET_DB_STATUS_HARD_ERROR, GNUNET_DB_STATUS_SOFT_ERROR, GNUNET_DB_STATUS_SUCCESS_NO_RESULTS, GNUNET_DB_STATUS_SUCCESS_ONE_RESULT, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_PQ_cleanup_result(), GNUNET_PQ_eval_prepared_singleton_select(), GNUNET_PQ_query_param_end, GNUNET_PQ_query_param_string(), GNUNET_PQ_result_spec_end, GNUNET_PQ_result_spec_string(), GNUNET_snprintf(), GNUNET_SYSERR, and prepare_check_patch().

Referenced by GNUNET_PQ_check_current(), and GNUNET_PQ_run_sql().

Here is the call graph for this function:

Here is the caller graph for this function:

pq_notice_receiver_cb()

static void pq_notice_receiver_cb ( void *  arg, const PGresult *  res  )

static

Function called by libpq whenever it wants to log something.

We already log whenever we care, so this function does nothing and merely exists to silence the libpq logging.

Parameters

arg	the SQL connection that was used
res	information about some libpq event

Definition at line 265 of file pq_connect.c.

{
  /* do nothing, intentionally */
  (void) arg;
  (void) res;
}

References res.

Referenced by GNUNET_PQ_reconnect_().

Here is the caller graph for this function:

pq_notice_processor_cb()

static void pq_notice_processor_cb ( void *  arg, const char *  message  )

static

Function called by libpq whenever it wants to log something.

We log those using the GNUnet logger.

Parameters

arg	the SQL connection that was used
message	information about some libpq event

Definition at line 282 of file pq_connect.c.

{
  (void) arg;
  GNUNET_log_from (GNUNET_ERROR_TYPE_INFO,
                   "pq",
                   "%s",
                   message);
}

References GNUNET_ERROR_TYPE_INFO, and GNUNET_log_from.

Referenced by GNUNET_PQ_reconnect_().

Here is the caller graph for this function:

GNUNET_PQ_exec_sql()

enum GNUNET_GenericReturnValue GNUNET_PQ_exec_sql	(	struct GNUNET_PQ_Context *	db,
		const char *	buf
	)

Execute SQL statements from buf against db.

The given filename infix in buf is prefixed with the "load_path" and ".sql" is appended to construct the full filename.

Parameters

[in,out]	db	database context to use
	buf	filename infix (!) with the SQL code to run

Returns

GNUNET_OK on success GNUNET_NO if patch buf does not exist GNUNET_SYSERR on error

Definition at line 294 of file pq_connect.c.

{
  struct GNUNET_Process *psql;
  enum GNUNET_OS_ProcessStatusType type;
  unsigned long code;
  char *fn;
 
  GNUNET_asprintf (&fn,
                   "%s%s.sql",
                   db->load_path,
                   buf);
  if (GNUNET_YES !=
      GNUNET_DISK_file_test_read (fn))
  {
    GNUNET_free (fn);
    return GNUNET_NO;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Applying SQL file `%s' on database %s\n",
              fn,
              db->config_str);
  psql = GNUNET_process_create (GNUNET_OS_INHERIT_STD_NONE);
  if (GNUNET_OK !=
      GNUNET_process_run_command_va (psql,
                                     "psql",
                                     "psql",
                                     db->config_str,
                                     "-f",
                                     fn,
                                     "-q",
                                     "--set",
                                     "ON_ERROR_STOP=1",
                                     NULL))
  {
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
                              "exec",
                              "psql");
    GNUNET_process_destroy (psql);
    GNUNET_free (fn);
    return GNUNET_SYSERR;
  }
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_process_wait (psql,
                                      true,
                                      &type,
                                      &code));
  GNUNET_process_destroy (psql);
  if ( (GNUNET_OS_PROCESS_EXITED != type) ||
       (0 != code) )
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Could not run PSQL on file %s: psql exit code was %d\n",
                fn,
                (int) code);
    GNUNET_free (fn);
    return GNUNET_SYSERR;
  }
  GNUNET_free (fn);
  return GNUNET_OK;
}

References db, GNUNET_asprintf(), GNUNET_assert, GNUNET_DISK_file_test_read(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_log_strerror_file, GNUNET_NO, GNUNET_OK, GNUNET_OS_INHERIT_STD_NONE, GNUNET_OS_PROCESS_EXITED, GNUNET_process_create(), GNUNET_process_destroy(), GNUNET_process_run_command_va(), GNUNET_process_wait(), GNUNET_SYSERR, GNUNET_YES, and type.

Referenced by GNUNET_PQ_load_versioning(), GNUNET_PQ_run_sql(), libgnunet_plugin_datacache_postgres_done(), and namestore_postgres_drop_tables().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_check_current()

enum GNUNET_GenericReturnValue GNUNET_PQ_check_current	(	struct GNUNET_PQ_Context *	db,
		const char *	prefix
	)

Check if the database is current with respect to database migrations using prefix.

Parameters

[in,out]	db	database to check versioning for
	prefix	prefix to use to check migrations

Returns

GNUNET_OK on success GNUNET_NO if migrations are pending GNUNET_SYSERR on failure

Definition at line 358 of file pq_connect.c.

{
  char *fn;
 
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Loading SQL resources from `%s'\n",
              load_suffix);
  for (unsigned int i = 1; i<10000; i++)
  {
    enum GNUNET_GenericReturnValue ret;
 
    ret = check_patch_applied (db,
                               load_suffix,
                               i);
    if (GNUNET_SYSERR == ret)
    {
      GNUNET_break (0);
      return GNUNET_SYSERR;
    }
    if (GNUNET_OK  == ret)
      continue; /* patch already applied, skip it */
    /* patch not applied, check if it exists... */
    GNUNET_asprintf (&fn,
                     "%s%s%04u",
                     db->load_path,
                     load_suffix,
                     i);
    ret = GNUNET_DISK_file_test_read (fn);
    GNUNET_free (fn);
    if (GNUNET_YES == ret)
      return GNUNET_NO;
    return GNUNET_OK;
  }
  GNUNET_break (0); /* 10k patches applied!? */
  return GNUNET_OK;
}

References check_patch_applied(), db, GNUNET_asprintf(), GNUNET_break, GNUNET_DISK_file_test_read(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, and ret.

Here is the call graph for this function:

GNUNET_PQ_run_sql()

enum GNUNET_GenericReturnValue GNUNET_PQ_run_sql	(	struct GNUNET_PQ_Context *	db,
		const char *	load_suffix
	)

Within the db context, run all the SQL files in the load path where the name starts with the load_suffix and ends with consecutive numbers from "[0000-9999].sql".

Parameters

db	database context to use
load_suffix	suffix to append to the load path to find the XXXX.sql files, usually "subsystem-".

Returns

GNUNET_OK on success GNUNET_NO if no upgrade was needed GNUNET_SYSERR if the upgrade failed

Definition at line 398 of file pq_connect.c.

{
  size_t slen = strlen (load_suffix) + 10;
  char patch_name[slen];
 
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Loading SQL resources from `%s'\n",
              load_suffix);
  for (unsigned int i = 1; i<10000; i++)
  {
    enum GNUNET_GenericReturnValue ret;
 
    ret = check_patch_applied (db,
                               load_suffix,
                               i);
    if (GNUNET_SYSERR == ret)
    {
      GNUNET_break (0);
      return GNUNET_SYSERR;
    }
    if (GNUNET_OK  == ret)
      continue; /* patch already applied, skip it */
 
    GNUNET_snprintf (patch_name,
                     sizeof (patch_name),
                     "%s%04u",
                     load_suffix,
                     i);
    ret = GNUNET_PQ_exec_sql (db,
                              patch_name);
    if (GNUNET_NO == ret)
      break; /* no such file, we are done */
    if (GNUNET_SYSERR == ret)
      return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References check_patch_applied(), db, GNUNET_break, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_PQ_exec_sql(), GNUNET_snprintf(), GNUNET_SYSERR, and ret.

Referenced by reconnect_cb(), reconnect_setup(), reconnect_setup(), and reconnect_setup().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_reconnect_if_down()

void GNUNET_PQ_reconnect_if_down

(

struct GNUNET_PQ_Context *

db

)

Reinitialize the database db if the connection is down.

Parameters

[in,out]

db

database connection to reinitialize

Definition at line 439 of file pq_connect.c.

{
  if (1 ==
      PQconsumeInput (db->conn))
    return;
  if (CONNECTION_BAD != PQstatus (db->conn))
    return;
  GNUNET_PQ_reconnect_ (db);
}

References db, and GNUNET_PQ_reconnect_().

Here is the call graph for this function:

GNUNET_PQ_get_oid_by_name()

enum GNUNET_GenericReturnValue GNUNET_PQ_get_oid_by_name	(	struct GNUNET_PQ_Context *	db,
		const char *	name,
		Oid *	oid
	)

Returns the oid for a given datatype by name.

Parameters

	db	The db-connection
	name	The name of the datatype
[out]	oid	The OID of the datatype.

Returns

GNUNET_OK when the datatype was found, GNUNET_SYSERR otherwise

Definition at line 451 of file pq_connect.c.

{
  /* Check if the entry is in the cache already */
  for (unsigned int i = 0; i < db->oids.num; i++)
  {
    /* Pointer comparison */
    if (name == db->oids.table[i].name)
    {
      *oid = db->oids.table[i].oid;
      return GNUNET_OK;
    }
  }
 
  /* No entry found in cache, ask database */
  {
    enum GNUNET_DB_QueryStatus qs;
    struct GNUNET_PQ_QueryParam params[] = {
      GNUNET_PQ_query_param_string (name),
      GNUNET_PQ_query_param_end
    };
    struct GNUNET_PQ_ResultSpec spec[] = {
      GNUNET_PQ_result_spec_uint32 ("oid",
                                    oid),
      GNUNET_PQ_result_spec_end
    };
 
    GNUNET_assert (NULL != db);
 
    qs = GNUNET_PQ_eval_prepared_singleton_select (db,
                                                   "gnunet_pq_get_oid_by_name",
                                                   params,
                                                   spec);
    if (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != qs)
      return GNUNET_SYSERR;
  }
 
  /* Add the entry to the cache */
  if (NULL == db->oids.table)
  {
    db->oids.table = GNUNET_new_array (8,
                                       typeof(*db->oids.table));
    db->oids.cap = 8;
    db->oids.num = 0;
  }
 
  if (db->oids.cap <= db->oids.num)
    GNUNET_array_grow (db->oids.table,
                       db->oids.cap,
                       db->oids.cap + 8);
 
  db->oids.table[db->oids.num].name = name;
  db->oids.table[db->oids.num].oid = *oid;
  db->oids.num++;
 
  return GNUNET_OK;
}

References db, GNUNET_array_grow, GNUNET_assert, GNUNET_DB_STATUS_SUCCESS_ONE_RESULT, GNUNET_new_array, GNUNET_OK, GNUNET_PQ_eval_prepared_singleton_select(), GNUNET_PQ_query_param_end, GNUNET_PQ_query_param_string(), GNUNET_PQ_result_spec_end, GNUNET_PQ_result_spec_uint32(), GNUNET_SYSERR, name, and oid.

Referenced by GNUNET_PQ_query_param_array_abs_time(), GNUNET_PQ_query_param_array_bool(), GNUNET_PQ_query_param_array_bytes(), GNUNET_PQ_query_param_array_bytes_same_size(), GNUNET_PQ_query_param_array_ptrs_abs_time(), GNUNET_PQ_query_param_array_ptrs_bytes(), GNUNET_PQ_query_param_array_ptrs_bytes_same_size(), GNUNET_PQ_query_param_array_ptrs_rel_time(), GNUNET_PQ_query_param_array_ptrs_string(), GNUNET_PQ_query_param_array_ptrs_timestamp(), GNUNET_PQ_query_param_array_rel_time(), GNUNET_PQ_query_param_array_string(), GNUNET_PQ_query_param_array_timestamp(), GNUNET_PQ_query_param_array_uint16(), GNUNET_PQ_query_param_array_uint32(), GNUNET_PQ_query_param_array_uint64(), GNUNET_PQ_result_spec_array_abs_time(), GNUNET_PQ_result_spec_array_bool(), GNUNET_PQ_result_spec_array_fixed_size(), GNUNET_PQ_result_spec_array_rel_time(), GNUNET_PQ_result_spec_array_string(), GNUNET_PQ_result_spec_array_timestamp(), GNUNET_PQ_result_spec_array_uint16(), GNUNET_PQ_result_spec_array_uint32(), GNUNET_PQ_result_spec_array_uint64(), GNUNET_PQ_result_spec_array_variable_size(), and load_initial_oids().

Here is the call graph for this function:

Here is the caller graph for this function:

load_initial_oids()

static enum GNUNET_GenericReturnValue load_initial_oids ( struct GNUNET_PQ_Context *  db )

static

Load the initial set of OIDs for the supported array-datatypes.

Parameters

db	The database context

Returns

GNUNET_OK on success, GNUNET_SYSERR if any of the types couldn't be found

Definition at line 521 of file pq_connect.c.

{
  static const char *typnames[] = {
    "bool",
    "int2",
    "int4",
    "int8",
    "bytea",
    "varchar"
  };
  Oid oid;
 
  for (size_t i = 0; i< sizeof(typnames) / sizeof(*typnames); i++)
  {
    if (GNUNET_OK !=
        GNUNET_PQ_get_oid_by_name (db,
                                   typnames[i],
                                   &oid))
    {
      GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
                       "pq",
                       "Couldn't retrieve OID for type %s\n",
                       typnames[i]);
      return GNUNET_SYSERR;
    }
  }
  return GNUNET_OK;
}

References db, GNUNET_ERROR_TYPE_ERROR, GNUNET_log_from, GNUNET_OK, GNUNET_PQ_get_oid_by_name(), GNUNET_SYSERR, and oid.

Referenced by GNUNET_PQ_reconnect_().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_reconnect_()

void GNUNET_PQ_reconnect_

(

struct GNUNET_PQ_Context *

db

)

Reinitialize the database db.

Parameters

db	database connection to reinitialize

Deprecated:

Definition at line 552 of file pq_connect.c.

{
  GNUNET_PQ_event_reconnect_ (db,
                              -1);
  reset_connection (db);
  db->versioning_ok = GNUNET_SYSERR; /* new connection, new game */
  db->conn = PQconnectdb (db->config_str);
  if ( (NULL == db->conn) ||
       (CONNECTION_OK != PQstatus (db->conn)) )
  {
    GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
                     "pq",
                     "Database connection to '%s' failed: %s\n",
                     db->config_str,
                     (NULL != db->conn)
                     ? PQerrorMessage (db->conn)
                     : "PQconnectdb returned NULL");
    reset_connection (db);
    return;
  }
  PQsetNoticeReceiver (db->conn,
                       &pq_notice_receiver_cb,
                       db);
  PQsetNoticeProcessor (db->conn,
                        &pq_notice_processor_cb,
                        db);
  if (NULL != db->rc)
    db->rc (db->rc_cls,
            db);
 
  /* Prepare statement for OID lookup by name */
  if (GNUNET_OK !=
      prepare_get_oid_by_name (db))
    return;
 
  /* Reset the OID-cache and retrieve the OIDs for the supported Array types */
  db->oids.num = 0;
  if (GNUNET_SYSERR == load_initial_oids (db))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to retrieve OID information for array types!\n");
    reset_connection (db);
    return;
  }
  GNUNET_PQ_event_reconnect_ (db,
                              PQsocket (db->conn));
}

References db, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_log_from, GNUNET_OK, GNUNET_PQ_event_reconnect_(), GNUNET_SYSERR, load_initial_oids(), pq_notice_processor_cb(), pq_notice_receiver_cb(), prepare_get_oid_by_name(), and reset_connection().

Referenced by do_scheduler_notify(), GNUNET_PQ_eval_result(), GNUNET_PQ_event_do_poll(), GNUNET_PQ_exec_prepared(), GNUNET_PQ_init(), and GNUNET_PQ_reconnect_if_down().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_load_versioning()

enum GNUNET_GenericReturnValue GNUNET_PQ_load_versioning

(

struct GNUNET_PQ_Context *

db

)

Setup database versioning.

Parameters

[in,out]

db

database to load versioning for

Returns

GNUNET_OK on success GNUNET_NO if it was already loaded GNUNET_SYSERR on failure

Definition at line 602 of file pq_connect.c.

{
  enum GNUNET_GenericReturnValue ret;
 
  ret = check_versioning_ok (db);
  if (GNUNET_SYSERR == ret)
    return GNUNET_SYSERR;
  if (GNUNET_YES == ret)
    return GNUNET_NO; /* already setup */
  ret = GNUNET_PQ_exec_sql (db,
                            "versioning");
  if (GNUNET_NO == ret)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to find SQL file to load database versioning logic\n");
    return GNUNET_SYSERR;
  }
  if (GNUNET_SYSERR == ret)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to run SQL logic to setup database versioning logic\n");
    return GNUNET_SYSERR;
  }
  db->versioning_ok = GNUNET_YES;
  return GNUNET_OK;
}

References check_versioning_ok(), db, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_PQ_exec_sql(), GNUNET_SYSERR, GNUNET_YES, and ret.

Referenced by reconnect_setup(), and reconnect_setup().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_init()

struct GNUNET_PQ_Context * GNUNET_PQ_init	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section,
		GNUNET_PQ_ReconnectCallback	rc,
		GNUNET_PQ_RECONNECT_CALLBACK_CLOSURE *	rc_cls
	)

Definition at line 631 of file pq_connect.c.

{
  struct GNUNET_PQ_Context *db;
  char *conninfo;
  char *load_path;
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (cfg,
                                             section,
                                             "CONFIG",
                                             &conninfo))
    conninfo = GNUNET_strdup ("");
  load_path = NULL;
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (cfg,
                                               section,
                                               "SQL_DIR",
                                               &load_path))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_INFO,
                               section,
                               "SQL_DIR");
  }
  db = GNUNET_new (struct GNUNET_PQ_Context);
  db->versioning_ok = GNUNET_SYSERR;
  db->config_str = conninfo;
  db->load_path = load_path;
  db->rc = rc;
  db->rc_cls = rc_cls;
  db->channel_map = GNUNET_CONTAINER_multishortmap_create (16,
                                                           true);
  GNUNET_PQ_reconnect_ (db);
  if (NULL == db->conn)
  {
    GNUNET_CONTAINER_multishortmap_destroy (db->channel_map);
    GNUNET_free (db->config_str);
    GNUNET_free (db);
    return NULL;
  }
  return db;
}

References cfg, db, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONTAINER_multishortmap_create(), GNUNET_CONTAINER_multishortmap_destroy(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log_config_missing(), GNUNET_new, GNUNET_OK, GNUNET_PQ_reconnect_(), GNUNET_strdup, GNUNET_SYSERR, GNUNET_PQ_Context::load_path, GNUNET_PQ_Context::rc, and GNUNET_PQ_Context::rc_cls.

Here is the call graph for this function:

GNUNET_PQ_disconnect()

void GNUNET_PQ_disconnect

(

struct GNUNET_PQ_Context *

db

)

Disconnect from the database, destroying the prepared statements and releasing other associated resources.

Parameters

db	database handle to disconnect (will be free'd)

Definition at line 678 of file pq_connect.c.

{
  if (NULL == db)
    return;
  GNUNET_assert (0 ==
                 GNUNET_CONTAINER_multishortmap_size (db->channel_map));
  GNUNET_CONTAINER_multishortmap_destroy (db->channel_map);
  if (NULL != db->poller_task)
  {
    GNUNET_SCHEDULER_cancel (db->poller_task);
    db->poller_task = NULL;
  }
  GNUNET_free (db->load_path);
  GNUNET_free (db->config_str);
  GNUNET_free (db->oids.table);
  db->oids.num = 0;
  db->oids.cap = 0;
  PQfinish (db->conn);
  GNUNET_free (db);
}

References db, GNUNET_assert, GNUNET_CONTAINER_multishortmap_destroy(), GNUNET_CONTAINER_multishortmap_size(), GNUNET_free, and GNUNET_SCHEDULER_cancel().

Referenced by database_shutdown(), database_shutdown(), libgnunet_plugin_datacache_postgres_done(), libgnunet_plugin_datastore_postgres_done(), namestore_postgres_create_tables(), and namestore_postgres_drop_tables().

Here is the call graph for this function:

Here is the caller graph for this function: