;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2014, 2015, 2016, 2017, 2019, 2020 Ludovic Courtès <ludo@gnu.org>
;;; Copyright © 2015 Joshua S. Grant <jgrant@parenthetical.io>
;;; Copyright © 2017 Mathieu Othacehe <m.othacehe@gmail.com>
;;;
;;; This file is part of GNU Guix.
;;;
;;; GNU Guix is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.

(define-module (gnu)
  #:use-module (guix i18n)
  #:use-module (guix diagnostics)
  #:use-module (srfi srfi-34)
  #:use-module (srfi srfi-35)
  #:use-module (ice-9 match)
  #:use-module (guix packages)
  #:use-module (gnu packages)
  #:use-module (gnu services)
  #:export (use-package-modules
            use-service-modules
            use-system-modules))

;;; Commentary:
;;;
;;; This composite module re-exports core parts the (gnu …) public modules.
;;;
;;; Code:

(eval-when (eval load compile)
  (begin
    (define %public-modules
      '((gnu system)
        (gnu system mapped-devices)
        (gnu system file-systems)
        (gnu bootloader)
        (gnu bootloader grub)
        (gnu system keyboard)
        (gnu system pam)
        (gnu system shadow)                       ; 'user-account'
        (gnu system linux-initrd)
        (gnu system nss)
        (gnu services)
        (gnu services base)
        (gnu packages)
        (gnu packages base)
        (guix gexp)))                             ; so gex<pre>
#include &quot;sqlite.hh&quot;
#include &quot;util.hh&quot;

#include &lt;sqlite3.h&gt;

namespace nix {

[[noreturn]] void throwSQLiteError(sqlite3 * db, const format &amp; f)
{
    int err = sqlite3_errcode(db);
    if (err == SQLITE_BUSY || err == SQLITE_PROTOCOL) {
        if (err == SQLITE_PROTOCOL)
            printMsg(lvlError, &quot;warning: SQLite database is busy (SQLITE_PROTOCOL)&quot;);
        else {
            static bool warned = false;
            if (!warned) {
                printMsg(lvlError, &quot;warning: SQLite database is busy&quot;);
                warned = true;
            }
        }
        /* Sleep for a while since retrying the transaction right away
           is likely to fail again. */
#if HAVE_NANOSLEEP
        struct timespec t;
        t.tv_sec = 0;
        t.tv_nsec = (random() % 100) * 1000 * 1000; /* &lt;= 0.1s */
        nanosleep(&amp;t, 0);
#else
        sleep(1);
#endif
        throw SQLiteBusy(format(&quot;%1%: %2%&quot;) % f.str() % sqlite3_errmsg(db));
    }
    else
        throw SQLiteError(format(&quot;%1%: %2%&quot;) % f.str() % sqlite3_errmsg(db));
}

SQLite::~SQLite()
{
    try {
        if (db &amp;&amp; sqlite3_close(db) != SQLITE_OK)
            throwSQLiteError(db, &quot;closing database&quot;);
    } catch (...) {
        ignoreException();
    }
}

void SQLiteStmt::create(sqlite3 * db, const string &amp; s)
{
    checkInterrupt();
    assert(!stmt);
    if (sqlite3_prepare_v2(db, s.c_str(), -1, &amp;stmt, 0) != SQLITE_OK)
        throwSQLiteError(db, &quot;creating statement&quot;);
    this-&gt;db = db;
}

SQLiteStmt::~SQLiteStmt()
{
    try {
        if (stmt &amp;&amp; sqlite3_finalize(stmt) != SQLITE_OK)
            throwSQLiteError(db, &quot;finalizing statement&quot;);
    } catch (...) {
        ignoreException();
    }
}

SQLiteStmt::Use::Use(SQLiteStmt &amp; stmt)
    : stmt(stmt)
{
    assert(stmt.stmt);
    /* Note: sqlite3_reset() returns the error code for the most
       recent call to sqlite3_step().  So ignore it. */
    sqlite3_reset(stmt);
}

SQLiteStmt::Use::~Use()
{
    sqlite3_reset(stmt);
}

SQLiteStmt::Use &amp; SQLiteStmt::Use::operator () (const std::string &amp; value, bool notNull)
{
    if (notNull) {
        if (sqlite3_bind_text(stmt, curArg++, value.c_str(), -1, SQLITE_TRANSIENT) != SQLITE_OK)
            throwSQLiteError(stmt.db, &quot;binding argument&quot;);
    } else
        bind();
    return *this;
}

SQLiteStmt::Use &amp; SQLiteStmt::Use::operator () (int64_t value, bool notNull)
{
    if (notNull) {
        if (sqlite3_bind_int64(stmt, curArg++, value) != SQLITE_OK)
            throwSQLiteError(stmt.db, &quot;binding argument&quot;);
    } else
        bind();
    return *this;
}

SQLiteStmt::Use &amp; SQLiteStmt::Use::bind()
{
    if (sqlite3_bind_null(stmt, curArg++) != SQLITE_OK)
        throwSQLiteError(stmt.db, &quot;binding argument&quot;);
    return *this;
}

int SQLiteStmt::Use::step()
{
    return sqlite3_step(stmt);
}

void SQLiteStmt::Use::exec()
{
    int r = step();
    assert(r != SQLITE_ROW);
    if (r != SQLITE_DONE)
        throwSQLiteError(stmt.db, &quot;executing SQLite statement&quot;);
}

bool SQLiteStmt::Use::next()
{
    int r = step();
    if (r != SQLITE_DONE &amp;&amp; r != SQLITE_ROW)
        throwSQLiteError(stmt