1067 lines
43 KiB
Scheme
1067 lines
43 KiB
Scheme
;;; GNU Guix --- Functional package management for GNU
|
||
;;; Copyright © 2010-2023 Ludovic Courtès <ludo@gnu.org>
|
||
;;; Copyright © 2012, 2013 Nikita Karetnikov <nikita@karetnikov.org>
|
||
;;; Copyright © 2021 Simon Tournier <zimon.toutoune@gmail.com>
|
||
;;; Copyright © 2022 Maxime Devos <maximedevos@telenet.be>
|
||
;;; Copyright © 2023 Maxim Cournoyer <maxim.cournoyer@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 gnu-maintenance)
|
||
#:use-module (web uri)
|
||
#:use-module (web client)
|
||
#:use-module (web response)
|
||
#:use-module (ice-9 regex)
|
||
#:use-module (ice-9 match)
|
||
#:use-module (srfi srfi-1)
|
||
#:use-module (srfi srfi-2)
|
||
#:use-module (srfi srfi-11)
|
||
#:use-module (srfi srfi-26)
|
||
#:use-module (rnrs io ports)
|
||
#:use-module ((guix http-client) #:hide (open-socket-for-uri))
|
||
;; not required in many cases, so autoloaded to reduce start-up costs.
|
||
#:autoload (guix download) (%mirrors)
|
||
#:use-module (guix ftp-client)
|
||
#:use-module (guix utils)
|
||
#:use-module (guix diagnostics)
|
||
#:use-module (guix i18n)
|
||
#:use-module (guix memoization)
|
||
#:use-module (guix records)
|
||
#:use-module (guix upstream)
|
||
#:use-module (guix packages)
|
||
#:autoload (guix import utils) (false-if-networking-error)
|
||
#:autoload (zlib) (call-with-gzip-input-port)
|
||
#:autoload (htmlprag) (html->sxml) ;from Guile-Lib
|
||
#:export (gnu-package-name
|
||
gnu-package-mundane-name
|
||
gnu-package-copyright-holder
|
||
gnu-package-savannah
|
||
gnu-package-fsd
|
||
gnu-package-language
|
||
gnu-package-logo
|
||
gnu-package-doc-category
|
||
gnu-package-doc-summary
|
||
gnu-package-doc-description
|
||
gnu-package-doc-urls
|
||
gnu-package-download-url
|
||
|
||
official-gnu-packages
|
||
find-package
|
||
gnu-package?
|
||
|
||
uri-mirror-rewrite
|
||
rewrite-url
|
||
|
||
release-file?
|
||
releases
|
||
import-release
|
||
gnu-release-archive-types
|
||
gnu-package-name->name+version
|
||
|
||
%gnu-updater
|
||
%gnu-ftp-updater
|
||
%savannah-updater
|
||
%sourceforge-updater
|
||
%xorg-updater
|
||
%kernel.org-updater
|
||
%generic-html-updater))
|
||
|
||
;;; Commentary:
|
||
;;;
|
||
;;; Code for dealing with the maintenance of GNU packages, such as
|
||
;;; auto-updates.
|
||
;;;
|
||
;;; Code:
|
||
|
||
|
||
;;;
|
||
;;; List of GNU packages.
|
||
;;;
|
||
|
||
(define %gnumaint-base-url
|
||
"https://web.cvs.savannah.gnu.org/viewvc/*checkout*/www/www/prep/gnumaint/")
|
||
|
||
(define %package-list-url
|
||
(string->uri
|
||
(string-append %gnumaint-base-url "rec/gnupackages.rec")))
|
||
|
||
(define %package-description-url
|
||
;; This file contains package descriptions in recutils format.
|
||
;; See <https://lists.gnu.org/archive/html/guix-devel/2013-10/msg00071.html>
|
||
;; and <https://lists.gnu.org/archive/html/guix-devel/2018-06/msg00362.html>.
|
||
(string->uri
|
||
(string-append %gnumaint-base-url "rec/pkgblurbs.rec")))
|
||
|
||
(define-record-type* <gnu-package-descriptor>
|
||
gnu-package-descriptor
|
||
make-gnu-package-descriptor
|
||
|
||
gnu-package-descriptor?
|
||
|
||
(name gnu-package-name)
|
||
(mundane-name gnu-package-mundane-name)
|
||
(copyright-holder gnu-package-copyright-holder)
|
||
(savannah gnu-package-savannah)
|
||
(fsd gnu-package-fsd)
|
||
(language gnu-package-language) ; list of strings
|
||
(logo gnu-package-logo)
|
||
(doc-category gnu-package-doc-category)
|
||
(doc-summary gnu-package-doc-summary)
|
||
(doc-description gnu-package-doc-description) ; taken from 'pkgdescr.txt'
|
||
(doc-urls gnu-package-doc-urls) ; list of strings
|
||
(download-url gnu-package-download-url))
|
||
|
||
(define* (official-gnu-packages
|
||
#:optional (fetch http-fetch/cached))
|
||
"Return a list of records, which are GNU packages. Use FETCH,
|
||
to fetch the list of GNU packages over HTTP."
|
||
(define (read-records port)
|
||
;; Return a list of alists. Each alist contains fields of a GNU
|
||
;; package.
|
||
(let loop ((alist (recutils->alist port))
|
||
(result '()))
|
||
(if (null? alist)
|
||
(reverse result)
|
||
(loop (recutils->alist port)
|
||
|
||
;; Ignore things like "%rec" (info "(recutils) Record
|
||
;; Descriptors").
|
||
(if (assoc-ref alist "package")
|
||
(cons alist result)
|
||
result)))))
|
||
|
||
(define official-description
|
||
(let ((db (read-records (fetch %package-description-url #:text? #t))))
|
||
(lambda (name)
|
||
;; Return the description found upstream for package NAME, or #f.
|
||
(and=> (find (lambda (alist)
|
||
(equal? name (assoc-ref alist "package")))
|
||
db)
|
||
(lambda (record)
|
||
(let ((field (assoc-ref record "blurb")))
|
||
;; The upstream description file uses "redirect PACKAGE" as
|
||
;; a blurb in cases where the description of the two
|
||
;; packages should be considered the same (e.g., GTK+ has
|
||
;; "redirect gnome".) This is usually not acceptable for
|
||
;; us because we prefer to have distinct descriptions in
|
||
;; such cases. Thus, ignore the 'blurb' field when that
|
||
;; happens.
|
||
(and field
|
||
(not (string-prefix? "redirect " field))
|
||
field)))))))
|
||
|
||
(map (lambda (alist)
|
||
(let ((name (assoc-ref alist "package")))
|
||
(alist->record `(("description" . ,(official-description name))
|
||
,@alist)
|
||
make-gnu-package-descriptor
|
||
(list "package" "mundane_name" "copyright_holder"
|
||
"savannah" "fsd" "language" "logo"
|
||
"doc_category" "doc_summary" "description"
|
||
"doc_url"
|
||
"download_url")
|
||
'("doc_url" "language"))))
|
||
(let* ((port (fetch %package-list-url #:text? #t))
|
||
(lst (read-records port)))
|
||
(close-port port)
|
||
lst)))
|
||
|
||
(define (find-package name)
|
||
"Find GNU package called NAME and return it. Return #f if it was not
|
||
found."
|
||
(find (lambda (package)
|
||
(string=? name (gnu-package-name package)))
|
||
(official-gnu-packages)))
|
||
|
||
(define gnu-package?
|
||
(let ((official-gnu-packages (memoize official-gnu-packages)))
|
||
(mlambdaq (package)
|
||
"Return true if PACKAGE is a GNU package. This procedure may access the
|
||
network to check in GNU's database."
|
||
(define (mirror-type url)
|
||
(let ((uri (string->uri url)))
|
||
(and (eq? (uri-scheme uri) 'mirror)
|
||
(cond
|
||
((member (uri-host uri)
|
||
'("gnu" "gnupg" "gcc" "gnome"))
|
||
;; Definitely GNU.
|
||
'gnu)
|
||
((equal? (uri-host uri) "cran")
|
||
;; Possibly GNU: mirror://cran could be either GNU R itself
|
||
;; or a non-GNU package.
|
||
#f)
|
||
(else
|
||
;; Definitely non-GNU.
|
||
'non-gnu)))))
|
||
|
||
(define (gnu-home-page? package)
|
||
(letrec-syntax ((>> (syntax-rules ()
|
||
((_ value proc)
|
||
(and=> value proc))
|
||
((_ value proc rest ...)
|
||
(and=> value
|
||
(lambda (next)
|
||
(>> (proc next) rest ...)))))))
|
||
(>> package package-home-page
|
||
string->uri uri-host
|
||
(lambda (host)
|
||
(member host '("www.gnu.org" "gnu.org"))))))
|
||
|
||
(or (gnu-home-page? package)
|
||
(match (package-source package)
|
||
((? origin? origin)
|
||
(let ((url (origin-uri origin))
|
||
(name (package-upstream-name package)))
|
||
(case (and (string? url) (mirror-type url))
|
||
((gnu) #t)
|
||
((non-gnu) #f)
|
||
(else
|
||
(and (member name (map gnu-package-name (official-gnu-packages)))
|
||
#t)))))
|
||
(_ #f))))))
|
||
|
||
|
||
;;;
|
||
;;; Latest FTP release.
|
||
;;;
|
||
|
||
(define (ftp-server/directory package)
|
||
"Return the FTP server and directory where PACKAGE's tarball are stored."
|
||
(let ((name (package-upstream-name package)))
|
||
(values (or (assoc-ref (package-properties package) 'ftp-server)
|
||
"ftp.gnu.org")
|
||
(or (assoc-ref (package-properties package) 'ftp-directory)
|
||
(string-append "/gnu/" name)))))
|
||
|
||
(define %tarball-rx
|
||
;; The .zip extensions is notably used for freefont-ttf.
|
||
;; The "-src" pattern is for "TeXmacs-1.0.7.9-src.tar.gz".
|
||
;; The "-gnu[0-9]" pattern is for "icecat-38.4.0-gnu1.tar.bz2".
|
||
;; Accept underscores as in "PKG_1.2.tar.gz" for some non-GNU packages.
|
||
;; Accept 'v' or 'V' prefix as in 'PKG-v2.3.tgz'.
|
||
(make-regexp "^([^.]+)[-_][vV]?([0-9]|[^-])+(-(src|[sS]ource|gnu[0-9]))?\\.(tar\\.|tgz|zip$)"))
|
||
|
||
(define %alpha-tarball-rx
|
||
(make-regexp "^.*-.*[0-9](-|~|\\.)?(alpha|beta|rc|RC|cvs|svn|git)-?[0-9\\.]*\\.tar\\."))
|
||
|
||
(define (release-file? project file)
|
||
"Return true if FILE is a release tarball of PROJECT."
|
||
(and (not (member (file-extension file)
|
||
'("sig" "sign" "asc"
|
||
"md5sum" "sha1sum" "sha256sum")))
|
||
(and=> (regexp-exec %tarball-rx file)
|
||
(lambda (match)
|
||
;; Filter out unrelated files, like `guile-www-1.1.1'.
|
||
;; Case-insensitive for things like "TeXmacs" vs. "texmacs".
|
||
;; The "-src" suffix is for "freefont-src-20120503.tar.gz".
|
||
;; The '-everywhere-src' suffix is for Qt modular components.
|
||
(and=> (match:substring match 1)
|
||
(lambda (name)
|
||
(or (string-ci=? name project)
|
||
(string-ci=? name (string-append project "-src"))
|
||
(string-ci=?
|
||
name (string-append project "-everywhere-src"))
|
||
;; For older Qt releases such as version 5.
|
||
(string-ci=?
|
||
name (string-append
|
||
project "-everywhere-opensource-src"))
|
||
;; For Qt Creator.
|
||
(string-ci=?
|
||
name (string-append
|
||
project "-opensource-src")))))))
|
||
(not (regexp-exec %alpha-tarball-rx file))
|
||
(let ((s (tarball-sans-extension file)))
|
||
(regexp-exec %package-name-rx s))))
|
||
|
||
(define (tarball->version tarball)
|
||
"Return the version TARBALL corresponds to. TARBALL is a file name like
|
||
\"coreutils-8.23.tar.xz\"."
|
||
(let-values (((name version)
|
||
(gnu-package-name->name+version
|
||
(tarball-sans-extension tarball))))
|
||
version))
|
||
|
||
(define* (releases project
|
||
#:key
|
||
(server "ftp.gnu.org")
|
||
(directory (string-append "/gnu/" project)))
|
||
"Return the list of <upstream-release> of PROJECT as a list of release
|
||
name/directory pairs."
|
||
;; TODO: Parse something like fencepost.gnu.org:/gd/gnuorg/packages-ftp.
|
||
(define conn (ftp-open server))
|
||
|
||
(let loop ((directories (list directory))
|
||
(result '()))
|
||
(match directories
|
||
(()
|
||
(ftp-close conn)
|
||
(coalesce-sources result))
|
||
((directory rest ...)
|
||
(let* ((files (ftp-list conn directory))
|
||
(subdirs (filter-map (match-lambda
|
||
((name 'directory . _) name)
|
||
(_ #f))
|
||
files)))
|
||
(define (file->url file)
|
||
(string-append "ftp://" server directory "/" file))
|
||
|
||
(define (file->source file)
|
||
(let ((url (file->url file)))
|
||
(upstream-source
|
||
(package project)
|
||
(version (tarball->version file))
|
||
(urls (list url))
|
||
(signature-urls (list (string-append url ".sig"))))))
|
||
|
||
(loop (append (map (cut string-append directory "/" <>)
|
||
subdirs)
|
||
rest)
|
||
(append
|
||
;; Filter out signatures, deltas, and files which
|
||
;; are potentially not releases of PROJECT--e.g.,
|
||
;; in /gnu/guile, filter out guile-oops and
|
||
;; guile-www; in mit-scheme, filter out binaries.
|
||
(filter-map (match-lambda
|
||
((file 'file . _)
|
||
(and (release-file? project file)
|
||
(file->source file)))
|
||
(_ #f))
|
||
files)
|
||
result)))))))
|
||
|
||
(define* (import-ftp-release project
|
||
#:key
|
||
(version #f)
|
||
(server "ftp.gnu.org")
|
||
(directory (string-append "/gnu/" project))
|
||
(file->signature (cut string-append <> ".sig")))
|
||
"Return an <upstream-source> for the latest release of PROJECT on SERVER
|
||
under DIRECTORY, or #f. Optionally include a VERSION string to fetch a specific version.
|
||
|
||
Use FTP-OPEN and FTP-CLOSE to open (resp. close) FTP connections; this can be
|
||
useful to reuse connections.
|
||
|
||
FILE->SIGNATURE must be a procedure; it is passed a source file URL and must
|
||
return the corresponding signature URL, or #f it signatures are unavailable."
|
||
(define (latest a b)
|
||
(if (version>? a b) a b))
|
||
|
||
(define (latest-release a b)
|
||
(if (version>? (upstream-source-version a) (upstream-source-version b))
|
||
a b))
|
||
|
||
(define patch-directory-name?
|
||
;; Return #t for patch directory names such as 'bash-4.2-patches'.
|
||
(cut string-suffix? "patches" <>))
|
||
|
||
(define conn (ftp-open server #:timeout 5))
|
||
|
||
(define (file->url directory file)
|
||
(string-append "ftp://" server directory "/" file))
|
||
|
||
(define (file->source directory file)
|
||
(let ((url (file->url directory file)))
|
||
(upstream-source
|
||
(package project)
|
||
(version (tarball->version file))
|
||
;; uri-mirror-rewrite: Don't turn nice mirror:// URIs into ftp://
|
||
;; URLs during "guix refresh -u".
|
||
(urls (list (uri-mirror-rewrite url)))
|
||
(signature-urls (match (file->signature url)
|
||
(#f #f)
|
||
(sig (list (uri-mirror-rewrite sig))))))))
|
||
|
||
(let loop ((directory directory)
|
||
(result #f))
|
||
(let* ((entries (catch 'ftp-error
|
||
(lambda _ (ftp-list conn directory))
|
||
(const '())))
|
||
|
||
;; Filter out things like /gnupg/patches. Filter out "w32"
|
||
;; directories as found on ftp.gnutls.org.
|
||
(subdirs (filter-map (match-lambda
|
||
(((? patch-directory-name? dir)
|
||
'directory . _)
|
||
#f)
|
||
(("w32" 'directory . _)
|
||
#f)
|
||
(("unstable" 'directory . _)
|
||
;; As seen at ftp.gnupg.org/gcrypt/pinentry.
|
||
#f)
|
||
((directory 'directory . _)
|
||
directory)
|
||
(_ #f))
|
||
entries))
|
||
|
||
;; Whether or not SUBDIRS is empty, compute the latest releases
|
||
;; for the current directory. This is necessary for packages
|
||
;; such as 'sharutils' that have a sub-directory that contains
|
||
;; only an older release.
|
||
(releases (filter-map (match-lambda
|
||
((file 'file . _)
|
||
(and (release-file? project file)
|
||
(file->source directory file)))
|
||
(_ #f))
|
||
entries)))
|
||
|
||
;; Assume that SUBDIRS correspond to versions, and jump into the
|
||
;; one with the highest version number.
|
||
(let* ((release (if version
|
||
(find (lambda (upstream)
|
||
(string=? (upstream-source-version upstream) version))
|
||
(coalesce-sources releases))
|
||
(reduce latest-release #f
|
||
(coalesce-sources releases))))
|
||
(result (if (and result release)
|
||
(latest-release release result)
|
||
(or release result)))
|
||
(target (reduce latest #f subdirs)))
|
||
(if target
|
||
(loop (string-append directory "/" target)
|
||
result)
|
||
(begin
|
||
(ftp-close conn)
|
||
result))))))
|
||
|
||
(define* (import-release package
|
||
#:key
|
||
(version #f)
|
||
(server "ftp.gnu.org")
|
||
(directory (string-append "/gnu/" package)))
|
||
"Return the <upstream-source> for the latest version of PACKAGE or #f.
|
||
PACKAGE must be the canonical name of a GNU package. Optionally include a
|
||
VERSION string to fetch a specific version."
|
||
(import-ftp-release package
|
||
#:version version
|
||
#:server server
|
||
#:directory directory))
|
||
|
||
(define-syntax-rule (false-if-ftp-error exp)
|
||
"Return #f if an FTP error is raise while evaluating EXP; return the result
|
||
of EXP otherwise."
|
||
(catch 'ftp-error
|
||
(lambda ()
|
||
exp)
|
||
(lambda (key port . rest)
|
||
(if (ftp-connection? port)
|
||
(ftp-close port)
|
||
(close-port port))
|
||
#f)))
|
||
|
||
(define* (import-release* package #:key (version #f))
|
||
"Like 'import-release', but (1) take a <package> object, and (2) ignore FTP
|
||
errors that might occur when PACKAGE is not actually a GNU package, or not
|
||
hosted on ftp.gnu.org, or not under that name (this is the case for
|
||
\"emacs-auctex\", for instance.)"
|
||
(let-values (((server directory)
|
||
(ftp-server/directory package)))
|
||
(false-if-ftp-error (import-release (package-upstream-name package)
|
||
#:version version
|
||
#:server server
|
||
#:directory directory))))
|
||
|
||
|
||
;;;
|
||
;;; Latest HTTP release.
|
||
;;;
|
||
|
||
(define (html-links sxml)
|
||
"Return the list of links found in SXML, the SXML tree of an HTML page."
|
||
(let loop ((sxml sxml)
|
||
(links '()))
|
||
(match sxml
|
||
(('a ('@ attributes ...) body ...)
|
||
(match (assq 'href attributes)
|
||
(#f (fold loop links body))
|
||
(('href url) (fold loop (cons url links) body))))
|
||
((tag ('@ _ ...) body ...)
|
||
(fold loop links body))
|
||
((tag body ...)
|
||
(fold loop links body))
|
||
(_
|
||
links))))
|
||
|
||
(define (url->links url)
|
||
"Return the unique links on the HTML page accessible at URL."
|
||
(let* ((uri (string->uri url))
|
||
(port (http-fetch/cached uri #:ttl 3600))
|
||
(sxml (html->sxml port)))
|
||
(close-port port)
|
||
(delete-duplicates (html-links sxml))))
|
||
|
||
(define (canonicalize-url url base-url)
|
||
"Make relative URL absolute, by appending URL to BASE-URL as required. If
|
||
URL is a directory instead of a file, it should be suffixed with a slash (/)."
|
||
(cond ((and=> (string->uri url) uri-scheme)
|
||
;; Fully specified URL.
|
||
url)
|
||
((string-prefix? "//" url)
|
||
;; Full URL lacking a URI scheme. Reuse the URI scheme of the
|
||
;; document that contains the URL.
|
||
(string-append (symbol->string (uri-scheme (string->uri base-url)))
|
||
":" url))
|
||
((string-prefix? "/" url)
|
||
;; Absolute URL.
|
||
(let ((uri (string->uri base-url)))
|
||
(uri->string
|
||
(build-uri (uri-scheme uri)
|
||
#:host (uri-host uri)
|
||
#:port (uri-port uri)
|
||
#:path url))))
|
||
;; URL is relative to BASE-URL, which is assumed to be a directory.
|
||
((string-suffix? "/" base-url)
|
||
(string-append base-url url))
|
||
(else
|
||
;; URL is relative to BASE-URL, which is assumed to denote a file
|
||
;; within a directory.
|
||
(string-append (dirname base-url) "/" url))))
|
||
|
||
(define (strip-trailing-slash s)
|
||
"Strip any trailing slash from S, a string."
|
||
(if (string-suffix? "/" s)
|
||
(string-drop-right s 1)
|
||
s))
|
||
|
||
;;; TODO: Extend to support the RPM and GNOME version schemes?
|
||
(define %version-rx "[0-9.]+")
|
||
|
||
(define* (rewrite-url url version #:key to-version)
|
||
"Rewrite URL so that the URL path components matching the current VERSION or
|
||
VERSION-MAJOR.VERSION-MINOR are updated with that of the latest version found
|
||
by crawling the corresponding URL directories. Alternatively, when TO-VERSION
|
||
is specified, rewrite version matches directly to it without crawling URL.
|
||
|
||
For example, the URL
|
||
\"https://dist.libuv.org/dist/v1.45.0/libuv-v1.45.0.tar.gz\" could be
|
||
rewritten to something like
|
||
\"https://dist.libuv.org/dist/v1.46.0/libuv-v1.46.0.tar.gz\"."
|
||
;; XXX: major-minor may be #f if version is not a triplet but a single
|
||
;; number such as "2".
|
||
(let* ((major-minor (false-if-exception (version-major+minor version)))
|
||
(to-major-minor (false-if-exception
|
||
(and=> to-version version-major+minor)))
|
||
(uri (string->uri url))
|
||
(url-prefix (string-drop-right url (string-length (uri-path uri))))
|
||
(url-prefix-components (string-split url-prefix #\/))
|
||
(path (uri-path uri))
|
||
;; Strip a forward slash on the path to avoid a double slash when
|
||
;; string-joining later.
|
||
(path (if (string-prefix? "/" path)
|
||
(string-drop path 1)
|
||
path))
|
||
(path-components (string-split path #\/)))
|
||
(string-join
|
||
(reverse
|
||
(fold
|
||
(lambda (s parents)
|
||
(if to-version
|
||
;; Direct rewrite case; the archive is assumed to exist.
|
||
(let ((u (string-replace-substring s version to-version)))
|
||
(cons (if (and major-minor to-major-minor)
|
||
(string-replace-substring u major-minor to-major-minor)
|
||
u)
|
||
parents))
|
||
;; More involved HTML crawl case.
|
||
(let* ((pattern (if major-minor
|
||
(format #f "(~a|~a)" version major-minor)
|
||
(format #f "(~a)" version)))
|
||
(m (string-match pattern s)))
|
||
(if m
|
||
;; Crawl parent and rewrite current component.
|
||
(let* ((parent-url (string-join (reverse parents) "/"))
|
||
(links (url->links parent-url))
|
||
;; The pattern matching the version.
|
||
(pattern (string-append "^" (match:prefix m)
|
||
"(" %version-rx ")"
|
||
(match:suffix m) "$"))
|
||
(candidates (filter-map
|
||
(lambda (l)
|
||
;; Links may be followed by a
|
||
;; trailing '/' in the case of
|
||
;; directories.
|
||
(and-let*
|
||
((l (strip-trailing-slash l))
|
||
(m (string-match pattern l))
|
||
(v (match:substring m 1)))
|
||
(cons v l)))
|
||
links)))
|
||
;; Retrieve the item having the largest version.
|
||
(if (null? candidates)
|
||
parents
|
||
(cons (cdr (first (sort candidates
|
||
(lambda (x y)
|
||
(version>? (car x)
|
||
(car y))))))
|
||
parents)))
|
||
;; No version found in path component; continue.
|
||
(cons s parents)))))
|
||
(reverse url-prefix-components)
|
||
path-components))
|
||
"/")))
|
||
|
||
(define* (import-html-release base-url package
|
||
#:key
|
||
rewrite-url?
|
||
version
|
||
(directory (string-append
|
||
"/" (package-upstream-name package)))
|
||
file->signature)
|
||
"Return an <upstream-source> for the latest release of PACKAGE under
|
||
DIRECTORY at BASE-URL, or #f. Optionally include a VERSION string to fetch a
|
||
specific version.
|
||
|
||
BASE-URL should be the URL of an HTML page, typically a directory listing as
|
||
found on 'https://kernel.org/pub'.
|
||
|
||
When FILE->SIGNATURE is omitted or #f, guess the detached signature file name,
|
||
if any. Otherwise, FILE->SIGNATURE must be a procedure; it is passed a source
|
||
file URL and must return the corresponding signature URL, or #f it signatures
|
||
are unavailable.
|
||
|
||
When REWRITE-URL? is #t, versioned components in BASE-URL and/or DIRECTORY are
|
||
also updated to the latest version, as explained in the doc of the
|
||
\"rewrite-url\" procedure used."
|
||
(let* ((current-version (package-version package))
|
||
(name (package-upstream-name package))
|
||
(url (if (string-null? directory)
|
||
base-url
|
||
(string-append base-url directory "/")))
|
||
(url (if rewrite-url?
|
||
(rewrite-url url current-version #:to-version version)
|
||
url))
|
||
(links (map (cut canonicalize-url <> url) (url->links url))))
|
||
|
||
(define (file->signature/guess url)
|
||
"Return the first link that matches a signature extension, else #f."
|
||
(let ((base (basename url)))
|
||
(any (lambda (link)
|
||
(any (lambda (extension)
|
||
(and (string=? (string-append base extension)
|
||
(basename link))
|
||
(string-append url extension)))
|
||
'(".asc" ".sig" ".sign")))
|
||
links)))
|
||
|
||
(define (url->release url)
|
||
"Return an <upstream-source> object if a release file was found at URL,
|
||
else #f. URL is assumed to fully specified."
|
||
(let ((base (basename url)))
|
||
(and (release-file? name base)
|
||
(let ((version (tarball->version base)))
|
||
(upstream-source
|
||
(package name)
|
||
(version version)
|
||
;; uri-mirror-rewrite: Don't turn nice mirror:// URIs into ftp://
|
||
;; URLs during "guix refresh -u".
|
||
(urls (list (uri-mirror-rewrite url)))
|
||
(signature-urls
|
||
(and=> ((or file->signature file->signature/guess) url)
|
||
(lambda (url) (list (uri-mirror-rewrite url))))))))))
|
||
|
||
(define candidates
|
||
(filter-map url->release links))
|
||
|
||
(match candidates
|
||
(() #f)
|
||
((first . _)
|
||
(if version
|
||
;; Find matching release version and return it.
|
||
(find (lambda (upstream)
|
||
(string=? (upstream-source-version upstream) version))
|
||
(coalesce-sources candidates))
|
||
;; Select the most recent release and return it.
|
||
(reduce (lambda (r1 r2)
|
||
(if (version>? (upstream-source-version r1)
|
||
(upstream-source-version r2))
|
||
r1 r2))
|
||
first
|
||
(coalesce-sources candidates)))))))
|
||
|
||
|
||
;;;
|
||
;;; Updaters.
|
||
;;;
|
||
|
||
(define %gnu-file-list-uri
|
||
;; URI of the file list for ftp.gnu.org.
|
||
(string->uri "https://ftp.gnu.org/find.txt.gz"))
|
||
|
||
(define ftp.gnu.org-files
|
||
(mlambda ()
|
||
"Return the list of files available at ftp.gnu.org."
|
||
|
||
;; XXX: Memoize the whole procedure to work around the fact that
|
||
;; 'http-fetch/cached' caches the gzipped version.
|
||
|
||
(define (trim-leading-components str)
|
||
;; Trim the leading ".", if any, in "./gnu/foo".
|
||
(string-trim str (char-set #\.)))
|
||
|
||
(define (string->lines str)
|
||
(string-tokenize str (char-set-complement (char-set #\newline))))
|
||
|
||
;; Since https://ftp.gnu.org honors 'If-Modified-Since', the hard-coded
|
||
;; TTL can be relatively short.
|
||
(let ((port (http-fetch/cached %gnu-file-list-uri #:ttl (* 15 60))))
|
||
(map trim-leading-components
|
||
(call-with-gzip-input-port port
|
||
(compose string->lines get-string-all))))))
|
||
|
||
(define* (import-gnu-release package #:key (version #f))
|
||
"Return the latest release of PACKAGE, a GNU package available via
|
||
ftp.gnu.org. Optionally include a VERSION string to fetch a specific version.
|
||
|
||
This method does not rely on FTP access at all; instead, it browses the file
|
||
list available from %GNU-FILE-LIST-URI over HTTP(S)."
|
||
(define archive-type
|
||
(package-archive-type package))
|
||
|
||
(define (better-tarball? tarball1 tarball2)
|
||
(string=? (file-extension tarball1) archive-type))
|
||
|
||
(define (find-latest-tarball-version tarballs)
|
||
(fold (lambda (file1 file2)
|
||
(if (and file2
|
||
(version>? (tarball-sans-extension (basename file2))
|
||
(tarball-sans-extension (basename file1))))
|
||
file2
|
||
file1))
|
||
#f
|
||
tarballs))
|
||
|
||
(let-values (((server directory)
|
||
(ftp-server/directory package))
|
||
((name)
|
||
(package-upstream-name package)))
|
||
(let* ((files (ftp.gnu.org-files))
|
||
;; select tarballs for this package
|
||
(relevant (filter (lambda (file)
|
||
(and (string-prefix? "/gnu" file)
|
||
(string-contains file directory)
|
||
(release-file? name (basename file))))
|
||
files))
|
||
;; find latest version
|
||
(version (or version
|
||
(and (not (null? relevant))
|
||
(tarball->version
|
||
(find-latest-tarball-version relevant)))))
|
||
;; find tarballs matching this version
|
||
(tarballs (filter (lambda (file)
|
||
(string=? version (tarball->version file)))
|
||
relevant)))
|
||
(match tarballs
|
||
(() #f)
|
||
(_
|
||
(upstream-source
|
||
(package name)
|
||
(version version)
|
||
(urls (map (lambda (file)
|
||
(string-append "mirror://gnu/"
|
||
(string-drop file
|
||
(string-length "/gnu/"))))
|
||
;; Sort so that the tarball with the same compression
|
||
;; format as currently used in PACKAGE comes first.
|
||
(sort tarballs better-tarball?)))
|
||
(signature-urls (map (cut string-append <> ".sig") urls))))))))
|
||
|
||
(define %package-name-rx
|
||
;; Regexp for a package name, e.g., "foo-X.Y". Since TeXmacs uses
|
||
;; "TeXmacs-X.Y-src", the `-src' suffix is allowed.
|
||
(make-regexp "^(.*)[-_][vV]?(([0-9]|\\.)+)(-src|\\.src|\\.orig)?"))
|
||
|
||
(define (gnu-package-name->name+version name+version)
|
||
"Return the package name and version number extracted from NAME+VERSION."
|
||
(let ((match (regexp-exec %package-name-rx name+version)))
|
||
(if (not match)
|
||
(values name+version #f)
|
||
(values (match:substring match 1) (match:substring match 2)))))
|
||
|
||
(define gnome-package?
|
||
(url-prefix-predicate "mirror://gnome/"))
|
||
|
||
(define (pure-gnu-package? package)
|
||
"Return true if PACKAGE is a non-Emacs and non-GNOME GNU package. This
|
||
excludes AucTeX, for instance, whose releases are now uploaded to
|
||
elpa.gnu.org, GNU Radio, which has releases at www.gnuradio.org, and all the
|
||
GNOME packages; EMMS is included though, because its releases are on gnu.org."
|
||
(and (or (not (string-prefix? "emacs-" (package-name package)))
|
||
(gnu-hosted? package))
|
||
(not (gnome-package? package))
|
||
(not (string-prefix? "gnuradio" (package-name package)))
|
||
(gnu-package? package)))
|
||
|
||
(define gnu-hosted?
|
||
(url-prefix-predicate "mirror://gnu/"))
|
||
|
||
(define (uri-mirror-rewrite uri)
|
||
"Rewrite URI to a mirror:// URI if possible, or return URI unmodified."
|
||
(if (string-prefix? "mirror://" uri)
|
||
uri ;nothing to do, it's already a mirror URI
|
||
(let loop ((mirrors %mirrors))
|
||
(match mirrors
|
||
(()
|
||
uri)
|
||
(((mirror-id mirror-urls ...) rest ...)
|
||
(match (find (cut string-prefix? <> uri) mirror-urls)
|
||
(#f
|
||
(loop rest))
|
||
(prefix
|
||
(format #f "mirror://~a/~a"
|
||
mirror-id
|
||
(string-drop uri (string-length prefix))))))))))
|
||
|
||
(define %savannah-base
|
||
;; One of the Savannah mirrors listed at
|
||
;; <https://download.savannah.gnu.org/mirmon/savannah/> that serves valid
|
||
;; HTML (unlike <https://download.savannah.nongnu.org/releases>.)
|
||
"https://de.freedif.org/savannah/")
|
||
|
||
(define* (import-savannah-release package #:key (version #f))
|
||
"Return the latest release of PACKAGE. Optionally include a VERSION string
|
||
to fetch a specific version."
|
||
(let* ((uri (string->uri
|
||
(match (origin-uri (package-source package))
|
||
((? string? uri) uri)
|
||
((uri mirrors ...) uri))))
|
||
(directory (dirname (uri-path uri))))
|
||
;; Note: We use the default 'file->signature', which adds ".sig", ".asc",
|
||
;; or whichever detached signature naming scheme PACKAGE uses.
|
||
(import-html-release %savannah-base package
|
||
#:version version
|
||
#:directory directory)))
|
||
|
||
(define* (latest-sourceforge-release package #:key (version #f))
|
||
"Return the latest release of PACKAGE. Optionally include a VERSION string
|
||
to fetch a specific version."
|
||
(define (uri-append uri extension)
|
||
;; Return URI with EXTENSION appended.
|
||
(build-uri (uri-scheme uri)
|
||
#:host (uri-host uri)
|
||
#:path (string-append (uri-path uri) extension)))
|
||
|
||
(define (valid-uri? uri port)
|
||
;; Return true if URI is reachable.
|
||
(false-if-exception
|
||
(case (response-code (http-head uri #:port port #:keep-alive? #t))
|
||
((200 302) #t)
|
||
(else #f))))
|
||
|
||
(when version
|
||
(error
|
||
(formatted-message
|
||
(G_ "Updating to a specific version is not yet implemented for ~a, sorry.")
|
||
"sourceforge")))
|
||
|
||
(let* ((name (package-upstream-name package))
|
||
(base (string-append "https://sourceforge.net/projects/"
|
||
name "/files"))
|
||
(url (string-append base "/latest/download"))
|
||
(uri (string->uri url))
|
||
(port (false-if-exception (open-socket-for-uri uri)))
|
||
(response (and port
|
||
(http-head uri #:port port #:keep-alive? #t))))
|
||
(dynamic-wind
|
||
(const #t)
|
||
(lambda ()
|
||
(and response
|
||
(= 302 (response-code response))
|
||
(response-location response)
|
||
(match (string-tokenize (uri-path (response-location response))
|
||
(char-set-complement (char-set #\/)))
|
||
((_ components ...)
|
||
(let* ((path (string-join components "/"))
|
||
(url (string-append "mirror://sourceforge/" path)))
|
||
(and (release-file? name (basename path))
|
||
|
||
;; Take the heavy-handed approach of probing 3 additional
|
||
;; URLs. XXX: Would be nicer if this could be avoided.
|
||
(let* ((loc (response-location response))
|
||
(sig (any (lambda (extension)
|
||
(let ((uri (uri-append loc extension)))
|
||
(and (valid-uri? uri port)
|
||
(string-append url extension))))
|
||
'(".asc" ".sig" ".sign"))))
|
||
(upstream-source
|
||
(package name)
|
||
(version (tarball->version (basename path)))
|
||
(urls (list url))
|
||
(signature-urls (and sig (list sig)))))))))))
|
||
(lambda ()
|
||
(when port
|
||
(close-port port))))))
|
||
|
||
(define* (import-xorg-release package #:key (version #f))
|
||
"Return the latest release of PACKAGE. Optionally include a VERSION string
|
||
to fetch a specific version."
|
||
(let ((uri (string->uri (origin-uri (package-source package)))))
|
||
(false-if-ftp-error
|
||
(import-ftp-release
|
||
(package-name package)
|
||
#:version version
|
||
#:server "ftp.freedesktop.org"
|
||
#:directory
|
||
(string-append "/pub/xorg/" (dirname (uri-path uri)))))))
|
||
|
||
(define* (import-kernel.org-release package #:key (version #f))
|
||
"Return the latest release of PACKAGE, a Linux kernel package.
|
||
Optionally include a VERSION string to fetch a specific version."
|
||
(define %kernel.org-base
|
||
;; This URL and sub-directories thereof are nginx-generated directory
|
||
;; listings suitable for 'import-html-release'.
|
||
"https://mirrors.edge.kernel.org/pub")
|
||
|
||
(define (file->signature file)
|
||
(string-append (file-sans-extension file) ".sign"))
|
||
|
||
(let* ((uri (string->uri
|
||
(match (origin-uri (package-source package))
|
||
((? string? uri) uri)
|
||
((uri mirrors ...) uri))))
|
||
(directory (dirname (uri-path uri))))
|
||
(import-html-release %kernel.org-base package
|
||
#:version version
|
||
#:directory directory
|
||
#:file->signature file->signature)))
|
||
|
||
;;; These sites are disallowed for the generic HTML updater as there are
|
||
;;; better means to query them.
|
||
(define %disallowed-hosting-sites
|
||
'("github.com" "github.io" "gitlab.com"
|
||
"notabug.org" "sr.ht" "gitlab.inria.fr"
|
||
"ftp.gnu.org" "download.savannah.gnu.org"
|
||
"pypi.org" "crates.io" "rubygems.org"
|
||
"bioconductor.org"))
|
||
|
||
(define (http-url? url)
|
||
"Return URL if URL has HTTP or HTTPS as its protocol. If URL uses the
|
||
special mirror:// protocol, substitute it with the first HTTP or HTTPS URL
|
||
prefix from its set."
|
||
(match (string->uri url)
|
||
(#f #f)
|
||
(uri
|
||
(let ((scheme (uri-scheme uri))
|
||
(host (uri-host uri)))
|
||
(or (and (memq scheme '(http https))
|
||
;; HOST may contain prefixes, e.g. "profanity-im.github.io",
|
||
;; hence the suffix-based test below.
|
||
(not (any (cut string-suffix? <> host)
|
||
%disallowed-hosting-sites))
|
||
url)
|
||
(and (eq? scheme 'mirror)
|
||
(and=> (find http-url?
|
||
(assoc-ref %mirrors
|
||
(string->symbol host)))
|
||
(lambda (url)
|
||
(string-append (strip-trailing-slash url)
|
||
(uri-path uri))))))))))
|
||
|
||
(define (html-updatable-package? package)
|
||
"Return true if the given package may be handled by the generic HTML
|
||
updater."
|
||
(or (assoc-ref (package-properties package) 'release-monitoring-url)
|
||
((url-predicate http-url?) package)))
|
||
|
||
(define* (import-html-updatable-release package #:key (version #f))
|
||
"Return the latest release of PACKAGE else #f. Do that by crawling the HTML
|
||
page of the directory containing its source tarball. Optionally include a
|
||
VERSION string to fetch a specific version."
|
||
|
||
(define (expand-uri uri)
|
||
(match uri
|
||
((and (? string?) (? (cut string-prefix? "mirror://" <>) url))
|
||
;; Retrieve the authoritative HTTP URL from a mirror.
|
||
(http-url? url))
|
||
((? string? url)
|
||
url)
|
||
((url _ ...)
|
||
;; This case is for when the URI is a list of possibly
|
||
;; mirror URLs as well as HTTP URLs.
|
||
(expand-uri url))))
|
||
|
||
(let* ((uri (string->uri
|
||
(expand-uri (origin-uri (package-source package)))))
|
||
(custom (assoc-ref (package-properties package)
|
||
'release-monitoring-url))
|
||
(base (or custom
|
||
(string-append (symbol->string (uri-scheme uri))
|
||
"://" (uri-host uri))))
|
||
(directory (if custom
|
||
""
|
||
(dirname (uri-path uri)))))
|
||
(false-if-networking-error
|
||
(import-html-release base package
|
||
#:rewrite-url? #t
|
||
#:version version
|
||
#:directory directory))))
|
||
|
||
(define %gnu-updater
|
||
;; This is for everything at ftp.gnu.org.
|
||
(upstream-updater
|
||
(name 'gnu)
|
||
(description "Updater for GNU packages")
|
||
(pred (lambda (package)
|
||
(false-if-networking-error (gnu-hosted? package))))
|
||
(import import-gnu-release)))
|
||
|
||
(define %gnu-ftp-updater
|
||
;; This is for GNU packages taken from alternate locations, such as
|
||
;; alpha.gnu.org, ftp.gnupg.org, etc. It is obsolescent.
|
||
(upstream-updater
|
||
(name 'gnu-ftp)
|
||
(description "Updater for GNU packages only available via FTP")
|
||
(pred (lambda (package)
|
||
(false-if-networking-error
|
||
(and (not (gnu-hosted? package))
|
||
(pure-gnu-package? package)))))
|
||
(import import-release*)))
|
||
|
||
(define %savannah-updater
|
||
(upstream-updater
|
||
(name 'savannah)
|
||
(description "Updater for packages hosted on savannah.gnu.org")
|
||
(pred (url-prefix-predicate "mirror://savannah/"))
|
||
(import import-savannah-release)))
|
||
|
||
(define %sourceforge-updater
|
||
(upstream-updater
|
||
(name 'sourceforge)
|
||
(description "Updater for packages hosted on sourceforge.net")
|
||
(pred (url-prefix-predicate "mirror://sourceforge/"))
|
||
(import latest-sourceforge-release)))
|
||
|
||
(define %xorg-updater
|
||
(upstream-updater
|
||
(name 'xorg)
|
||
(description "Updater for X.org packages")
|
||
(pred (url-prefix-predicate "mirror://xorg/"))
|
||
(import import-xorg-release)))
|
||
|
||
(define %kernel.org-updater
|
||
(upstream-updater
|
||
(name 'kernel.org)
|
||
(description "Updater for packages hosted on kernel.org")
|
||
(pred (url-prefix-predicate "mirror://kernel.org/"))
|
||
(import import-kernel.org-release)))
|
||
|
||
(define %generic-html-updater
|
||
(upstream-updater
|
||
(name 'generic-html)
|
||
(description "Updater that crawls HTML pages.")
|
||
(pred html-updatable-package?)
|
||
(import import-html-updatable-release)))
|
||
|
||
;;; gnu-maintenance.scm ends here
|