code:
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2016 David Craven <david@craven.ch>
;;;
;;; 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 (guix build qt-utils)
  #:use-module (guix build utils)
  #:export (wrap-qt-program))

(define (wrap-qt-program out program)
  (define (suffix env-var path)
    (let ((env-val (getenv env-var)))
      (if env-val (string-append env-val ":" path) path)))

  (let ((qml-path        (suffix "QML2_IMPORT_PATH"
                                 (string-append out "/qml")))
        (plugin-path     (suffix "QT_PLUGIN_PATH"
                                 (string-append out "/plugins")))
        (xdg-data-path   (suffix "XDG_DATA_DIRS"
                                 (string-append out "/share")))
        (xdg-config-path (suffix "XDG_CONFIG_DIRS"
                                 (string-append out "/etc/xdg"))))
    (wrap-program (string-append out "/bin/" program)
      `("QML2_IMPORT_PATH" = (,qml-path))
      `("QT_PLUGIN_PATH" = (,plugin-path))
      `("XDG_DATA_DIRS" = (,xdg-data-path))
      `("XDG_CONFIG_DIRS" = (,xdg-config-path)))))


code:
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2015, 2017, 2018 Ricardo Wurmus <rekado@elephly.net>
;;;
;;; 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 (guix build r-build-system)
  #:use-module ((guix build gnu-build-system) #:prefix gnu:)
  #:use-module (guix build utils)
  #:use-module (ice-9 match)
  #:use-module (ice-9 ftw)
  #:use-module (ice-9 popen)
  #:use-module (srfi srfi-1)
  #:use-module (srfi srfi-26)
  #:use-module (srfi srfi-35)
  #:export (%standard-phases
            r-build))

;; Commentary:
;;
;; Builder-side code of the standard build procedure for R packages.
;;
;; Code:

(define (invoke-r command params)
  (apply invoke "R" "CMD" command params))

(define (pipe-to-r command params)
  (let ((port (apply open-pipe* OPEN_WRITE "R" params)))
    (display command port)
    (let ((code (status:exit-val (close-pipe port))))
      (unless (zero? code)
        (raise (condition ((@@ (guix build utils) &invoke-error)
                           (program "R")
                           (arguments (string-append params " " command))
                           (exit-status (status:exit-val code))
                           (term-signal (status:term-sig code))
                           (stop-signal (status:stop-sig code)))))))))

(define (generate-site-path inputs)
  (string-join (map (match-lambda
                      ((_ . path)
                       (string-append path "/site-library")))
                    ;; Restrict to inputs beginning with "r-".
                    (filter (match-lambda
                              ((name . _)
                               (string-prefix? "r-" name)))
                            inputs))
               ":"))

(define* (check #:key test-target inputs outputs tests? #:allow-other-keys)
  "Run the test suite of a given R package."
  (let* ((libdir    (string-append (assoc-ref outputs "out") "/site-library/"))

         ;; R package names are case-sensitive and cannot be derived from the
         ;; Guix package name.  The exact package name is required as an
         ;; argument to ‘tools::testInstalledPackage’, which runs the tests
         ;; for a package given its name and the path to the “library” (a
         ;; location for a collection of R packages) containing it.

         ;; Since there can only be one R package in any collection (=
         ;; “library”), the name of the only directory in the collection path
         ;; is the original name of the R package.
         (pkg-name  (car (scandir libdir (negate (cut member <> '("." ".."))))))
         (testdir   (string-append libdir pkg-name "/" test-target))
         (site-path (string-append libdir ":" (generate-site-path inputs))))
    (when (and tests? (file-exists? testdir))
      (setenv "R_LIBS_SITE" site-path)
      (pipe-to-r (string-append "tools::testInstalledPackage(\"" pkg-name "\", "
                                "lib.loc = \"" libdir "\")")
                 '("--no-save" "--slave")))
    #t))

(define* (install #:key outputs inputs (configure-flags '())
                  #:allow-other-keys)
  "Install a given R package."
  (let* ((out          (assoc-ref outputs "out"))
         (site-library (string-append out "/site-library/"))
         (params       (append configure-flags
                               (list "--install-tests"
                                     (string-append "--library=" site-library)
                                     "--built-timestamp=1970-01-01"
                                     ".")))
         (site-path    (string-append site-library ":"
                                      (generate-site-path inputs))))
    ;; If dependencies cannot be found at install time, R will refuse to
    ;; install the package.
    (setenv "R_LIBS_SITE" site-path)
    ;; Some R packages contain a configure script for which the CONFIG_SHELL
    ;; variable should be set.
    (setenv "CONFIG_SHELL" (which "bash"))
    (mkdir-p site-library)
    (invoke-r "INSTALL" params)))

(define %standard-phases
  (modify-phases gnu:%standard-phases
    (delete 'bootstrap)
    (delete 'configure)
    (delete 'build)
    (delete 'check) ; tests must be run after installation
    (replace 'install install)
    (add-after 'install 'check check)))

(define* (r-build #:key inputs (phases %standard-phases)
                       #:allow-other-keys #:rest args)
  "Build the given R package, applying all of PHASES in order."
  (apply gnu:gnu-build #:inputs inputs #:phases phases args))

;;; r-build-system.scm ends here

license: mit


code:
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2013 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/>.

(define-module (guix build rpath)
  #:use-module (ice-9 popen)
  #:use-module (ice-9 rdelim)
  #:export (%patchelf
            file-rpath
            augment-rpath))

;;; Commentary:
;;;
;;; Tools to manipulate the RPATH and RUNPATH of ELF binaries.  Currently they
;;; rely on PatchELF.
;;;
;;; Code:

(define %patchelf
  ;; The `patchelf' command.
  (make-parameter "patchelf"))

(define %not-colon
  (char-set-complement (char-set #\:)))

(define (file-rpath file)
  "Return the RPATH (or RUNPATH) of FILE as a list of directory names, or #f
on failure."
  (let* ((p (open-pipe* OPEN_READ (%patchelf) "--print-rpath" file))
         (l (read-line p)))
    (and (zero? (close-pipe p))
         (string-tokenize l %not-colon))))

(define (augment-rpath file dir)
  "Add DIR to the front of the RPATH and RUNPATH of FILE.  Return the new
RPATH as a list, or #f on failure."
  (let* ((rpath  (or (file-rpath file) '()))
         (rpath* (cons dir rpath)))
    (format #t "~a: changing RPATH from ~s to ~s~%"
            file rpath rpath*)
    (and (zero? (system* (%patchelf) "--set-rpath"
                         (string-join rpath* ":") file))
         rpath*)))

;;; rpath.scm ends here


code:
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2015 David Thompson <davet@gnu.org>
;;; Copyright © 2015 Pjotr Prins <pjotr.public01@thebird.nl>
;;; Copyright © 2015, 2016 Ben Woodcroft <donttrustben@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 (guix build ruby-build-system)
  #:use-module ((guix build gnu-build-system) #:prefix gnu:)
  #:use-module (guix build utils)
  #:use-module (ice-9 ftw)
  #:use-module (ice-9 match)
  #:use-module (ice-9 popen)
  #:use-module (ice-9 rdelim)
  #:use-module (ice-9 regex)
  #:use-module (srfi srfi-1)
  #:use-module (srfi srfi-26)
  #:export (%standard-phases
            ruby-build))

;; Commentary:
;;
;; Builder-side code of the standard Ruby package build procedure.
;;
;; Code:

(define (first-matching-file pattern)
  "Return the first file name that matches PATTERN in the current working
directory."
  (match (find-files "." pattern)
    ((file-name . _) file-name)
    (() (error "No files matching pattern: " pattern))))

(define gnu:unpack (assq-ref gnu:%standard-phases 'unpack))

(define (gem-archive? file-name)
  (string-match "^.*\\.gem$" file-name))

(define* (unpack #:key source #:allow-other-keys)
  "Unpack the gem SOURCE and enter the resulting directory."
  (if (gem-archive? source)
      (begin
        (invoke "gem" "unpack" source)
        ;; The unpacked gem directory is named the same as the archive,
        ;; sans the ".gem" extension.  It is renamed to simply "gem" in an
        ;; effort to keep file names shorter to avoid UNIX-domain socket
        ;; file names and shebangs that exceed the system's fixed maximum
        ;; length when running test suites.
        (let ((dir (match:substring (string-match "^(.*)\\.gem$"
                                                  (basename source))
                                    1)))
          (rename-file dir "gem")
          (chdir "gem"))
        #t)
      ;; Use GNU unpack strategy for things that aren't gem archives.
      (gnu:unpack #:source source)))

(define (first-gemspec)
  (first-matching-file "\\.gemspec$"))

(define* (replace-git-ls-files #:key source #:allow-other-keys)
  "Many gemspec files downloaded from outside rubygems.org use `git ls-files`
to list of the files to be included in the built gem.  However, since this
operation is not deterministic, we replace it with `find`."
  (when (not (gem-archive? source))
    (let ((gemspec (first-gemspec)))
      (substitute* gemspec
        (("`git ls-files`") "`find . -type f |sort`")
        (("`git ls-files -z`") "`find . -type f -print0 |sort -z`"))))
  #t)

(define* (extract-gemspec #:key source #:allow-other-keys)
  "Remove the original gemspec, if present, and replace it with a new one.
This avoids issues with upstream gemspecs requiring tools such as git to
generate the files list."
  (when (gem-archive? source)
    (let ((gemspec (or (false-if-exception (first-gemspec))
                       ;; Make new gemspec if one wasn't shipped.
                       ".gemspec")))

      (when (file-exists? gemspec) (delete-file gemspec))

      ;; Extract gemspec from source gem.
      (let ((pipe (open-pipe* OPEN_READ "gem" "spec" "--ruby" source)))
        (dynamic-wind
          (const #t)
          (lambda ()
            (call-with-output-file gemspec
              (lambda (out)
                ;; 'gem spec' writes to stdout, but 'gem build' only reads
                ;; gemspecs from a file, so we redirect the output to a file.
                (while (not (eof-object? (peek-char pipe)))
                  (write-char (read-char pipe) out))))
            #t)
          (lambda ()
            (close-pipe pipe)))))
    #t))

(define* (build #:key source #:allow-other-keys)
  "Build a new gem using the gemspec from the SOURCE gem."

  ;; Build a new gem from the current working directory.  This also allows any
  ;; dynamic patching done in previous phases to be present in the installed
  ;; gem.
  (invoke "gem" "build" (first-gemspec)))

(define* (check #:key tests? test-target #:allow-other-keys)
  "Run the gem's test suite rake task TEST-TARGET.  Skip the tests if TESTS?
is #f."
  (if tests?
      (invoke "rake" test-target)
      #t))

(define* (install #:key inputs outputs (gem-flags '())
                  #:allow-other-keys)
  "Install the gem archive SOURCE to the output store item.  Additional
GEM-FLAGS are passed to the 'gem' invokation, if present."
  (let* ((ruby-version
          (match:substring (string-match "ruby-(.*)\\.[0-9]$"
                                         (assoc-ref inputs "ruby"))
                           1))
         (out (assoc-ref outputs "out"))
         (vendor-dir (string-append out "/lib/ruby/vendor_ruby"))
         (gem-file (first-matching-file "\\.gem$"))
         (gem-file-basename (basename gem-file))
         (gem-name (substring gem-file-basename
                              0
                              (- (string-length gem-file-basename) 4))))
    (setenv "GEM_VENDOR" vendor-dir)

    (or (zero?
         (apply system* "gem" "install" gem-file
                "--local" "--ignore-dependencies" "--vendor"
                ;; Executables should go into /bin, not
                ;; /lib/ruby/gems.
                "--bindir" (string-append out "/bin")
                gem-flags))
        (begin
          (let ((failed-output-dir (string-append (getcwd) "/out")))
            (mkdir failed-output-dir)
            (copy-recursively out failed-output-dir))
          (error "installation failed")))

    ;; Remove the cached gem file as this is unnecessary and contains
    ;; timestamped files rendering builds not reproducible.
    (let ((cached-gem (string-append vendor-dir "/cache/" gem-file)))
      (log-file-deletion cached-gem)
      (delete-file cached-gem))

    ;; For gems with native extensions, several Makefile-related files
    ;; are created that contain timestamps or other elements making
    ;; them not reproducible.  They are unnecessary so we remove them.
    (when (file-exists? (string-append vendor-dir "/ext"))
      (for-each (lambda (file)
                  (log-file-deletion file)
                  (delete-file file))
                (append
                 (find-files (string-append vendor-dir "/doc")
                             "page-Makefile.ri")
                 (find-files (string-append vendor-dir "/extensions")
                             "gem_make.out")
                 (find-files (string-append vendor-dir "/ext")
                             "Makefile"))))

    #t))

(define* (wrap-ruby-program prog #:key (gem-clear-paths #t) #:rest vars)
  "Make a wrapper for PROG.  VARS should look like this:

  '(VARIABLE DELIMITER POSITION LIST-OF-DIRECTORIES)

where DELIMITER is optional.  ':' will be used if DELIMITER is not given.

For example, this command:

  (wrap-ruby-program \"foo\"
                '(\"PATH\" \":\" = (\"/gnu/.../bar/bin\"))
                '(\"CERT_PATH\" suffix (\"/gnu/.../baz/certs\"
                                        \"/qux/certs\")))

will copy 'foo' to '.real/fool' and create the file 'foo' with the following
contents:

  #!location/of/bin/ruby
  ENV['PATH'] = \"/gnu/.../bar/bin\"
  ENV['CERT_PATH'] = (ENV.key?('CERT_PATH') ? (ENV['CERT_PATH'] + ':') : '') + '/gnu/.../baz/certs:/qux/certs'
  load location/of/.real/foo

This is useful for scripts that expect particular programs to be in $PATH, for
programs that expect particular gems to be in the GEM_PATH.

This is preferable to wrap-program, which uses a bash script, as this prevents
ruby scripts from being executed with @command{ruby -S ...}.

If PROG has previously been wrapped by 'wrap-ruby-program', the wrapper is
extended with definitions for VARS."
  (define wrapped-file
    (string-append (dirname prog) "/.real/" (basename prog)))

  (define already-wrapped?
    (file-exists? wrapped-file))

  (define (last-line port)
    ;; Return the last line read from PORT and leave PORT's cursor right
    ;; before it.
    (let loop ((previous-line-offset 0)
               (previous-line "")
               (position (seek port 0 SEEK_CUR)))
      (match (read-line port 'concat)
        ((? eof-object?)
         (seek port previous-line-offset SEEK_SET)
         previous-line)
        ((? string? line)
         (loop position line (+ (string-length line) position))))))

  (define (export-variable lst)
    ;; Return a string that exports an environment variable.
    (match lst
      ((var sep '= rest)
       (format #f "ENV['~a'] = '~a'"
               var (string-join rest sep)))
      ((var sep 'prefix rest)
       (format #f "ENV['~a'] = '~a' + (ENV.key?('~a') ? ('~a' + ENV['~a']) : '')"
               var (string-join rest sep) var sep var))
      ((var sep 'suffix rest)
       (format #f "ENV['~a'] = (ENV.key?('~a') ? (ENV['~a'] + '~a') : '') + '~a'"
               var var var sep (string-join rest sep)))
      ((var '= rest)
       (format #f "ENV['~a'] = '~a'"
               var (string-join rest ":")))
      ((var 'prefix rest)
       (format #f "ENV['~a'] = '~a' + (ENV.key?('~a') ? (':' + ENV['~a']) : '')"
               var (string-join rest ":") var var))
      ((var 'suffix rest)
       (format #f "ENV['~a'] = (ENV.key?('~a') ? (ENV['~a'] + ':') : '') + '~a'"
               var var var (string-join rest ":")))))

  (if already-wrapped?

      ;; PROG is already a wrapper: add the new "export VAR=VALUE" lines just
      ;; before the last line.
      (let* ((port (open-file prog "r+"))
             (last (last-line port)))
        (for-each (lambda (var)
                    (display (export-variable var) port)
                    (newline port))
                  vars)
        (display last port)
        (close-port port))

      ;; PROG is not wrapped yet: create a shell script that sets VARS.
      (let ((prog-tmp (string-append wrapped-file "-tmp")))
        (mkdir-p (dirname prog-tmp))
        (link prog wrapped-file)

        (call-with-output-file prog-tmp
          (lambda (port)
            (format port
                    "#!~a~%~a~%~a~%load '~a'~%"
                    (which "ruby")
                    (string-join (map export-variable vars) "\n")
                    ;; This ensures that if the GEM_PATH has been changed,
                    ;; then that change will be noticed.
                    (if gem-clear-paths "Gem.clear_paths" "")
                    (canonicalize-path wrapped-file))))

        (chmod prog-tmp #o755)
        (rename-file prog-tmp prog))))

(define* (wrap #:key inputs outputs #:allow-other-keys)
  (define (list-of-files dir)
    (map (cut string-append dir "/" <>)
         (or (scandir dir (lambda (f)
                            (let ((s (stat (string-append dir "/" f))))
                              (eq? 'regular (stat:type s)))))
             '())))

  (define bindirs
    (append-map (match-lambda
                 ((_ . dir)
                  (list (string-append dir "/bin")
                        (string-append dir "/sbin"))))
                outputs))

  (let* ((out  (assoc-ref outputs "out"))
         (var `("GEM_PATH" prefix
                (,(string-append out "/lib/ruby/vendor_ruby")
                 ,(getenv "GEM_PATH")))))
    (for-each (lambda (dir)
                (let ((files (list-of-files dir)))
                  (for-each (cut wrap-ruby-program <> var)
                            files)))
              bindirs))
  #t)

(define (log-file-deletion file)
  (display (string-append "deleting '" file "' for reproducibility\n")))

(define %standard-phases
  (modify-phases gnu:%standard-phases
    (delete 'bootstrap)
    (delete 'configure)
    (replace 'unpack unpack)
    (add-before 'build 'extract-gemspec extract-gemspec)
    (add-after 'extract-gemspec 'replace-git-ls-files replace-git-ls-files)
    (replace 'build build)
    (replace 'check check)
    (replace 'install install)
    (add-after 'install 'wrap wrap)))

(define* (ruby-build #:key inputs (phases %standard-phases)
                     #:allow-other-keys #:rest args)
  (apply gnu:gnu-build #:inputs inputs #:phases phases args))


code:
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2017 Arun Isaac <arunisaac@systemreboot.net>
;;; Copyright © 2018 Mark H Weaver <mhw@netris.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/>.

(define-module (guix build scons-build-system)
  #:use-module ((guix build gnu-build-system) #:prefix gnu:)
  #:use-module (guix build utils)
  #:export (%standard-phases
            scons-build))

;; Commentary:
;;
;; Builder-side code of the SCons build system.
;;
;; Code:

(define* (build #:key outputs (scons-flags '()) (parallel-build? #t) #:allow-other-keys)
  (let ((out (assoc-ref outputs "out")))
    (mkdir-p out)
    (apply invoke "scons"
           (append (if parallel-build?
                       (list "-j" (number->string
                                   (parallel-job-count)))
                       (list))
                   scons-flags))))

(define* (check #:key tests? test-target (scons-flags '()) #:allow-other-keys)
  "Run the test suite of a given SCons application."
  (if tests?
      (apply invoke "scons" test-target scons-flags)
      (format #t "test suite not run~%"))
  #t)

(define* (install #:key outputs (scons-flags '()) #:allow-other-keys)
  "Install a given SCons application."
  (apply invoke "scons" "install" scons-flags))

(define %standard-phases
  (modify-phases gnu:%standard-phases
    (delete 'bootstrap)
    (delete 'configure)
    (replace 'build build)
    (replace 'check check)
    (replace 'install install)))

(define* (scons-build #:key inputs (phases %standard-phases)
                       #:allow-other-keys #:rest args)
  "Build a given SCons application, applying all of PHASES in order."
  (apply gnu:gnu-build #:inputs inputs #:phases phases args))

;;; scons-build-system.scm ends here


code:
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2013, 2014, 2017, 2018 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/>.

(define-module (guix build store-copy)
  #:use-module (guix build utils)
  #:use-module (guix sets)
  #:use-module (guix progress)
  #:use-module (srfi srfi-1)
  #:use-module (srfi srfi-9)
  #:use-module (srfi srfi-26)
  #:use-module (ice-9 match)
  #:use-module (ice-9 rdelim)
  #:use-module (ice-9 ftw)
  #:use-module (ice-9 vlist)
  #:export (store-info?
            store-info
            store-info-item
            store-info-deriver
            store-info-references

            read-reference-graph

            closure-size
            populate-store))

;;; Commentary:
;;;
;;; This module provides the tools to copy store items and their dependencies
;;; to another store.  It relies on the availability of "reference graph"
;;; files as produced by 'gexp->derivation' et al. with the
;;; #:references-graphs parameter.
;;;
;;; Code:

;; Information about a store item as produced by #:references-graphs.
(define-record-type <store-info>
  (store-info item deriver references)
  store-info?
  (item        store-info-item)                   ;string
  (deriver     store-info-deriver)                ;#f | string
  (references  store-info-references))            ;?

;; TODO: Factorize with that in (guix store).
(define (topological-sort nodes edges)
  "Return NODES in topological order according to EDGES.  EDGES must be a
one-argument procedure that takes a node and returns the nodes it is connected
to."
  (define (traverse)
    ;; Do a simple depth-first traversal of all of PATHS.
    (let loop ((nodes nodes)
               (visited (setq))
               (result '()))
      (match nodes
        ((head tail ...)
         (if (set-contains? visited head)
             (loop tail visited result)
             (call-with-values
                 (lambda ()
                   (loop (edges head)
                         (set-insert head visited)
                         result))
               (lambda (visited result)
                 (loop tail visited (cons head result))))))
        (()
         (values visited result)))))

  (call-with-values traverse
    (lambda (_ result)
      (reverse result))))

(define (read-reference-graph port)
  "Read the reference graph as produced by #:references-graphs from PORT and
return it as a list of <store-info> records in topological order--i.e., leaves
come first.  IOW, store items in the resulting list can be registered in the
order in which they appear.

The reference graph format consists of sequences of lines like this:

     FILE
     DERIVER
     NUMBER-OF-REFERENCES
     REF1
     ...
     REFN

It is meant as an internal format."
  (let loop ((result '())
             (table vlist-null)
             (referrers vlist-null))
    (match (read-line port)
      ((? eof-object?)
       ;; 'guix-daemon' gives us something that's in "reverse topological
       ;; order"--i.e., leaves (items with zero references) come last.  Here
       ;; we compute the topological order that we want: leaves come first.
       (let ((unreferenced? (lambda (item)
                              (let ((referrers (vhash-fold* cons '()
                                                            (store-info-item item)
                                                            referrers)))
                                (or (null? referrers)
                                    (equal? (list item) referrers))))))
         (topological-sort (filter unreferenced? result)
                           (lambda (item)
                             (map (lambda (item)
                                    (match (vhash-assoc item table)
                                      ((_ . node) node)))
                                  (store-info-references item))))))
      (item
       (let* ((deriver (match (read-line port)
                         ("" #f)
                         (line line)))
              (count   (string->number (read-line port)))
              (refs    (unfold-right (cut >= <> count)
                                     (lambda (n)
                                       (read-line port))
                                     1+
                                     0))
              (item    (store-info item deriver refs)))
         (loop (cons item result)
               (vhash-cons (store-info-item item) item table)
               (fold (cut vhash-cons <> item <>)
                     referrers
                     refs)))))))

(define (file-size file)
  "Return the size of bytes of FILE, entering it if FILE is a directory."
  (file-system-fold (const #t)
                    (lambda (file stat result)    ;leaf
                      (+ (stat:size stat) result))
                    (lambda (directory stat result) ;down
                      (+ (stat:size stat) result))
                    (lambda (directory stat result) ;up
                      result)
                    (lambda (file stat result)    ;skip
                      result)
                    (lambda (file stat errno result)
                      (format (current-error-port)
                              "file-size: ~a: ~a~%" file
                              (strerror errno))
                      result)
                    0
                    file
                    lstat))

(define (closure-size reference-graphs)
  "Return an estimate of the size of the closure described by
REFERENCE-GRAPHS, a list of reference-graph files."
  (define (graph-from-file file)
    (map store-info-item
         (call-with-input-file file read-reference-graph)))

  (define items
    (delete-duplicates (append-map graph-from-file reference-graphs)))

  (reduce + 0 (map file-size items)))

(define* (populate-store reference-graphs target
                         #:key (log-port (current-error-port)))
  "Populate the store under directory TARGET with the items specified in
REFERENCE-GRAPHS, a list of reference-graph files."
  (define store
    (string-append target (%store-directory)))

  (define (things-to-copy)
    ;; Return the list of store files to copy to the image.
    (define (graph-from-file file)
      (map store-info-item
           (call-with-input-file file read-reference-graph)))

    (delete-duplicates (append-map graph-from-file reference-graphs)))

  (mkdir-p store)
  (chmod store #o1775)

  (let* ((things   (things-to-copy))
         (len      (length things))
         (progress (progress-reporter/bar len
                                          (format #f "copying ~a store items"
                                                  len)
                                          log-port)))
    (call-with-progress-reporter progress
      (lambda (report)
        (for-each (lambda (thing)
                    (copy-recursively thing
                                      (string-append target thing)
                                      #:log (%make-void-port "w"))
                    (report))
                  things)))))

;;; store-copy.scm ends here


code:
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2014 Ludovic Courtès <ludo@gnu.org>
;;; Copyright © 2014 Sree Harsha Totakura <sreeharsha@totakura.in>
;;; Copyright © 2018 Mark H Weaver <mhw@netris.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/>.

(define-module (guix build svn)
  #:use-module (guix build utils)
  #:export (svn-fetch))

;;; Commentary:
;;;
;;; This is the build-side support code of (guix svn-download).  It allows a
;;; Subversion repository to be cloned and checked out at a specific revision.
;;;
;;; Code:

(define* (svn-fetch url revision directory
                    #:key (svn-command "svn")
                    (user-name #f)
                    (password #f))
  "Fetch REVISION from URL into DIRECTORY.  REVISION must be an integer, and a
valid Subversion revision.  Return #t on success, #f otherwise."
  (apply invoke svn-command
         "checkout" "--non-interactive"
         ;; Trust the server certificate.  This is OK as we
         ;; verify the checksum later.  This can be removed when
         ;; ca-certificates package is added.
         "--trust-server-cert" "-r" (number->string revision)
         `(,@(if (and user-name password)
                 (list (string-append "--username=" user-name)
                       (string-append "--password=" password))
                 '())
           ,url ,directory))

  ;; The contents of '.svn' vary as a function of the current status
  ;; of the repo.  Since we want a fixed output, this directory needs
  ;; to be taken out.
  (with-directory-excursion directory
    (delete-file-recursively ".svn"))

  #t)

;;; svn.scm ends here