nixo
/
guix-devel
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Remove 'guix-register' and its traces. 

* Makefile.am (SH_TESTS): Remove tests/guix-register.sh.
* build-aux/pre-inst-env.in (GUIX_REGISTER): Remove.
* gnu/build/install.scm (directives): Remove outdated comment.
* gnu/build/vm.scm (root-partition-initializer): Update comment.
* gnu/packages/package-management.scm (guix-register): Remove.
* guix/config.scm.in (%sbindir, %guix-register-program): Remove.
* guix/scripts/system.scm (install): Adjust docstring.
* guix/self.scm (make-config.scm): Remove #:guix.  Do not generate
%sbindir and %guix-register-program.
(specification->package): Remove "guix".
* nix/guix-register/guix-register.cc: Remove.
* nix/libstore/store-api.cc (decodeValidPathInfo): Remove.
* nix/libstore/store-api.hh (decodeValidPathInfo): Remove declaration.
* nix/local.mk (sbin_PROGRAMS, guix_register_SOURCES)
(guix_register_CPPFLAGS, guix_register_LDFLAGS): Remove.
* tests/guix-register.sh: Remove.
This commit is contained in:
Ludovic Courtès 2018-06-08 11:03:31 +02:00
parent df2f6400b1
commit ea0a06cee2
No known key found for this signature in database
GPG Key ID: 090B11993D9AEBB5
14 changed files with 7 additions and 576 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -69,7 +69,6 @@
/etc/guix-publish.conf /etc/guix-publish.conf
/etc/guix-publish.service /etc/guix-publish.service
/guix-daemon /guix-daemon
/guix-register
/guix/config.scm /guix/config.scm
/libformat.a /libformat.a
/libstore.a /libstore.a

7
Makefile.am
View File

@ -405,13 +405,6 @@ SH_TESTS = \
tests/guix-graph.sh \ tests/guix-graph.sh \
tests/guix-lint.sh tests/guix-lint.sh
if BUILD_DAEMON
SH_TESTS += tests/guix-register.sh
endif BUILD_DAEMON
TESTS = $(SCM_TESTS) $(SH_TESTS) TESTS = $(SCM_TESTS) $(SH_TESTS)
AM_TESTS_ENVIRONMENT = abs_top_srcdir="$(abs_top_srcdir)" GUILE_AUTO_COMPILE=0 AM_TESTS_ENVIRONMENT = abs_top_srcdir="$(abs_top_srcdir)" GUILE_AUTO_COMPILE=0

6
build-aux/pre-inst-env.in
View File

@ -1,7 +1,7 @@
#!/bin/sh #!/bin/sh
# GNU Guix --- Functional package management for GNU # GNU Guix --- Functional package management for GNU
# Copyright © 2012, 2013, 2014, 2015, 2017 Ludovic Courtès <ludo@gnu.org> # Copyright © 2012, 2013, 2014, 2015, 2017, 2018 Ludovic Courtès <ludo@gnu.org>
# Copyright © 2017 Eric Bavier <bavier@cray.com> # Copyright © 2017 Eric Bavier <bavier@cray.com>
# #
# This file is part of GNU Guix. # This file is part of GNU Guix.
@ -55,10 +55,6 @@ NIX_BUILD_HOOK="$abs_top_builddir/nix/scripts/offload"
@BUILD_DAEMON_OFFLOAD_FALSE@# No offloading support. @BUILD_DAEMON_OFFLOAD_FALSE@# No offloading support.
@BUILD_DAEMON_OFFLOAD_FALSE@unset NIX_BUILD_HOOK @BUILD_DAEMON_OFFLOAD_FALSE@unset NIX_BUILD_HOOK
# The 'guix-register' program.
GUIX_REGISTER="$abs_top_builddir/guix-register"
export GUIX_REGISTER
# The following variables need only be defined when compiling Guix # The following variables need only be defined when compiling Guix
# modules, but we define them to be on the safe side in case of # modules, but we define them to be on the safe side in case of
# auto-compilation. # auto-compilation.

3
gnu/build/install.scm
View File

@ -110,9 +110,6 @@ STORE."
("/var/guix/gcroots/booted-system" -> "/run/booted-system") ("/var/guix/gcroots/booted-system" -> "/run/booted-system")
("/var/guix/gcroots/current-system" -> "/run/current-system") ("/var/guix/gcroots/current-system" -> "/run/current-system")
;; XXX: 'guix-register' creates this symlink with a wrong target, so
;; create it upfront to be sure.
("/var/guix/gcroots/profiles" -> "/var/guix/profiles") ("/var/guix/gcroots/profiles" -> "/var/guix/profiles")
(directory "/bin") (directory "/bin")

4
gnu/build/vm.scm
View File

@ -346,7 +346,7 @@ SYSTEM-DIRECTORY is the name of the directory of the 'system' derivation."
;; Optionally, register the inputs in the image's store. ;; Optionally, register the inputs in the image's store.
(when register-closures? (when register-closures?
(unless copy-closures? (unless copy-closures?
;; XXX: 'guix-register' wants to palpate the things it registers, so ;; XXX: 'register-closure' wants to palpate the things it registers, so
;; bind-mount the store on the target. ;; bind-mount the store on the target.
(mkdir-p target-store) (mkdir-p target-store)
(mount (%store-directory) target-store "" MS_BIND)) (mount (%store-directory) target-store "" MS_BIND))
@ -365,7 +365,7 @@ SYSTEM-DIRECTORY is the name of the directory of the 'system' derivation."
(display "populating...\n") (display "populating...\n")
(populate-root-file-system system-directory target) (populate-root-file-system system-directory target)
;; 'guix-register' resets timestamps and everything, so no need to do it ;; 'register-closure' resets timestamps and everything, so no need to do it
;; once more in that case. ;; once more in that case.
(unless register-closures? (unless register-closures?
(reset-timestamps target)))) (reset-timestamps target))))

36
gnu/packages/package-management.scm
View File

@ -294,42 +294,6 @@ the Nix package manager.")
;; Alias for backward compatibility. ;; Alias for backward compatibility.
(define-public guix-devel guix) (define-public guix-devel guix)
(define-public guix-register
;; This package is for internal consumption: it allows us to quickly build
;; the 'guix-register' program, which is referred to by (guix config).
;; TODO: Remove this hack when 'guix-register' has been superseded by Scheme
;; code.
(package
(inherit guix)
(properties `((hidden? . #t)))
(name "guix-register")
;; Use a minimum set of dependencies.
(native-inputs
(fold alist-delete (package-native-inputs guix)
'("po4a" "graphviz" "help2man")))
(propagated-inputs
`(("gnutls" ,gnutls)
("guile-git" ,guile-git)))
(arguments
(substitute-keyword-arguments (package-arguments guix)
((#:tests? #f #f)
#f)
((#:phases phases '%standard-phases)
`(modify-phases ,phases
(replace 'build
(lambda _
(invoke "make" "nix/libstore/schema.sql.hh")
(invoke "make" "-j" (number->string
(parallel-job-count))
"guix-register")))
(delete 'copy-bootstrap-guile)
(replace 'install
(lambda _
(invoke "make" "install-sbinPROGRAMS")))
(delete 'wrap-program)))))))
(define-public guile2.0-guix (define-public guile2.0-guix
(package (package
(inherit guix) (inherit guix)

12
guix/config.scm.in
View File

@ -1,5 +1,5 @@
;;; GNU Guix --- Functional package management for GNU ;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2012, 2013, 2014, 2015, 2016 Ludovic Courtès <ludo@gnu.org> ;;; Copyright © 2012, 2013, 2014, 2015, 2016, 2018 Ludovic Courtès <ludo@gnu.org>
;;; Copyright © 2017 Caleb Ristvedt <caleb.ristvedt@cune.org> ;;; Copyright © 2017 Caleb Ristvedt <caleb.ristvedt@cune.org>
;;; ;;;
;;; This file is part of GNU Guix. ;;; This file is part of GNU Guix.
@ -26,13 +26,11 @@
%storedir %storedir
%localstatedir %localstatedir
%sysconfdir %sysconfdir
%sbindir
%store-directory %store-directory
%state-directory %state-directory
%store-database-directory %store-database-directory
%config-directory %config-directory
%guix-register-program
%system %system
%libgcrypt %libgcrypt
@ -70,9 +68,6 @@
(define %sysconfdir (define %sysconfdir
"@guix_sysconfdir@") "@guix_sysconfdir@")
(define %sbindir
"@guix_sbindir@")
(define %store-directory (define %store-directory
(or (and=> (getenv "NIX_STORE_DIR") canonicalize-path) (or (and=> (getenv "NIX_STORE_DIR") canonicalize-path)
%storedir)) %storedir))
@ -91,11 +86,6 @@
(or (getenv "GUIX_CONFIGURATION_DIRECTORY") (or (getenv "GUIX_CONFIGURATION_DIRECTORY")
(string-append %sysconfdir "/guix"))) (string-append %sysconfdir "/guix")))
(define %guix-register-program
;; The 'guix-register' program.
(or (getenv "GUIX_REGISTER")
(string-append %sbindir "/guix-register")))
(define %system (define %system
"@guix_system@") "@guix_system@")

2
guix/scripts/system.scm
View File

@ -198,7 +198,7 @@ TARGET, and register them."
bootcfg bootcfg-file) bootcfg bootcfg-file)
"Copy the closure of BOOTCFG, which includes the output of OS-DRV, to "Copy the closure of BOOTCFG, which includes the output of OS-DRV, to
directory TARGET. TARGET must be an absolute directory name since that's what directory TARGET. TARGET must be an absolute directory name since that's what
'guix-register' expects. 'register-path' expects.
When INSTALL-BOOTLOADER? is true, install bootloader using BOOTCFG." When INSTALL-BOOTLOADER? is true, install bootloader using BOOTCFG."
(define (maybe-copy to-copy) (define (maybe-copy to-copy)

21
guix/self.scm
View File

@ -89,8 +89,6 @@ GUILE-VERSION (\"2.0\" or \"2.2\"), or #f if none of the packages matches."
("gzip" (ref '(gnu packages compression) 'gzip)) ("gzip" (ref '(gnu packages compression) 'gzip))
("bzip2" (ref '(gnu packages compression) 'bzip2)) ("bzip2" (ref '(gnu packages compression) 'bzip2))
("xz" (ref '(gnu packages compression) 'xz)) ("xz" (ref '(gnu packages compression) 'xz))
("guix" (ref '(gnu packages package-management)
'guix-register))
("guile2.0-json" (ref '(gnu packages guile) 'guile2.0-json)) ("guile2.0-json" (ref '(gnu packages guile) 'guile2.0-json))
("guile2.0-ssh" (ref '(gnu packages ssh) 'guile2.0-ssh)) ("guile2.0-ssh" (ref '(gnu packages ssh) 'guile2.0-ssh))
("guile2.0-git" (ref '(gnu packages guile) 'guile2.0-git)) ("guile2.0-git" (ref '(gnu packages guile) 'guile2.0-git))
@ -565,7 +563,6 @@ the modules, and DEPENDENCIES, a list of packages depended on. COMMAND is the
#:gzip gzip #:gzip gzip
#:bzip2 bzip2 #:bzip2 bzip2
#:xz xz #:xz xz
#:guix guix
#:package-name #:package-name
%guix-package-name %guix-package-name
#:package-version #:package-version
@ -630,8 +627,7 @@ the modules, and DEPENDENCIES, a list of packages depended on. COMMAND is the
(define %dependency-variables (define %dependency-variables
;; (guix config) variables corresponding to dependencies. ;; (guix config) variables corresponding to dependencies.
'(%libgcrypt %libz %xz %gzip %bzip2 %nix-instantiate '(%libgcrypt %libz %xz %gzip %bzip2 %nix-instantiate))
%sbindir %guix-register-program))
(define %persona-variables (define %persona-variables
;; (guix config) variables that define Guix's persona. ;; (guix config) variables that define Guix's persona.
@ -653,7 +649,7 @@ the modules, and DEPENDENCIES, a list of packages depended on. COMMAND is the
(string<? (symbol->string (car name+value1)) (string<? (symbol->string (car name+value1))
(symbol->string (car name+value2)))))) (symbol->string (car name+value2))))))
(define* (make-config.scm #:key libgcrypt zlib gzip xz bzip2 guix (define* (make-config.scm #:key libgcrypt zlib gzip xz bzip2
(package-name "GNU Guix") (package-name "GNU Guix")
(package-version "0") (package-version "0")
(bug-report-address "bug-guix@gnu.org") (bug-report-address "bug-guix@gnu.org")
@ -669,8 +665,6 @@ the modules, and DEPENDENCIES, a list of packages depended on. COMMAND is the
%guix-version %guix-version
%guix-bug-report-address %guix-bug-report-address
%guix-home-page-url %guix-home-page-url
%sbindir
%guix-register-program
%libgcrypt %libgcrypt
%libz %libz
%gzip %gzip
@ -688,17 +682,6 @@ the modules, and DEPENDENCIES, a list of packages depended on. COMMAND is the
(define %guix-bug-report-address #$bug-report-address) (define %guix-bug-report-address #$bug-report-address)
(define %guix-home-page-url #$home-page-url) (define %guix-home-page-url #$home-page-url)
(define %sbindir
;; This is used to define '%guix-register-program'.
;; TODO: Use a derivation that builds nothing but the
;; C++ part.
#+(and guix (file-append guix "/sbin")))
(define %guix-register-program
(or (getenv "GUIX_REGISTER")
(and %sbindir
(string-append %sbindir "/guix-register"))))
(define %gzip (define %gzip
#+(and gzip (file-append gzip "/bin/gzip"))) #+(and gzip (file-append gzip "/bin/gzip")))
(define %bzip2 (define %bzip2

254
nix/guix-register/guix-register.cc
View File

@ -1,254 +0,0 @@
/* GNU Guix --- Functional package management for GNU
Copyright (C) 2013, 2014, 2015 Ludovic Courtès <ludo@gnu.org>
Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012,
2013 Eelco Dolstra <eelco.dolstra@logicblox.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/>. */
/* This file derives from the implementation of 'nix-store
--register-validity', by Eelco Dolstra, as found in the Nix package
manager's src/nix-store/nix-store.cc. */
#include <config.h>
#include <globals.hh>
#include <local-store.hh>
#include <iostream>
#include <fstream>
#include <cstdlib>
#include <cstdio>
#include <argp.h>
#include <gcrypt.h>
using namespace nix;
/* Input stream where we read closure descriptions. */
static std::istream *input = &std::cin;
/* Command-line options. */
const char *argp_program_version =
"guix-register (" PACKAGE_NAME ") " PACKAGE_VERSION;
const char *argp_program_bug_address = PACKAGE_BUGREPORT;
static char doc[] =
"guix-register -- register a closure as valid in a store\
\v\
This program is used internally when populating a store with data \
from an existing store. It updates the new store's database with \
information about which store files are valid, and what their \
references are.";
#define GUIX_OPT_STATE_DIRECTORY 1
#define GUIX_OPT_DEDUPLICATE 2
static const struct argp_option options[] =
{
{ "prefix", 'p', "DIRECTORY", 0,
"Open the store that lies under DIRECTORY" },
{ "state-directory", GUIX_OPT_STATE_DIRECTORY, "DIRECTORY", 0,
"Use DIRECTORY as the state directory of the target store" },
{ "no-deduplication", GUIX_OPT_DEDUPLICATE, 0, 0,
"Disable automatic deduplication of registered store items" },
{ 0, 0, 0, 0, 0 }
};
/* Prefix of the store being populated. */
static std::string prefix;
/* Whether to deduplicate the registered store items. */
static bool deduplication = true;
/* Parse a single option. */
static error_t
parse_opt (int key, char *arg, struct argp_state *state)
{
switch (key)
{
case 'p':
{
prefix = canonPath (arg);
settings.nixStore = prefix + NIX_STORE_DIR;
settings.nixDataDir = prefix + NIX_DATA_DIR;
settings.nixLogDir = prefix + NIX_LOG_DIR;
settings.nixStateDir = prefix + NIX_STATE_DIR;
settings.nixDBPath = settings.nixStateDir + "/db";
break;
}
case GUIX_OPT_STATE_DIRECTORY:
{
string state_dir = canonPath (arg);
settings.nixStateDir = state_dir;
settings.nixDBPath = state_dir + "/db";
break;
}
case GUIX_OPT_DEDUPLICATE:
deduplication = false;
break;
case ARGP_KEY_ARG:
{
std::ifstream *file;
if (state->arg_num >= 2)
/* Too many arguments. */
argp_usage (state);
file = new std::ifstream ();
file->open (arg);
input = file;
}
break;
default:
return (error_t) ARGP_ERR_UNKNOWN;
}
return (error_t) 0;
}
/* Argument parsing. */
static struct argp argp = { options, parse_opt, 0, doc };
/* Read from INPUT the description of a closure, and register it as valid in
STORE. The expected format on INPUT is that used by #:references-graphs:
FILE
DERIVER
NUMBER-OF-REFERENCES
REF1
...
REFN
This is really meant as an internal format. */
static void
register_validity (LocalStore *store, std::istream &input,
bool optimize = true,
bool reregister = true, bool hashGiven = false,
bool canonicalise = true)
{
ValidPathInfos infos;
while (1)
{
ValidPathInfo info = decodeValidPathInfo (input, hashGiven);
if (info.path == "")
break;
if (!prefix.empty ())
{
/* Rewrite the input to refer to the final name, as if we were in a
chroot under PREFIX. */
std::string final_prefix (NIX_STORE_DIR "/");
info.path = final_prefix + baseNameOf (info.path);
}
/* Keep its real path to canonicalize it and compute its hash. */
std::string real_path;
real_path = prefix + "/" + settings.nixStore + "/" + baseNameOf (info.path);
if (!store->isValidPath (info.path) || reregister)
{
/* !!! races */
if (canonicalise)
canonicalisePathMetaData (real_path, -1);
if (!hashGiven)
{
HashResult hash = hashPath (htSHA256, real_path);
info.hash = hash.first;
info.narSize = hash.second;
}
infos.push_back (info);
}
}
store->registerValidPaths (infos);
/* XXX: When PREFIX is non-empty, store->linksDir points to the original
store's '.links' directory, which means 'optimisePath' would try to link
to that instead of linking to the target store. Thus, disable
deduplication in this case. */
if (optimize)
{
/* Make sure deduplication is enabled. */
settings.autoOptimiseStore = true;
std::string store_dir = settings.nixStore;
/* 'optimisePath' creates temporary links under 'settings.nixStore' and
this must be the real target store, under PREFIX, to avoid
cross-device links. Thus, temporarily switch the value of
'settings.nixStore'. */
settings.nixStore = prefix + store_dir;
for (auto&& i: infos)
store->optimisePath (prefix + i.path);
settings.nixStore = store_dir;
}
}
int
main (int argc, char *argv[])
{
/* Initialize libgcrypt, which is indirectly used. */
if (!gcry_check_version (GCRYPT_VERSION))
{
fprintf (stderr, "error: libgcrypt version mismatch\n");
exit (EXIT_FAILURE);
}
/* Tell Libgcrypt that initialization has completed, as per the Libgcrypt
1.6.0 manual (although this does not appear to be strictly needed.) */
gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
/* Honor the environment variables, and initialize the settings. */
settings.processEnvironment ();
try
{
argp_parse (&argp, argc, argv, 0, 0, 0);
/* Instantiate the store. This creates any missing directories among
'settings.nixStore', 'settings.nixDBPath', etc. */
LocalStore store;
if (!prefix.empty ())
/* Under the --prefix tree, the final name of the store will be
NIX_STORE_DIR. Set it here so that the database uses file names
prefixed by NIX_STORE_DIR and not PREFIX + NIX_STORE_DIR. */
settings.nixStore = NIX_STORE_DIR;
register_validity (&store, *input, deduplication);
}
catch (std::exception &e)
{
fprintf (stderr, "error: %s\n", e.what ());
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}

26
nix/libstore/store-api.cc
View File

@ -226,32 +226,6 @@ string StoreAPI::makeValidityRegistration(const PathSet & paths,
return s; return s;
} }
ValidPathInfo decodeValidPathInfo(std::istream & str, bool hashGiven)
{
ValidPathInfo info;
getline(str, info.path);
if (str.eof()) { info.path = ""; return info; }
if (hashGiven) {
string s;
getline(str, s);
info.hash = parseHash(htSHA256, s);
getline(str, s);
if (!string2Int(s, info.narSize)) throw Error("number expected");
}
getline(str, info.deriver);
string s; int n;
getline(str, s);
if (!string2Int(s, n)) throw Error("number expected");
while (n--) {
getline(str, s);
info.references.insert(s);
}
if (!str || str.eof()) throw Error("missing input");
return info;
}
string showPaths(const PathSet & paths) string showPaths(const PathSet & paths)
{ {
string s; string s;

4
nix/libstore/store-api.hh
View File

@ -371,10 +371,6 @@ std::shared_ptr<StoreAPI> openStore(bool reserveSpace = true);
string showPaths(const PathSet & paths); string showPaths(const PathSet & paths);
ValidPathInfo decodeValidPathInfo(std::istream & str,
bool hashGiven = false);
/* Export multiple paths in the format expected by ‘nix-store /* Export multiple paths in the format expected by ‘nix-store
--import’. */ --import’. */
void exportPaths(StoreAPI & store, const Paths & paths, void exportPaths(StoreAPI & store, const Paths & paths,

16
nix/local.mk
View File

@ -120,7 +120,6 @@ libstore_a_CXXFLAGS = $(AM_CXXFLAGS) \
$(SQLITE3_CFLAGS) $(LIBGCRYPT_CFLAGS) $(SQLITE3_CFLAGS) $(LIBGCRYPT_CFLAGS)
bin_PROGRAMS = guix-daemon bin_PROGRAMS = guix-daemon
sbin_PROGRAMS = guix-register
guix_daemon_SOURCES = \ guix_daemon_SOURCES = \
%D%/nix-daemon/nix-daemon.cc \ %D%/nix-daemon/nix-daemon.cc \
@ -138,24 +137,9 @@ guix_daemon_LDADD = \
guix_daemon_headers = \ guix_daemon_headers = \
%D%/nix-daemon/shared.hh %D%/nix-daemon/shared.hh
guix_register_SOURCES = \
%D%/guix-register/guix-register.cc
guix_register_CPPFLAGS = \
$(libutil_a_CPPFLAGS) \
$(libstore_a_CPPFLAGS) \
-I$(top_srcdir)/%D%/libstore
# XXX: Should we start using shared libs?
guix_register_LDADD = \
libstore.a libutil.a libformat.a -lz \
$(SQLITE3_LIBS) $(LIBGCRYPT_LIBS)
if HAVE_LIBBZ2 if HAVE_LIBBZ2
guix_daemon_LDADD += -lbz2 guix_daemon_LDADD += -lbz2
guix_register_LDADD += -lbz2
endif HAVE_LIBBZ2 endif HAVE_LIBBZ2

191
tests/guix-register.sh
View File

@ -1,191 +0,0 @@
# GNU Guix --- Functional package management for GNU
# Copyright © 2013, 2014, 2015, 2016 Ludovic Courtès <ludo@gnu.org>
#
# 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/>.
#
# Test the 'guix-register' command-line utility.
#
guix-register --version
new_store="t-register-$$"
closure="t-register-closure-$$"
rm -rf "$new_store"
exit_hook=":"
trap "chmod -R +w $new_store ; rm -rf $new_store $closure ; \$exit_hook" EXIT
#
# Registering items in the current store---i.e., without '--prefix'.
#
new_file="$NIX_STORE_DIR/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-guix-register-$$"
echo "Fake store file to test registration." > "$new_file"
# Register the file with zero references and no deriver.
guix-register <<EOF
$new_file
0
EOF
# Register an idendical file, and make sure it gets deduplicated.
new_file2="$new_file-duplicate"
cat "$new_file" > "$new_file2"
guix-register <<EOF
$new_file2
0
EOF
guile -c "
(exit (= (stat:ino (stat \"$new_file\"))
(stat:ino (stat \"$new_file2\"))))"
# Make sure both are valid.
guile -c "
(use-modules (guix store))
(define s (open-connection))
(exit (and (valid-path? s \"$new_file\")
(valid-path? s \"$new_file2\")
(null? (references s \"$new_file\"))
(null? (references s \"$new_file2\"))))"
#
# Registering items in a new store, with '--prefix'.
#
mkdir -p "$new_store/$storedir"
new_store_dir="`cd "$new_store/$storedir" ; pwd -P`"
new_store="`cd "$new_store" ; pwd -P`"
to_copy="`guix build guile-bootstrap`"
cp -r "$to_copy" "$new_store_dir"
copied="$new_store_dir/`basename $to_copy`"
# Create a file representing a closure with zero references, and with an empty
# "deriver" field. Note that we give the file name as it appears in the
# original store, and 'guix-register' translates it to match the prefix.
cat >> "$closure" <<EOF
$to_copy
0
EOF
# Register it.
guix-register -p "$new_store" < "$closure"
# Doing it a second time shouldn't hurt.
guix-register --prefix "$new_store" "$closure"
# Same, but with the database stored in a different place.
guix-register -p "$new_store" \
--state-directory "$new_store/chbouib" "$closure"
# Register duplicate files.
cp "$new_file" "$new_file2" "$new_store_dir"
guix-register -p "$new_store" <<EOF
$new_file
0
EOF
guix-register -p "$new_store" <<EOF
$new_file2
0
EOF
copied_duplicate1="$new_store_dir/`basename $new_file`"
copied_duplicate2="$new_store_dir/`basename $new_file2`"
# Make sure there is indeed deduplication under $new_store and that there are
# no cross-store hard links.
guile -c "
(exit (and (= (stat:ino (stat \"$copied_duplicate1\"))
(stat:ino (stat \"$copied_duplicate2\")))
(not (= (stat:ino (stat \"$new_file\"))
(stat:ino (stat \"$copied_duplicate1\"))))))"
# Delete them.
guix gc -d "$new_file" "$new_file2"
# Now make sure this is recognized as valid.
ls -R "$new_store"
for state_dir in "$localstatedir/guix" "/chbouib"
do
NIX_STORE_DIR="$new_store_dir"
NIX_STATE_DIR="$new_store$state_dir"
NIX_LOG_DIR="$new_store$state_dir/log/guix"
NIX_DB_DIR="$new_store$state_dir/db"
GUIX_DAEMON_SOCKET="$NIX_STATE_DIR/daemon-socket/socket"
export NIX_IGNORE_SYMLINK_STORE NIX_STORE_DIR NIX_STATE_DIR \
NIX_LOG_DIR NIX_DB_DIR GUIX_DAEMON_SOCKET
# Check whether we overflow the limitation on local socket name lengths.
if [ `echo "$GUIX_DAEMON_SOCKET" | wc -c` -ge 108 ]
then
# Mark the test as skipped even though we already did some work so
# that the remainder is not silently skipped.
exit 77
fi
guix-daemon --disable-chroot &
subdaemon_pid=$!
exit_hook="kill $subdaemon_pid"
final_name="$storedir/`basename $to_copy`"
# At this point the copy in $new_store must be valid, and unreferenced.
# The database under $NIX_DB_DIR uses the $final_name, but we can't use
# that name in a 'valid-path?' query because 'assertStorePath' would kill
# us because of the wrong prefix. So we just list dead paths instead.
guile -c "
(use-modules (guix store) (srfi srfi-1) (srfi srfi-34))
(define s
(let loop ((i 5))
(guard (c ((nix-connection-error? c)
(if (<= i 0)
(raise c)
(begin
(display \"waiting for daemon socket...\")
(newline)
(sleep 1)
(loop (- i 1))))))
(open-connection \"$GUIX_DAEMON_SOCKET\"))))
(exit (lset= string=?
(pk 1 (list \"$copied\" \"$copied_duplicate1\"
\"$copied_duplicate2\"))
(pk 2 (dead-paths s))))"
# Kill the daemon so we can access the database below (otherwise we may
# get "database is locked" errors.)
kill $subdaemon_pid
exit_hook=":"
while kill -0 $subdaemon_pid ; do sleep 0.5 ; done
# When 'sqlite3' is available, check the name in the database.
if type -P sqlite3
then
echo "select * from ValidPaths where path=\"$final_name\";" | \
sqlite3 "$NIX_DB_DIR/db.sqlite"
fi
done