pq_connect.c File Reference

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

#include "platform.h"
#include "pq.h"

Include dependency graph for pq_connect.c:

Go to the source code of this file.

Functions
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...
int	GNUNET_PQ_run_sql (struct GNUNET_PQ_Context *db, const char *load_path)
	Within the db context, run all the SQL files from the load_path from 0000-9999.sql (as long as the files exist contiguously). More...
void	GNUNET_PQ_reconnect_if_down (struct GNUNET_PQ_Context *db)
	Reinitialize the database db if the connection is down. 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...
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

Definition in file pq_connect.c.

Function Documentation

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

Referenced by GNUNET_PQ_reconnect().

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

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

References GNUNET_ERROR_TYPE_INFO, and GNUNET_log_from.

Referenced by GNUNET_PQ_reconnect().

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

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

References GNUNET_PQ_Context::config_str, GNUNET_PQ_Context::conn, db, GNUNET_PQ_Context::es, GNUNET_free, GNUNET_free_non_null, GNUNET_new, GNUNET_new_array, GNUNET_PQ_reconnect(), GNUNET_strdup, GNUNET_PQ_Context::load_path, name, and GNUNET_PQ_Context::ps.

Referenced by GNUNET_PQ_connect_with_cfg().

{
  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->config_str = GNUNET_strdup (config_str);
  if (NULL != load_path)
    db->load_path = GNUNET_strdup (load_path);
  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));
  }
  GNUNET_PQ_reconnect (db);
  if (NULL == db->conn)
  {
    GNUNET_free_non_null (db->load_path);
    GNUNET_free (db->config_str);
    GNUNET_free (db);
    return NULL;
  }
  return db;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_run_sql()

int GNUNET_PQ_run_sql	(	struct GNUNET_PQ_Context *	db,
		const char *	load_path
	)

Within the db context, run all the SQL files from the load_path from 0000-9999.sql (as long as the files exist contiguously).

Parameters

db	database context to use
load_path	where to find the XXXX.sql files

Returns

GNUNET_OK on success

Definition at line 147 of file pq_connect.c.

References buf, GNUNET_PQ_Context::config_str, GNUNET_assert, GNUNET_DISK_file_test(), GNUNET_ERROR_TYPE_ERROR, 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_wait_status(), GNUNET_OS_start_process(), GNUNET_snprintf(), GNUNET_SYSERR, GNUNET_YES, GNUNET_PQ_Context::load_path, and type.

Referenced by GNUNET_PQ_reconnect().

{
  size_t slen = strlen (db->load_path) + 10;

  for (unsigned int i = 0; i<10000; i++)
  {
    char buf[slen];
    struct GNUNET_OS_Process *psql;
    enum GNUNET_OS_ProcessStatusType type;
    unsigned long code;
    
    GNUNET_snprintf (buf,
                     sizeof (buf),
                     "%s%04u.sql",
                     db->load_path,
                     i);
    if (GNUNET_YES !=
        GNUNET_DISK_file_test (buf))
      break; /* We are done */
    psql = GNUNET_OS_start_process (GNUNET_NO,
                                    GNUNET_OS_INHERIT_STD_NONE,
                                    NULL,
                                    NULL,
                                    NULL,
                                    "psql",
                                    "psql",
                                    db->config_str,
                                    "-f",
                                    buf,
                                    "-q",
                                    NULL);
    if (NULL == psql)
    {
      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
                                "exec",
                                "psql");
      return GNUNET_SYSERR;
    }
    GNUNET_assert (GNUNET_OK ==
                   GNUNET_OS_process_wait_status (psql,
                                                  &type,
                                                  &code));
    GNUNET_OS_process_destroy (psql);
    if ( (GNUNET_OS_PROCESS_EXITED != type) ||
         (0 != code) )
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Could not run PSQL on file %s: %d",
                  buf,
                  (int) code);
      return GNUNET_SYSERR;
    }
  }
  return GNUNET_OK;
}

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

References GNUNET_PQ_Context::conn, and GNUNET_PQ_reconnect().

{
  if (CONNECTION_BAD != PQstatus (db->conn))
    return;
  GNUNET_PQ_reconnect (db);
}

Here is the call 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 225 of file pq_connect.c.

References GNUNET_PQ_Context::config_str, GNUNET_PQ_Context::conn, GNUNET_PQ_Context::es, GNUNET_ERROR_TYPE_ERROR, GNUNET_log_from, GNUNET_OK, GNUNET_PQ_exec_statements(), GNUNET_PQ_prepare_statements(), GNUNET_PQ_run_sql(), GNUNET_PQ_Context::load_path, pq_notice_processor_cb(), pq_notice_receiver_cb(), and GNUNET_PQ_Context::ps.

Referenced by GNUNET_PQ_connect(), GNUNET_PQ_eval_result(), GNUNET_PQ_exec_prepared(), and GNUNET_PQ_reconnect_if_down().

{
  if (NULL != db->conn)
    PQfinish (db->conn);
  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");
    if (NULL != db->conn)
    {
      PQfinish (db->conn);
      db->conn = NULL;
    }
    return;
  }
  PQsetNoticeReceiver (db->conn,
                       &pq_notice_receiver_cb,
                       db);
  PQsetNoticeProcessor (db->conn,
                        &pq_notice_processor_cb,
                        db);
  if ( (NULL != db->load_path) &&
     (GNUNET_OK !=
      GNUNET_PQ_run_sql (db,
                         db->load_path)) )
  { 
    PQfinish (db->conn);
    db->conn = NULL;
    return;
  }
  if ( (NULL != db->es) &&
       (GNUNET_OK !=
        GNUNET_PQ_exec_statements (db,
                                   db->es)) )
  {
    PQfinish (db->conn);
    db->conn = NULL;
    return;
  }
  if ( (NULL != db->ps) &&
       (GNUNET_OK !=
        GNUNET_PQ_prepare_statements (db,
                                      db->ps)) )
  {
    PQfinish (db->conn);
    db->conn = NULL;
    return;
  }
}

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

References db, GNUNET_asprintf(), GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_free_non_null, GNUNET_OK, GNUNET_PQ_connect(), and GNUNET_PQ_Context::load_path.

Referenced by database_setup(), and init_connection().

{
  struct GNUNET_PQ_Context *db;
  char *conninfo;
  char *load_path;
  char *sp;

  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (cfg,
                                             section,
                                             "CONFIG",
                                             &conninfo))
    conninfo = NULL;
  load_path = NULL;
  sp = NULL;
  if (GNUNET_OK ==
      GNUNET_CONFIGURATION_get_value_filename (cfg,
                                               section,
                                               "SQL_DIR",
                                               &sp))
    GNUNET_asprintf (&load_path,
                     "%s%s",
                     sp,
                     load_path_suffix);
  db = GNUNET_PQ_connect (conninfo == NULL ? "" : conninfo,
                          load_path,
                          es,
                          ps);
  GNUNET_free_non_null (load_path);
  GNUNET_free_non_null (sp);
  GNUNET_free_non_null (conninfo);
  return db;
}

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

References GNUNET_PQ_Context::config_str, GNUNET_PQ_Context::conn, GNUNET_PQ_Context::es, GNUNET_free, GNUNET_free_non_null, GNUNET_PQ_Context::load_path, and GNUNET_PQ_Context::ps.

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

{
  GNUNET_free_non_null (db->es);
  GNUNET_free_non_null (db->ps);
  GNUNET_free_non_null (db->load_path);
  GNUNET_free_non_null (db->config_str);
  PQfinish (db->conn);
  GNUNET_free (db);
}

Here is the caller graph for this function: