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. More...
static enum GNUNET_GenericReturnValue	prepare_check_patch (struct GNUNET_PQ_Context *db)
	Prepare the "gnunet_pq_check_patch" statement. More...
static enum GNUNET_GenericReturnValue	prepare_get_oid_by_name (struct GNUNET_PQ_Context *db)
	Prepare the "gnunet_pq_get_oid_by_name" statement. More...
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. More...
static void	pq_notice_receiver_cb (void *arg, const PGresult *res)
	Function called by libpq whenever it wants to log something. More...
static void	pq_notice_processor_cb (void *arg, const char *message)
	Function called by libpq whenever it wants to log something. More...
struct GNUNET_PQ_Context *	GNUNET_PQ_connect (const char *config_str, const char *load_path, const struct GNUNET_PQ_ExecuteStatement *es, const struct GNUNET_PQ_PreparedStatement *ps)
	Create a connection to the Postgres database using config_str for the configuration. More...
struct GNUNET_PQ_Context *	GNUNET_PQ_connect2 (const char *config_str, const char *load_path, const char *auto_suffix, const struct GNUNET_PQ_ExecuteStatement *es, const struct GNUNET_PQ_PreparedStatement *ps, enum GNUNET_PQ_Options flags)
	Create a connection to the Postgres database using config_str for the configuration. More...
enum GNUNET_GenericReturnValue	GNUNET_PQ_exec_sql (struct GNUNET_PQ_Context *db, const char *buf)
	Execute SQL statements from buf against db. More...
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". More...
void	GNUNET_PQ_reconnect_if_down (struct GNUNET_PQ_Context *db)
	Reinitialize the database db if the connection is down. More...
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. More...
static enum GNUNET_GenericReturnValue	load_initial_oids (struct GNUNET_PQ_Context *db)
	Load the initial set of OIDs for the supported array-datatypes. More...
void	GNUNET_PQ_reconnect (struct GNUNET_PQ_Context *db)
	Reinitialize the database db. More...
struct GNUNET_PQ_Context *	GNUNET_PQ_connect_with_cfg (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *load_path_suffix, const struct GNUNET_PQ_ExecuteStatement *es, const struct GNUNET_PQ_PreparedStatement *ps)
	Connect to a postgres database using the configuration option "CONFIG" in section. More...
struct GNUNET_PQ_Context *	GNUNET_PQ_connect_with_cfg2 (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *load_path_suffix, const struct GNUNET_PQ_ExecuteStatement *es, const struct GNUNET_PQ_PreparedStatement *ps, enum GNUNET_PQ_Options flags)
	Connect to a postgres database using the configuration option "CONFIG" in section. More...
void	GNUNET_PQ_disconnect (struct GNUNET_PQ_Context *db)
	Disconnect from the database, destroying the prepared statements and releasing other associated resources. More...

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(), and GNUNET_PQ_reconnect().

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 typname = $1"
                   " LIMIT 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_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 139 of file pq_connect.c.

{
  const char *load_path_suffix;
  size_t slen = strlen (load_path) + 10;
  char patch_name[slen];
 
  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 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_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 214 of file pq_connect.c.

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

References find_typedefs::arg, and 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 231 of file pq_connect.c.

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

References find_typedefs::arg, GNUNET_ERROR_TYPE_INFO, and GNUNET_log_from.

Referenced by GNUNET_PQ_reconnect().

Here is the caller graph for this function:

GNUNET_PQ_connect()

struct GNUNET_PQ_Context * GNUNET_PQ_connect	(	const char *	config_str,
		const char *	load_path,
		const struct GNUNET_PQ_ExecuteStatement *	es,
		const struct GNUNET_PQ_PreparedStatement *	ps
	)

Create a connection to the Postgres database using config_str for the configuration.

Initialize logging via GNUnet's log routines and disable Postgres's logger. Also ensures that the statements in load_path and es are executed whenever we (re)connect to the database, and that the prepared statements in ps are "ready". If statements in es fail that were created with GNUNET_PQ_make_execute(), then the entire operation fails.

In load_path, a list of "$XXXX.sql" files is expected where $XXXX must be a sequence of contiguous integer values starting at 0000. These files are then loaded in sequence using "psql $config_str" before running statements from es. The directory is inspected again on reconnect.

Parameters

config_str	configuration to use
load_path	path to directory with SQL transactions to run, can be NULL
es	GNUNET_PQ_PREPARED_STATEMENT_END-terminated array of statements to execute upon EACH connection, can be NULL
ps	array of prepared statements to prepare, can be NULL

Returns

NULL on error

Definition at line 243 of file pq_connect.c.

{
  return GNUNET_PQ_connect2 (config_str,
                             load_path,
                             NULL == load_path
                             ? NULL
                             : "",
                             es,
                             ps,
                             GNUNET_PQ_FLAG_NONE);
}

References GNUNET_PQ_Context::config_str, GNUNET_PQ_Context::es, GNUNET_PQ_connect2(), GNUNET_PQ_FLAG_NONE, GNUNET_PQ_Context::load_path, and ps.

Here is the call graph for this function:

GNUNET_PQ_connect2()

struct GNUNET_PQ_Context * GNUNET_PQ_connect2	(	const char *	config_str,
		const char *	load_path,
		const char *	auto_suffix,
		const struct GNUNET_PQ_ExecuteStatement *	es,
		const struct GNUNET_PQ_PreparedStatement *	ps,
		enum GNUNET_PQ_Options	flags
	)

Create a connection to the Postgres database using config_str for the configuration.

Initialize logging via GNUnet's log routines and disable Postgres's logger. Also ensures that the statements in load_path and es are executed whenever we (re)connect to the database, and that the prepared statements in ps are "ready". If statements in es fail that were created with GNUNET_PQ_make_execute(), then the entire operation fails.

In load_path, a list of "$XXXX.sql" files is expected where $XXXX must be a sequence of contiguous integer values starting at 0000. These files are then loaded in sequence using "psql $config_str" before running statements from es. The directory is inspected again on reconnect.

Parameters

config_str	configuration to use
load_path	path to directory with SQL transactions to run, can be NULL
auto_suffix	infix of SQL series to run on every reconnect; runs multiple (!) files, of the form auto_suffix-XXXX where XXXX is from 0 to 9999 (consecutive).
es	GNUNET_PQ_PREPARED_STATEMENT_END-terminated array of statements to execute upon EACH connection, can be NULL
ps	array of prepared statements to prepare, can be NULL
flags	connection flags

Returns

NULL on error

Definition at line 260 of file pq_connect.c.

{
  struct GNUNET_PQ_Context *db;
  unsigned int elen = 0;
  unsigned int plen = 0;
 
  if (NULL != es)
    while (NULL != es[elen].sql)
      elen++;
  if (NULL != ps)
    while (NULL != ps[plen].name)
      plen++;
 
  db = GNUNET_new (struct GNUNET_PQ_Context);
  db->flags = flags;
  db->config_str = GNUNET_strdup (config_str);
  if (NULL != load_path)
    db->load_path = GNUNET_strdup (load_path);
  if (NULL != auto_suffix)
    db->auto_suffix = GNUNET_strdup (auto_suffix);
  if (0 != elen)
  {
    db->es = GNUNET_new_array (elen + 1,
                               struct GNUNET_PQ_ExecuteStatement);
    memcpy (db->es,
            es,
            elen * sizeof (struct GNUNET_PQ_ExecuteStatement));
  }
  if (0 != plen)
  {
    db->ps = GNUNET_new_array (plen + 1,
                               struct GNUNET_PQ_PreparedStatement);
    memcpy (db->ps,
            ps,
            plen * sizeof (struct GNUNET_PQ_PreparedStatement));
  }
  db->channel_map = GNUNET_CONTAINER_multishortmap_create (16,
                                                           GNUNET_YES);
  GNUNET_PQ_reconnect (db);
  if (NULL == db->conn)
  {
    GNUNET_CONTAINER_multishortmap_destroy (db->channel_map);
    GNUNET_free (db->load_path);
    GNUNET_free (db->auto_suffix);
    GNUNET_free (db->config_str);
    GNUNET_free (db);
    return NULL;
  }
  return db;
}

References GNUNET_PQ_Context::auto_suffix, GNUNET_PQ_Context::config_str, db, GNUNET_PQ_Context::es, GNUNET_PQ_Context::flags, GNUNET_CONTAINER_multishortmap_create(), GNUNET_CONTAINER_multishortmap_destroy(), GNUNET_free, GNUNET_new, GNUNET_new_array, GNUNET_PQ_reconnect(), GNUNET_strdup, GNUNET_YES, GNUNET_PQ_Context::load_path, name, and ps.

Referenced by GNUNET_PQ_connect(), and GNUNET_PQ_connect_with_cfg2().

Here is the call graph for this function:

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

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 318 of file pq_connect.c.

{
  struct GNUNET_OS_Process *psql;
  enum GNUNET_OS_ProcessStatusType type;
  unsigned long code;
  enum GNUNET_GenericReturnValue ret;
  char *fn;
 
  GNUNET_asprintf (&fn,
                   "%s%s.sql",
                   db->load_path,
                   buf);
  if (GNUNET_YES !=
      GNUNET_DISK_file_test_read (fn))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "SQL resource `%s' does not exist\n",
                fn);
    GNUNET_free (fn);
    return GNUNET_NO;
  }
  if (0 != (GNUNET_PQ_FLAG_CHECK_CURRENT & db->flags))
    return GNUNET_SYSERR;
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Applying SQL file `%s' on database %s\n",
              fn,
              db->config_str);
  psql = GNUNET_OS_start_process (GNUNET_OS_INHERIT_STD_NONE,
                                  NULL,
                                  NULL,
                                  NULL,
                                  "psql",
                                  "psql",
                                  db->config_str,
                                  "-f",
                                  fn,
                                  "-q",
                                  "--set",
                                  "ON_ERROR_STOP=1",
                                  NULL);
  if (NULL == psql)
  {
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
                              "exec",
                              "psql");
    GNUNET_free (fn);
    return GNUNET_SYSERR;
  }
  ret = GNUNET_OS_process_wait_status (psql,
                                       &type,
                                       &code);
  if (GNUNET_OK != ret)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "psql on file %s did not finish, killed it!\n",
                fn);
    /* can happen if we got a signal, like CTRL-C, before
       psql was complete */
    (void) GNUNET_OS_process_kill (psql,
                                   SIGKILL);
    GNUNET_OS_process_destroy (psql);
    GNUNET_free (fn);
    return GNUNET_SYSERR;
  }
  GNUNET_OS_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_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_destroy(), GNUNET_OS_PROCESS_EXITED, GNUNET_OS_process_kill(), GNUNET_OS_process_wait_status(), GNUNET_OS_start_process(), GNUNET_PQ_FLAG_CHECK_CURRENT, GNUNET_SYSERR, GNUNET_YES, ret, and type.

Referenced by GNUNET_PQ_reconnect(), 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_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

Definition at line 400 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;
    if ( (GNUNET_SYSERR == ret) &&
         (0 != (GNUNET_PQ_FLAG_CHECK_CURRENT & db->flags)) )
    {
      /* We are only checking, found unapplied patch, bad! */
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Database outdated, patch %s missing. Aborting!\n",
                  patch_name);
    }
    if (GNUNET_SYSERR == ret)
      return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

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

Referenced by GNUNET_PQ_reconnect().

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

db	database connection to reinitialize

Definition at line 449 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 461 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 531 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

Definition at line 562 of file pq_connect.c.

{
  GNUNET_PQ_event_reconnect_ (db,
                              -1);
  reset_connection (db);
  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->load_path) &&
       (NULL != db->auto_suffix) )
  {
    PGresult *res;
    ExecStatusType est;
 
    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);
      reset_connection (db);
      return;
    }
    if (0 == PQntuples (res))
    {
      enum GNUNET_GenericReturnValue ret;
 
      PQclear (res);
      if (0 != (db->flags & GNUNET_PQ_FLAG_DROP))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                    "Versioning schema does not exist yet. Not attempting drop!\n");
        reset_connection (db);
        return;
      }
      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");
        reset_connection (db);
        return;
      }
      if (GNUNET_SYSERR == ret)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                    "Failed to run SQL logic to setup database versioning logic\n");
        reset_connection (db);
        return;
      }
    }
    else
    {
      PQclear (res);
    }
  }
 
  /* 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;
  }
 
  if (NULL != db->auto_suffix)
  {
    GNUNET_assert (NULL != db->load_path);
    if (GNUNET_OK !=
        prepare_check_patch (db))
      return;
 
    if (GNUNET_SYSERR ==
        GNUNET_PQ_run_sql (db,
                           db->auto_suffix))
    {
      if (0 == (GNUNET_PQ_FLAG_CHECK_CURRENT & db->flags))
        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                    "Failed to load SQL statements from `%s*'\n",
                    db->auto_suffix);
      reset_connection (db);
      return;
    }
  }
 
  if ( (NULL != db->es) &&
       (GNUNET_OK !=
        GNUNET_PQ_exec_statements (db,
                                   db->es)) )
  {
    reset_connection (db);
    return;
  }
  if ( (NULL != db->ps) &&
       (GNUNET_OK !=
        GNUNET_PQ_prepare_statements (db,
                                      db->ps)) )
  {
    reset_connection (db);
    return;
  }
  GNUNET_PQ_event_reconnect_ (db,
                              PQsocket (db->conn));
}

References db, GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_log_from, GNUNET_NO, GNUNET_OK, GNUNET_PQ_event_reconnect_(), GNUNET_PQ_exec_sql(), GNUNET_PQ_exec_statements(), GNUNET_PQ_FLAG_CHECK_CURRENT, GNUNET_PQ_FLAG_DROP, GNUNET_PQ_prepare_statements(), GNUNET_PQ_run_sql(), GNUNET_SYSERR, load_initial_oids(), pq_notice_processor_cb(), pq_notice_receiver_cb(), prepare_check_patch(), prepare_get_oid_by_name(), res, reset_connection(), and ret.

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

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_connect_with_cfg()

struct GNUNET_PQ_Context * GNUNET_PQ_connect_with_cfg	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section,
		const char *	load_path_suffix,
		const struct GNUNET_PQ_ExecuteStatement *	es,
		const struct GNUNET_PQ_PreparedStatement *	ps
	)

Connect to a postgres database using the configuration option "CONFIG" in section.

Also ensures that the statements in es are executed whenever we (re)connect to the database, and that the prepared statements in ps are "ready".

The caller does not have to ensure that es and ps remain allocated and initialized in memory until GNUNET_PQ_disconnect() is called, as a copy will be made.

Parameters

cfg	configuration
section	configuration section to use to get Postgres configuration options
load_path_suffix	suffix to append to the SQL_DIR in the configuration
es	GNUNET_PQ_PREPARED_STATEMENT_END-terminated array of statements to execute upon EACH connection, can be NULL
ps	array of prepared statements to prepare, can be NULL

Returns

the postgres handle, NULL on error

Definition at line 700 of file pq_connect.c.

{
  return GNUNET_PQ_connect_with_cfg2 (cfg,
                                      section,
                                      load_path_suffix,
                                      es,
                                      ps,
                                      GNUNET_PQ_FLAG_NONE);
}

References cfg, GNUNET_PQ_Context::es, GNUNET_PQ_connect_with_cfg2(), GNUNET_PQ_FLAG_NONE, and ps.

Referenced by database_connect(), database_setup(), init_connection(), 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:

GNUNET_PQ_connect_with_cfg2()

struct GNUNET_PQ_Context * GNUNET_PQ_connect_with_cfg2	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section,
		const char *	load_path_suffix,
		const struct GNUNET_PQ_ExecuteStatement *	es,
		const struct GNUNET_PQ_PreparedStatement *	ps,
		enum GNUNET_PQ_Options	flags
	)

Connect to a postgres database using the configuration option "CONFIG" in section.

Also ensures that the statements in es are executed whenever we (re)connect to the database, and that the prepared statements in ps are "ready".

The caller does not have to ensure that es and ps remain allocated and initialized in memory until GNUNET_PQ_disconnect() is called, as a copy will be made.

Parameters

cfg	configuration
section	configuration section to use to get Postgres configuration options
load_path_suffix	suffix to append to the SQL_DIR in the configuration
es	GNUNET_PQ_PREPARED_STATEMENT_END-terminated array of statements to execute upon EACH connection, can be NULL
ps	array of prepared statements to prepare, can be NULL
flags	connection flags

Returns

the postgres handle, NULL on error

Definition at line 716 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 = NULL;
  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");
  }
  if ( (NULL != load_path_suffix) &&
       (NULL == load_path) )
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               section,
                               "SQL_DIR");
    return NULL;
  }
  db = GNUNET_PQ_connect2 (conninfo == NULL ? "" : conninfo,
                           load_path,
                           load_path_suffix,
                           es,
                           ps,
                           flags);
  GNUNET_free (load_path);
  GNUNET_free (conninfo);
  return db;
}

References cfg, db, GNUNET_PQ_Context::es, GNUNET_PQ_Context::flags, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log_config_missing(), GNUNET_OK, GNUNET_PQ_connect2(), GNUNET_PQ_Context::load_path, and ps.

Referenced by GNUNET_PQ_connect_with_cfg().

Here is the call graph for this function:

Here is the caller 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 765 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);
  GNUNET_free (db->es);
  GNUNET_free (db->ps);
  GNUNET_free (db->load_path);
  GNUNET_free (db->auto_suffix);
  GNUNET_free (db->config_str);
  GNUNET_free (db->oids.table);
  db->oids.table = NULL;
  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(), and GNUNET_free.

Referenced by 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: