GNUnet  0.11.x
Functions
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_ContextGNUNET_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...
 
static int apply_patch (struct GNUNET_PQ_Context *db, const char *load_path, unsigned int i)
 Apply patch number from path load_path. 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_ContextGNUNET_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
argthe SQL connection that was used
resinformation about some libpq event

Definition at line 38 of file pq_connect.c.

Referenced by GNUNET_PQ_reconnect().

40 {
41  /* do nothing, intentionally */
42  (void) arg;
43  (void) res;
44 }
static int 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
argthe SQL connection that was used
messageinformation 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().

57 {
58  (void) arg;
60  "pq",
61  "%s",
62  message);
63 }
#define GNUNET_log_from(kind, comp,...)
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_strconfiguration to use
load_pathpath to directory with SQL transactions to run, can be NULL
esGNUNET_PQ_PREPARED_STATEMENT_END-terminated array of statements to execute upon EACH connection, can be NULL
psarray 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().

93 {
94  struct GNUNET_PQ_Context *db;
95  unsigned int elen = 0;
96  unsigned int plen = 0;
97 
98  if (NULL != es)
99  while (NULL != es[elen].sql)
100  elen++;
101  if (NULL != ps)
102  while (NULL != ps[plen].name)
103  plen++;
104 
105  db = GNUNET_new (struct GNUNET_PQ_Context);
107  if (NULL != load_path)
109  if (0 != elen)
110  {
111  db->es = GNUNET_new_array (elen + 1,
113  memcpy (db->es,
114  es,
115  elen * sizeof (struct GNUNET_PQ_ExecuteStatement));
116  }
117  if (0 != plen)
118  {
119  db->ps = GNUNET_new_array (plen + 1,
121  memcpy (db->ps,
122  ps,
123  plen * sizeof (struct GNUNET_PQ_PreparedStatement));
124  }
125  GNUNET_PQ_reconnect (db);
126  if (NULL == db->conn)
127  {
129  GNUNET_free (db->config_str);
130  GNUNET_free (db);
131  return NULL;
132  }
133  return db;
134 }
void GNUNET_PQ_reconnect(struct GNUNET_PQ_Context *db)
Reinitialize the database db.
Definition: pq_connect.c:323
struct GNUNET_PQ_PreparedStatement * ps
Prepared statements.
Definition: pq.h:49
char * load_path
Path to load SQL files from.
Definition: pq.h:59
Information needed to run a list of SQL statements using GNUNET_PQ_exec_statements().
Information needed to prepare a list of SQL statements using GNUNET_PQ_prepare_statements().
struct GNUNET_PQ_ExecuteStatement * es
Statements to execute upon connection.
Definition: pq.h:44
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
PGconn * conn
Actual connection.
Definition: pq.h:39
char * config_str
Configuration to use to connect to the DB.
Definition: pq.h:54
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
static struct GNUNET_FS_DirectoryBuilder * db
Definition: gnunet-search.c:41
const char * name
Handle to Postgres database.
Definition: pq.h:34
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ apply_patch()

static int apply_patch ( struct GNUNET_PQ_Context db,
const char *  load_path,
unsigned int  i 
)
static

Apply patch number from path load_path.

Parameters
dbdatabase context to use
load_pathwhere to find the SQL code to run
ipatch number to append to the load_path
Returns
GNUNET_OK on success, GNUNET_NO if patch i does not exist, GNUNET_SYSERR on error

Definition at line 146 of file pq_connect.c.

References buf, GNUNET_PQ_Context::config_str, GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, 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, and type.

Referenced by GNUNET_PQ_reconnect(), and GNUNET_PQ_run_sql().

149 {
150  struct GNUNET_OS_Process *psql;
152  unsigned long code;
153  size_t slen = strlen (load_path) + 10;
154  char buf[slen];
155 
156  GNUNET_snprintf (buf,
157  sizeof (buf),
158  "%s%04u.sql",
159  load_path,
160  i);
162  "Applying SQL file `%s' on database %s\n",
163  buf,
164  db->config_str);
167  NULL,
168  NULL,
169  NULL,
170  "psql",
171  "psql",
172  db->config_str,
173  "-f",
174  buf,
175  "-q",
176  NULL);
177  if (NULL == psql)
178  {
180  "exec",
181  "psql");
182  return GNUNET_SYSERR;
183  }
186  &type,
187  &code));
189  if ( (GNUNET_OS_PROCESS_EXITED != type) ||
190  (0 != code) )
191  {
193  "Could not run PSQL on file %s: %d\n",
194  buf,
195  (int) code);
196  return GNUNET_SYSERR;
197  }
198  return GNUNET_OK;
199 }
void GNUNET_OS_process_destroy(struct GNUNET_OS_Process *proc)
Cleans up process structure contents (OS-dependent) and deallocates it.
Definition: os_priority.c:287
int GNUNET_snprintf(char *buf, size_t size, const char *format,...)
Like snprintf, just aborts if the buffer is of insufficient size.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_OS_Process * GNUNET_OS_start_process(int pipe_control, enum GNUNET_OS_InheritStdioFlags std_inheritance, struct GNUNET_DISK_PipeHandle *pipe_stdin, struct GNUNET_DISK_PipeHandle *pipe_stdout, struct GNUNET_DISK_PipeHandle *pipe_stderr, const char *filename,...)
Start a process.
Definition: os_priority.c:687
#define GNUNET_NO
Definition: gnunet_common.h:86
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:83
char * config_str
Configuration to use to connect to the DB.
Definition: pq.h:54
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
No standard streams should be inherited.
Definition: gnunet_os_lib.h:73
GNUNET_OS_ProcessStatusType
Process status types.
int GNUNET_OS_process_wait_status(struct GNUNET_OS_Process *proc, enum GNUNET_OS_ProcessStatusType *type, unsigned long *code)
Retrieve the status of a process, waiting on it if dead.
Definition: os_priority.c:981
static char buf[2048]
The process exited with a return code.
#define GNUNET_SYSERR
Definition: gnunet_common.h:84
#define GNUNET_log(kind,...)
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
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
dbdatabase context to use
load_pathwhere to find the XXXX.sql files
Returns
GNUNET_OK on success

Definition at line 212 of file pq_connect.c.

References apply_patch(), buf, GNUNET_break, GNUNET_DB_STATUS_HARD_ERROR, GNUNET_DB_STATUS_SUCCESS_ONE_RESULT, GNUNET_DISK_file_test(), 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, GNUNET_YES, and ret.

Referenced by GNUNET_PQ_reconnect().

214 {
215  const char *load_path_suffix;
216  size_t slen = strlen (load_path) + 10;
217 
218  load_path_suffix = strrchr (load_path, '/');
219  if (NULL == load_path_suffix)
220  {
221  GNUNET_break (0);
222  return GNUNET_SYSERR;
223  }
224  load_path_suffix++; /* skip '/' */
225  for (unsigned int i = 1; i<10000; i++)
226  {
227  enum GNUNET_DB_QueryStatus qs;
228  {
229  char buf[slen];
230 
231  /* First, check patch actually exists */
232  GNUNET_snprintf (buf,
233  sizeof (buf),
234  "%s%04u.sql",
235  load_path,
236  i);
237  if (GNUNET_YES !=
238  GNUNET_DISK_file_test (buf))
239  return GNUNET_OK; /* We are done */
240  }
241 
242  /* Second, check with DB versioning schema if this patch was already applied,
243  if so, skip it. */
244  {
245  char patch_name[slen];
246 
247  GNUNET_snprintf (patch_name,
248  sizeof (patch_name),
249  "%s%04u",
250  load_path_suffix,
251  i);
252  {
253  char *applied_by;
254  struct GNUNET_PQ_QueryParam params[] = {
255  GNUNET_PQ_query_param_string (patch_name),
257  };
258  struct GNUNET_PQ_ResultSpec rs[] = {
259  GNUNET_PQ_result_spec_string ("applied_by",
260  &applied_by),
262  };
263 
265  "gnunet_pq_check_patch",
266  params,
267  rs);
269  {
271  "Database version %s already applied by %s, skipping\n",
272  patch_name,
273  applied_by);
275  }
276  if (GNUNET_DB_STATUS_HARD_ERROR == qs)
277  {
278  GNUNET_break (0);
279  return GNUNET_SYSERR;
280  }
281  }
282  }
284  continue; /* patch already applied, skip it */
285 
286  /* patch not yet applied, run it! */
287  {
288  int ret;
289 
290  ret = apply_patch (db,
291  load_path,
292  i);
293  if (GNUNET_NO == ret)
294  break;
295  if (GNUNET_SYSERR == ret)
296  return GNUNET_SYSERR;
297  }
298  }
299  return GNUNET_OK;
300 }
int GNUNET_DISK_file_test(const char *fil)
Check that fil corresponds to a filename (of a file that exists and that is not a directory)...
Definition: disk.c:544
int GNUNET_snprintf(char *buf, size_t size, const char *format,...)
Like snprintf, just aborts if the buffer is of insufficient size.
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_string(const char *ptr)
Generate query parameter for a string.
static int apply_patch(struct GNUNET_PQ_Context *db, const char *load_path, unsigned int i)
Apply patch number from path load_path.
Definition: pq_connect.c:146
Description of a DB result cell.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
#define GNUNET_NO
Definition: gnunet_common.h:86
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:83
A hard error occurred, retrying will not help.
Definition: gnunet_db_lib.h:39
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_string(const char *name, char **dst)
0-terminated string expected.
#define GNUNET_PQ_result_spec_end
End of result parameter specification.
#define GNUNET_PQ_query_param_end
End of query parameter specification.
Definition: gnunet_pq_lib.h:96
enum GNUNET_DB_QueryStatus GNUNET_PQ_eval_prepared_singleton_select(struct GNUNET_PQ_Context *db, const char *statement_name, const struct GNUNET_PQ_QueryParam *params, struct GNUNET_PQ_ResultSpec *rs)
Execute a named prepared statement that is a SELECT statement which must return a single result in co...
Definition: pq_eval.c:258
static char buf[2048]
#define GNUNET_SYSERR
Definition: gnunet_common.h:84
The transaction succeeded, and yielded one result.
Definition: gnunet_db_lib.h:58
Description of a DB query parameter.
Definition: gnunet_pq_lib.h:64
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:85
GNUNET_DB_QueryStatus
Status code returned from functions running database commands.
Definition: gnunet_db_lib.h:34
void GNUNET_PQ_cleanup_result(struct GNUNET_PQ_ResultSpec *rs)
Free all memory that was allocated in rs during GNUNET_PQ_extract_result().
Definition: pq.c:130
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
dbdatabase connection to reinitialize

Definition at line 309 of file pq_connect.c.

References GNUNET_PQ_Context::conn, and GNUNET_PQ_reconnect().

310 {
311  if (CONNECTION_BAD != PQstatus (db->conn))
312  return;
313  GNUNET_PQ_reconnect (db);
314 }
void GNUNET_PQ_reconnect(struct GNUNET_PQ_Context *db)
Reinitialize the database db.
Definition: pq_connect.c:323
PGconn * conn
Actual connection.
Definition: pq.h:39
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
dbdatabase connection to reinitialize

Definition at line 323 of file pq_connect.c.

References apply_patch(), GNUNET_PQ_Context::config_str, GNUNET_PQ_Context::conn, GNUNET_PQ_Context::es, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_log_from, GNUNET_NO, GNUNET_OK, GNUNET_PQ_exec_statements(), GNUNET_PQ_prepare_statements(), GNUNET_PQ_run_sql(), GNUNET_SYSERR, GNUNET_PQ_Context::load_path, pq_notice_processor_cb(), pq_notice_receiver_cb(), GNUNET_PQ_Context::ps, res, and ret.

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

324 {
325  if (NULL != db->conn)
326  PQfinish (db->conn);
327  db->conn = PQconnectdb (db->config_str);
328  if ( (NULL == db->conn) ||
329  (CONNECTION_OK != PQstatus (db->conn)) )
330  {
332  "pq",
333  "Database connection to '%s' failed: %s\n",
334  db->config_str,
335  (NULL != db->conn) ?
336  PQerrorMessage (db->conn)
337  : "PQconnectdb returned NULL");
338  if (NULL != db->conn)
339  {
340  PQfinish (db->conn);
341  db->conn = NULL;
342  }
343  return;
344  }
345  PQsetNoticeReceiver (db->conn,
347  db);
348  PQsetNoticeProcessor (db->conn,
350  db);
351  if (NULL != db->load_path)
352  {
353  PGresult *res;
354 
355  res = PQprepare (db->conn,
356  "gnunet_pq_check_patch",
357  "SELECT"
358  " applied_by"
359  " FROM _v.patches"
360  " WHERE patch_name = $1"
361  " LIMIT 1",
362  1,
363  NULL);
364  if (PGRES_COMMAND_OK != PQresultStatus (res))
365  {
366  int ret;
367 
368  PQclear (res);
370  "Failed to prepare statement to check patch level. Likely versioning schema does not exist yet, loading patch level 0000!\n");
371  ret = apply_patch (db,
372  db->load_path,
373  0);
374  if (GNUNET_NO == ret)
375  {
377  "Failed to find SQL file to load database versioning logic\n");
378  PQfinish (db->conn);
379  db->conn = NULL;
380  return;
381  }
382  if (GNUNET_SYSERR == ret)
383  {
385  "Failed to run SQL logic to setup database versioning logic\n");
386  PQfinish (db->conn);
387  db->conn = NULL;
388  return;
389  }
390  /* try again to prepare our statement! */
391  res = PQprepare (db->conn,
392  "gnunet_pq_check_patch",
393  "SELECT"
394  " applied_by"
395  " FROM _v.patches"
396  " WHERE patch_name = $1"
397  " LIMIT 1",
398  1,
399  NULL);
400  if (PGRES_COMMAND_OK != PQresultStatus (res))
401  {
403  "Failed to run SQL logic to setup database versioning logic: %s/%s\n",
404  PQresultErrorMessage (res),
405  PQerrorMessage (db->conn));
406  PQclear (res);
407  PQfinish (db->conn);
408  db->conn = NULL;
409  return;
410  }
411  }
412  PQclear (res);
413 
414  if (GNUNET_SYSERR ==
415  GNUNET_PQ_run_sql (db,
416  db->load_path))
417  {
419  "Failed to load SQL statements from `%s'\n",
420  db->load_path);
421  PQfinish (db->conn);
422  db->conn = NULL;
423  return;
424  }
425  }
426  if ( (NULL != db->es) &&
427  (GNUNET_OK !=
429  db->es)) )
430  {
431  PQfinish (db->conn);
432  db->conn = NULL;
433  return;
434  }
435  if ( (NULL != db->ps) &&
436  (GNUNET_OK !=
438  db->ps)) )
439  {
440  PQfinish (db->conn);
441  db->conn = NULL;
442  return;
443  }
444 }
struct GNUNET_PQ_PreparedStatement * ps
Prepared statements.
Definition: pq.h:49
char * load_path
Path to load SQL files from.
Definition: pq.h:59
struct GNUNET_PQ_ExecuteStatement * es
Statements to execute upon connection.
Definition: pq.h:44
static int apply_patch(struct GNUNET_PQ_Context *db, const char *load_path, unsigned int i)
Apply patch number from path load_path.
Definition: pq_connect.c:146
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
int GNUNET_PQ_prepare_statements(struct GNUNET_PQ_Context *db, const struct GNUNET_PQ_PreparedStatement *ps)
Request creation of prepared statements ps from Postgres.
Definition: pq_prepare.c:62
#define GNUNET_NO
Definition: gnunet_common.h:86
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:83
PGconn * conn
Actual connection.
Definition: pq.h:39
int GNUNET_PQ_exec_statements(struct GNUNET_PQ_Context *db, const struct GNUNET_PQ_ExecuteStatement *es)
Request execution of an array of statements es from Postgres.
Definition: pq_exec.c:76
char * config_str
Configuration to use to connect to the DB.
Definition: pq.h:54
static int res
#define GNUNET_SYSERR
Definition: gnunet_common.h:84
#define GNUNET_log(kind,...)
static void pq_notice_receiver_cb(void *arg, const PGresult *res)
Function called by libpq whenever it wants to log something.
Definition: pq_connect.c:38
static void pq_notice_processor_cb(void *arg, const char *message)
Function called by libpq whenever it wants to log something.
Definition: pq_connect.c:55
#define GNUNET_log_from(kind, comp,...)
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 fi...
Definition: pq_connect.c:212
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
cfgconfiguration
sectionconfiguration section to use to get Postgres configuration options
load_path_suffixsuffix to append to the SQL_DIR in the configuration
esGNUNET_PQ_PREPARED_STATEMENT_END-terminated array of statements to execute upon EACH connection, can be NULL
psarray of prepared statements to prepare, can be NULL
Returns
the postgres handle, NULL on error

Definition at line 465 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().

470 {
471  struct GNUNET_PQ_Context *db;
472  char *conninfo;
473  char *load_path;
474  char *sp;
475 
476  if (GNUNET_OK !=
478  section,
479  "CONFIG",
480  &conninfo))
481  conninfo = NULL;
482  load_path = NULL;
483  sp = NULL;
484  if ( (NULL != load_path_suffix) &&
485  (GNUNET_OK ==
487  section,
488  "SQL_DIR",
489  &sp)) )
490  GNUNET_asprintf (&load_path,
491  "%s%s",
492  sp,
493  load_path_suffix);
494  db = GNUNET_PQ_connect (conninfo == NULL ? "" : conninfo,
495  load_path,
496  es,
497  ps);
498  GNUNET_free_non_null (load_path);
500  GNUNET_free_non_null (conninfo);
501  return db;
502 }
char * load_path
Path to load SQL files from.
Definition: pq.h:59
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:83
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
static char * section
Name of the section.
Definition: gnunet-config.c:33
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.
Definition: pq_connect.c:89
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
int GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
static struct GNUNET_FS_DirectoryBuilder * db
Definition: gnunet-search.c:41
int GNUNET_CONFIGURATION_get_value_filename(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be the name of a file or directory.
Handle to Postgres database.
Definition: pq.h:34
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
dbdatabase handle to disconnect (will be free'd)

Definition at line 512 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().

513 {
514  GNUNET_free_non_null (db->es);
515  GNUNET_free_non_null (db->ps);
518  PQfinish (db->conn);
519  GNUNET_free (db);
520 }
struct GNUNET_PQ_PreparedStatement * ps
Prepared statements.
Definition: pq.h:49
char * load_path
Path to load SQL files from.
Definition: pq.h:59
struct GNUNET_PQ_ExecuteStatement * es
Statements to execute upon connection.
Definition: pq.h:44
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
PGconn * conn
Actual connection.
Definition: pq.h:39
char * config_str
Configuration to use to connect to the DB.
Definition: pq.h:54
#define GNUNET_free(ptr)
Wrapper around free.
Here is the caller graph for this function: