;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2018-2021, 2024 Ludovic Courtès <ludo@gnu.org>
;;; Copyright © 2020 Jakub Kądziołka <kuba@kadziolka.net>
;;; Copyright © 2021 Xinglu Chen <public@yoctocell.xyz>
;;; Copyright © 2021 Simon Tournier <zimon.toutoune@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 swh)
#:use-module (guix base16)
#:use-module (guix build utils)
#:use-module ((guix build syscalls) #:select (mkdtemp!))
#:use-module (web uri)
#:use-module (web client)
#:use-module (web response)
#:use-module (json)
#:use-module (srfi srfi-1)
#:use-module (srfi srfi-9)
#:use-module (srfi srfi-11)
#:use-module (srfi srfi-19)
#:use-module (ice-9 match)
#:use-module (ice-9 regex)
#:use-module (ice-9 popen)
#:use-module ((ice-9 ftw) #:select (scandir))
#:export (%swh-base-url
%verify-swh-certificate?
%allow-request?
request-rate-limit-reached?
origin?
origin-type
origin-url
origin-visits
lookup-origin
visit?
visit-date
visit-origin
visit-url
visit-snapshot-url
visit-status
visit-number
visit-type
visit-snapshot
snapshot?
snapshot-id
snapshot-branches
lookup-snapshot-branch
branch?
branch-name
branch-target
release?
release-id
release-name
release-message
release-target
revision?
revision-id
revision-date
revision-directory
lookup-revision
lookup-origin-revision
external-id?
external-id-value
external-id-type
external-id-version
external-id-target
lookup-external-id
lookup-directory-by-nar-hash
content?
content-checksums
content-data-url
content-length
lookup-content
directory-entry?
directory-entry-name
directory-entry-type
directory-entry-checksums
directory-entry-length
directory-entry-permissions
lookup-directory
directory-entry-target
save-reply?
save-reply-origin-url
save-reply-origin-type
save-reply-request-date
save-reply-request-status
save-reply-task-status
save-origin
save-origin-status
vault-reply?
vault-reply-id
vault-reply-fetch-url
vault-reply-progress-message
vault-reply-status
vault-reply-swhid
query-vault
request-cooking
vault-fetch
commit-id?
swh-download-directory
swh-download-directory-by-nar-hash
swh-download))
;;; Commentary:
;;;
;;; This module provides bindings to the HTTP interface of Software Heritage.
;;; It allows you to browse the archive, look up revisions (such as SHA1
;;; commit IDs), "origins" (code hosting URLs), content (files), etc. See
;;; <https://archive.softwareheritage.org/api/> for more information.
;;;
;;; The high-level 'swh-download' procedure allows you to download a Git
;;; revision from Software Heritage, provided it is available.
;;;
;;; Code:
(define %swh-base-url
;; Presumably we won't need to change it.
(make-parameter "https://archive.softwareheritage.org"))
(define %verify-swh-certificate?
;; Whether to verify the X.509 HTTPS certificate for %SWH-BASE-URL.
(make-parameter #t))
;; Token from an account to the Software Heritage Authentication service
;; <https://archive.softwareheritage.org/api/>
(define %swh-token
(make-parameter (and=> (getenv "GUIX_SWH_TOKEN")
string->symbol)))
(define (swh-url path . rest)
;; URLs returned by the API may be relative or absolute. This has changed
;; without notice before. Handle both cases by detecting whether the path
;; starts with a domain.
(define root
(if (string-prefix? "/" path)
(string-append (%swh-base-url) path)
path))
(define url
(string-append root (string-join rest "/" 'prefix)))
(define (contains-parameters? url)
(match (string-rindex url #\/)
(#f #f)
(offset (string-index (string-drop url (+ 1 offset)) #\?))))
;; Ensure there's a trailing slash or we get a redirect. Don't do that if
;; URL contains parameters.
(cond ((string-suffix? "/" url) url)
((contains-parameters? url) url)
(else (string-append url "/"))))
;; XXX: Work around a bug in Guile 3.0.2 where #:verify-certificate? would
;; be ignored (<https://bugs.gnu.org/40486>).
(define* (http-get* uri #:rest rest)
(apply http-request uri #:method 'GET rest))
(define* (http-post* uri #:rest rest)
(apply http-request uri #:method 'POST rest))
(define %date-regexp
;; Match strings like "2014-11-17T22:09:38+01:00" or
;; "2018-09-30T23:20:07.815449+00:00"".
(make-regexp "^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})((\\.[0-9]+)?)([+-][0-9]{2}):([0-9]{2})$"))
(define (string->date* str)
"Return a SRFI-19 date parsed from STR, a date string as returned by
Software Heritage."
;; We can't use 'string->date' because of the timezone format: SWH returns
;; "+01:00" when the '~z' template expects "+0100". So we roll our own!
(or (and=> (regexp-exec %date-regexp str)
(lambda (match)
(define (ref n)
(string->number (match:substring match n)))
(make-date (let ((ns (match:substring match 8)))
(if ns
(string->number (string-drop ns 1))
0))
(ref 6) (ref 5) (ref 4)
(ref 3) (ref 2) (ref 1)
(+ (* 3600 (ref 9)) ;time zone
(if (< (ref 9) 0)
(- (ref 10))
(ref 10))))))
str)) ;oops!
(define (maybe-null proc)
(match-lambda
((? null?) #f)
('null #f)
(obj (proc obj))))
(define string*
;; Converts "string or #nil" coming from JSON to "string or #f".
(match-lambda
((? string? str) str)
((? null?) #f) ;Guile-JSON 3.x
('null #f))) ;Guile-JSON 4.x
(define %allow-request?
;; Takes a URL and method (e.g., the 'http-get' procedure) and returns true
;; to keep going. This can be used to disallow requests when
;; 'request-rate-limit-reached?' returns true, for instance.
(make-parameter (const #t)))
;; The time when the rate limit for "/origin/save" POST requests and that of
;; other requests will be reset.
;; See <https://archive.softwareheritage.org/api/#rate-limiting>.
(define %save-rate-limit-reset-time 0)
(define %general-rate-limit-reset-time 0)
(define (request-rate-limit-reached? url method)
"Return true if the rate limit has been reached for URI."
(define uri
(string->uri url))
(define reset-time
(if (and (eq? method http-post*)
(string-prefix? "/api/1/origin/save/" (uri-path uri)))
%save-rate-limit-reset-time
%general-rate-limit-reset-time))
(< (car (gettimeofday)) reset-time))
(define (update-rate-limit-reset-time! url method response)
"Update the rate limit reset time for URL and METHOD based on the headers in
RESPONSE."
(let ((uri (string->uri url)))
(match (assq-ref (response-headers response) 'x-ratelimit-reset)
((= string->number (? number? reset))
(if (and (eq? method http-post*)
(string-prefix? "/api/1/origin/save/" (uri-path uri)))
(set! %save-rate-limit-reset-time reset)
(set! %general-rate-limit-reset-time reset)))
(_
#f))))
(define* (call url decode #:optional (method http-get*)
#:key (false-if-404? #t))
"Invoke the endpoint at URL using METHOD. Decode the resulting JSON body
using DECODE, a one-argument procedure that takes an input port. When
FALSE-IF-404? is true, return #f upon 404 responses."
(and ((%allow-request?) url method)
(let*-values (((response port)
(method url #:streaming? #t
#:headers
(if (%swh-token)
`((authorization . (Bearer ,(%swh-token))))
'())
#:verify-certificate?
(%verify-swh-certificate?))))
;; See <https://archive.softwareheritage.org/api/#rate-limiting>.
(match (assq-ref (response-headers response) 'x-ratelimit-remaining)
(#f #t)
((? (compose zero? string->number))
(update-rate-limit-reset-time! url method response)
(throw 'swh-error url method response))
(_ #t))
(cond ((= 200 (response-code response))
(let ((result (decode port)))
(close-port port)
result))
((and false-if-404?
(= 404 (response-code response)))
(close-port port)
#f)
(else
(close-port port)
(throw 'swh-error url method response))))))
(define-syntax define-query
(syntax-rules (path)
"Define a procedure that performs a Software Heritage query."
((_ (name args ...) docstring (path components ...)
json->value)
(define (name args ...)
docstring
(call (swh-url components ...) json->value)))))
;; <https://archive.softwareheritage.org/api/1/origin/https://github.com/guix-mirror/guix/get>
(define-json-mapping <origin> make-origin origin?
json->origin
(visits-url origin-visits-url "origin_visits_url")
(type origin-type)
(url origin-url))
;; <https://archive.softwareheritage.org/api/1/origin/52181937/visits/>
(define-json-mapping <visit> make-visit visit?
json->visit
(date visit-date "date" string->date*)
(origin visit-origin)
(url visit-url "origin_visit_url")
(snapshot-url visit-snapshot-url "snapshot_url" string*) ;string | #f
(status visit-status "status" string->symbol) ;'full | 'partial | 'ongoing
(type visit-type "type" string->symbol) ;'git | 'git-checkout | ...
(number visit-number "visit"))
;; <https://archive.softwareheritage.org/api/1/snapshot/4334c3ed4bb208604ed780d8687fe523837f1bd1/>
(define-json-mapping <snapshot> make-snapshot snapshot?
json->snapshot
(id snapshot-id)
(branches snapshot-branches "branches" json->branches))
;; This is used for the "branches" field of snapshots.
(define-record-type <branch>
(make-branch name target-type target-url)
branch?
(name branch-name)
(target-type branch-target-type) ;release | revision
(target-url branch-target-url))
(define (json->branches branches)
(map (match-lambda
((key . value)
(make-branch key
(string->symbol
(assoc-ref value "target_type"))
(assoc-ref value "target_url"))))
branches))
;; <https://archive.softwareheritage.org/api/1/release/1f44934fb6e2cefccbecd4fa347025349fa9ff76/>
(define-json-mapping <release> make-release release?
json->release
(id release-id)
(name release-name)
(message release-message)
(target-type release-target-type "target_type" string->symbol)
(target-url release-target-url "target_url"))
;; <https://archive.softwareheritage.org/api/1/revision/359fdda40f754bbf1b5dc261e7427b75463b59be/>
;; Note: Some revisions, such as those for "nixguix" origins (e.g.,
;; <https://archive.softwareheritage.org/api/1/revision/b8dbc65475bbedde8e015d4730ade8864c38fad3/>),
;; have their 'date' field set to null.
(define-json-mapping <revision> make-revision revision?
json->revision
(id revision-id)
(date revision-date "date" (maybe-null string->date*))
(directory revision-directory)
(directory-url revision-directory-url "directory_url"))
;; <https://archive.softwareheritage.org/api/1/content/>
(define-json-mapping <content> make-content content?
json->content
(checksums content-checksums "checksums" json->checksums)
(data-url content-data-url "data_url")
(file-type-url content-file-type-url "filetype_url")
(language-url content-language-url "language_url")
(length content-length)
(license-url content-license-url "license_url"))
(define (json->checksums checksums)
(map (match-lambda
((key . value)
(cons key (base16-string->bytevector value))))
checksums))
;; <https://archive.softwareheritage.org/api/1/directory/27c69c5d298a43096a53affbf881e7b13f17bdcd/>
(define-json-mapping <directory-entry> make-directory-entry directory-entry?
json->directory-entry
(name directory-entry-name)
(type directory-entry-type "type"
(match-lambda
("dir" 'directory)
(str (string->symbol str))))
(checksums directory-entry-checksums "checksums"
(match-lambda
(#f #f)
((? unspecified?) #f)
(lst (json->checksums lst))))
(id directory-entry-id "dir_id")
(length directory-entry-length)
(permissions directory-entry-permissions "perms")
(target-url directory-entry-target-url "target_url"))
;; <https://archive.softwareheritage.org/api/1/extid/doc/>
(define-json-mapping <external-id> make-external-id external-id?
json->external-id
(value external-id-value "extid")
(type external-id-type "extid_type")
(version external-id-version "extid_version")
(target external-id-target)
(target-url external-id-target-url "target_url"))
;; <https://archive.softwareheritage.org/api/1/origin/save/>
(define-json-mapping <save-reply> make-save-reply save-reply?
json->save-reply
(origin-url save-reply-origin-url "origin_url")
(origin-type save-reply-origin-type "origin_type")
(request-date save-reply-request-date "save_request_date"
string->date*)
(request-status save-reply-request-status "save_request_status"
string->symbol)
(task-status save-reply-task-status "save_task_status"
(match-lambda
("not created" 'not-created)
((? string? str) (string->symbol str)))))
;; <https://docs.softwareheritage.org/devel/swh-vault/api.html#vault-api-ref>
(define-json-mapping <vault-reply> make-vault-reply vault-reply?
json->vault-reply
(id vault-reply-id)
(fetch-url vault-reply-fetch-url "fetch_url")
(progress-message vault-reply-progress-message "progress_message")
(status vault-reply-status "status" string->symbol)
(swhid vault-reply-swhid))
;;;
;;; RPCs.
;;;
(define-query (lookup-origin url)
"Return an origin for URL."
(path "/api/1/origin" url "get")
json->origin)
(define-query (lookup-content hash type)
"Return a content for HASH, of the given TYPE--e.g., \"sha256\"."
(path "/api/1/content"
(string-append type ":"
(bytevector->base16-string hash)))
json->content)
(define-query (lookup-revision id)
"Return the revision with the given ID, typically a Git commit SHA1."
(path "/api/1/revision" id)
json->revision)
(define-query (lookup-directory id)
"Return the list of entries of the directory with the given ID."
(path "/api/1/directory" id)
json->directory-entries)
(define (json->directory-entries port)
(map json->directory-entry
(vector->list (json->scm port))))
(define (lookup-external-id type id)
"Return the external ID record for ID, a bytevector, of the given TYPE
(currently one of: \"bzr-nodeid\", \"hg-nodeid\", \"nar-sha256\",
\"checksum-sha512\")."
;; Specify "extid_version=1" as explained in
;; <https://gitlab.softwareheritage.org/swh/meta/-/issues/5093>.
(call (swh-url "/api/1/extid" type
(string-append "hex:" (bytevector->base16-string id)
"/?extid_version=1"))
json->external-id))
(define* (lookup-directory-by-nar-hash hash #:optional (algorithm 'sha256))
"Return the SWHID of a directory---i.e., prefixed by \"swh:1:dir\"---for the
directory that with the given HASH (a bytevector), assuming nar serialization
and use of ALGORITHM."
;; example:
;; https://archive.softwareheritage.org/api/1/extid/nar-sha256/base64url:0jD6Z4TLMm5g1CviuNNuVNP31KWyoT_oevfr8TQwc3Y/
(and=> (lookup-external-id (string-append "nar-" (symbol->string algorithm))
hash)
external-id-target))
(define* (origin-visits origin #:optional (max 10))
"Return the list of the up to MAX latest visits of ORIGIN, a record as
returned by 'lookup-origin'."
(call (string-append (swh-url (origin-visits-url origin))
"?per_page=" (number->string max))
(lambda (port)
(map json->visit (vector->list (json->scm port))))))
(define (visit-snapshot visit)
"Return the snapshot corresponding to VISIT or #f if no snapshot is
available."
(and (visit-snapshot-url visit)
(call (swh-url (visit-snapshot-url visit))
json->snapshot)))
(define (snapshot-url snapshot branch-count first-branch)
"Return the URL of SNAPSHOT such that it contains information for
BRANCH-COUNT branches, starting at FIRST-BRANCH."
(string-append (swh-url "/api/1/snapshot" (snapshot-id snapshot))
"?branches_count=" (number->string branch-count)
"&branches_from=" (uri-encode first-branch)))
(define (lookup-snapshot-branch snapshot name)
"Look up branch NAME on SNAPSHOT. Return the branch, or return #f if it
could not be found."
(or (find (lambda (branch)
(string=? (branch-name branch) name))
(snapshot-branches snapshot))
;; There's no API entry point to look up a snapshot branch by name.
;; Work around that by using the paginated list of branches provided by
;; the /api/1/snapshot API: ask for one branch, and start pagination at
;; NAME.
(let ((snapshot (call (snapshot-url snapshot 1 name)
json->snapshot)))
(match (snapshot-branches snapshot)
((branch)
(and (string=? (branch-name branch) name)
branch))
(_ #f)))))
(define (branch-target branch)
"Return the target of BRANCH: a <revision>, a <release>, or the SWHID of a
directory."
(match (branch-target-type branch)
('release
(call (swh-url (branch-target-url branch))
json->release))
('revision
(call (swh-url (branch-target-url branch))
json->revision))
((or 'directory 'alias)
(match (string-tokenize (branch-target-url branch)
(char-set-complement (char-set #\/)))
((_ ... "directory" id)
(string-append "swh:1:dir:" id))))))
(define (lookup-origin-revision url tag)
"Return a <revision> corresponding to the given TAG for the repository
coming from URL. Example:
(lookup-origin-revision \"https://github.com/guix-mirror/guix/\" \"v0.8\")
=> #<<revision> id: \"44941…\" …>
The information is based on the latest visit of URL available. Return #f if
URL could not be found."
(match (lookup-origin url)
(#f #f)
(origin
(any (lambda (visit)
(and (visit-snapshot-url visit)
(eq? 'full (visit-status visit))
(let ((snapshot (visit-snapshot visit)))
(match (and=> (find (lambda (branch)
(or
;; Git specific.
(string=? (string-append "refs/tags/" tag)
(branch-name branch))
;; Hg specific.
(string=? tag
(branch-name branch))))
(snapshot-branches snapshot))
branch-target)
((? release? release)
(release-target release))
((? revision? revision)
revision)
(_
;; Either the branch points to a directory rather than
;; a revision (this is the case for visits of type
;; 'git-checkout, 'hg-checkout, 'tarball-directory,
;; etc.), or TAG was not found.
#f)))))
(origin-visits origin 30)))))
(define (release-target release)
"Return the revision that is the target of RELEASE."
(match (release-target-type release)
('revision
(call (swh-url (release-target-url release))
json->revision))))
(define (directory-entry-target entry)
"If ENTRY, a directory entry, has type 'directory, return its list of
directory entries; if it has type 'file, return its <content> object."
(call (swh-url (directory-entry-target-url entry))
(match (directory-entry-type entry)
('file json->content)
('directory json->directory-entries))))
(define* (save-origin url #:optional (type "git"))
"Request URL to be saved."
(call (swh-url "/api/1/origin/save" type "url" url) json->save-reply
http-post*))
(define-query (save-origin-status url type)
"Return the status of a /save request for URL and TYPE (e.g., \"git\")."
(path "/api/1/origin/save" type "url" url)
json->save-reply)
(define* (vault-url id kind #:optional (archive-type 'flat))
"Return the vault query/cooking URL for ID and KIND. Normally, ID is an
SWHID and KIND is #f; the deprecated convention is to set ID to a raw
directory or revision ID and KIND to 'revision or 'directory."
;; Note: /api/1/vault/directory/ID was deprecated in favor of
;; /api/1/vault/flat/SWHID; this procedure "converts" automatically.
(let ((id (match kind
('directory (string-append "swh:1:dir:" id))
('revision (string-append "swh:1:rev:" id))
(#f id))))
(swh-url "/api/1/vault" (symbol->string archive-type) id)))
(define* (query-vault id #:optional kind #:key (archive-type 'flat))
"Ask the availability of object ID (an SWHID) to the vault. Return #f if it
could not be found, or a <vault-reply> on success. ARCHIVE-TYPE can be 'flat
for a tarball containing a directory, or 'git-bare for a tarball containing a
bare Git repository corresponding to a revision.
Passing KIND (one of 'directory or 'revision) together with a raw revision or
directory identifier is deprecated."
(call (vault-url id kind archive-type)
json->vault-reply))
(define* (request-cooking id #:optional kind #:key (archive-type 'flat))
"Request the cooking of object ID, an SWHID. Return a <vault-reply>.
ARCHIVE-TYPE can be 'flat for a tarball containing a directory, or 'git-bare
for a tarball containing a bare Git repository corresponding to a revision.
Passing KIND (one of 'directory or 'revision) together with a raw revision or
directory identifier is deprecated."
(call (vault-url id kind archive-type)
json->vault-reply
http-post*))
(define* (http-get/follow url
#:key
(verify-certificate? (%verify-swh-certificate?)))
"Like 'http-get' but follow redirects (HTTP 30x). On success, return two
values: an input port to read the response body and its 'Content-Length'. On
failure return #f and #f."
(define uri
(if (string? url) (string->uri url) url))
(let loop ((uri uri))
(define (resolve-uri-reference target)
(if (and (uri-scheme target) (uri-host target))
target
(build-uri (uri-scheme uri) #:host (uri-host uri)
#:port (uri-port uri)
#:path (uri-path target))))
(let*-values (((response port)
(http-get* uri #:streaming? #t
#:verify-certificate? verify-certificate?))
((code)
(response-code response)))
(case code
((200)
(values port (response-content-length response)))
((301 ; moved permanently
302 ; found (redirection)
303 ; see other
307 ; temporary redirection
308) ; permanent redirection
(close-port port)
(loop (resolve-uri-reference (response-location response))))
(else
(values #f #f))))))
(define* (vault-fetch id
#:optional kind
#:key
(archive-type 'flat)
(log-port (current-error-port)))
"Return an input port from which a bundle of the object with the given ID,
an SWHID, or #f if the object could not be found.
ARCHIVE-TYPE can be 'flat for a tarball containing a directory, or 'git-bare
for a tarball containing a bare Git repository corresponding to a revision."
(let loop ((reply (query-vault id kind
#:archive-type archive-type)))
(match reply
(#f
(and=> (request-cooking id kind
#:archive-type archive-type)
loop))
(_
(match (vault-reply-status reply)
('done
;; Fetch the bundle.
(let-values (((port length)
(http-get/follow (swh-url (vault-reply-fetch-url reply))
#:verify-certificate?
(%verify-swh-certificate?))))
port))
('failed
;; Upon failure, we're supposed to try again.
(format log-port "SWH vault: failure: ~a~%"
(vault-reply-progress-message reply))
(format log-port "SWH vault: retrying...~%")
(loop (request-cooking id kind
#:archive-type archive-type)))
((and (or 'new 'pending) status)
;; Wait until the bundle shows up.
(let ((message (vault-reply-progress-message reply)))
(when (eq? 'new status)
(format log-port "SWH vault: \
requested bundle cooking, waiting for completion...~%"))
(when (string? message)
(format log-port "SWH vault: ~a~%" message))
;; Wait long enough so we don't exhaust our maximum number of
;; requests per hour too fast (as of this writing, the limit is 60
;; requests per hour per IP address.)
(sleep (if (eq? status 'new) 60 30))
(loop (query-vault id kind
#:archive-type archive-type)))))))))
;;;
;;; High-level interface.
;;;
(define (call-with-temporary-directory proc) ;FIXME: factorize
"Call PROC with a name of a temporary directory; close the directory and
delete it when leaving the dynamic extent of this call."
(let* ((directory (or (getenv "TMPDIR") "/tmp"))
(template (string-append directory "/guix-directory.XXXXXX"))
(tmp-dir (mkdtemp! template)))
(dynamic-wind
(const #t)
(lambda ()
(proc tmp-dir))
(lambda ()
(false-if-exception (delete-file-recursively tmp-dir))))))
(define* (swh-download-archive swhid output
#:key
(archive-type 'flat)
(log-port (current-error-port)))
"Download from Software Heritage the directory or revision with the given
SWID, in the ARCHIVE-TYPE format (one of 'flat or 'git-bare), and unpack it to
OUTPUT. Return #t on success and #f on failure."
(call-with-temporary-directory
(lambda (directory)
(match (vault-fetch swhid
#:archive-type archive-type
#:log-port log-port)
(#f
(format log-port
"SWH: object ~a could not be fetched from the vault~%"
swhid)
#f)
((? port? input)
(let ((tar (open-pipe* OPEN_WRITE "tar" "-C" directory
(match archive-type
('flat "-xzvf") ;gzipped
('git-bare "-xvf")) ;uncompressed
"-")))
(dump-port input tar)
(close-port input)
(let ((status (close-pipe tar)))
(unless (zero? status)
(error "tar extraction failure" status)))
(match (scandir directory)
(("." ".." sub-directory)
(copy-recursively (string-append directory "/" sub-directory)
output
#:log (%make-void-port "w"))
#t))))))))
(define* (swh-download-directory id output
#:key (log-port (current-error-port)))
"Download from Software Heritage the directory with the given ID, and
unpack it to OUTPUT. Return #t on success and #f on failure."
(swh-download-archive (string-append "swh:1:dir:" id) output
#:archive-type 'flat
#:log-port log-port))
(define (commit-id? reference)
"Return true if REFERENCE is likely a commit ID, false otherwise---e.g., if
it is a tag name. This is based on a simple heuristic so use with care!"
(and (= (string-length reference) 40)
(string-every char-set:hex-digit reference)))
(define* (swh-download url reference output
#:key
(archive-type 'flat)
(log-port (current-error-port)))
"Download from Software Heritage a checkout (if ARCHIVE-TYPE is 'flat) or a
full Git repository (if ARCHIVE-TYPE is 'git-bare) of the Git tag or commit
REFERENCE originating from URL, and unpack it in OUTPUT. Return #t on success
and #f on failure.
This procedure uses the \"vault\", which contains \"cooked\" directories in
the form of tarballs. If the requested directory is not cooked yet, it will
wait until it becomes available, which could take several minutes."
(match (if (commit-id? reference)
(lookup-revision reference)
(lookup-origin-revision url reference))
((? revision? revision)
(format log-port "SWH: found revision ~a with directory at '~a'~%"
(revision-id revision)
(swh-url (revision-directory-url revision)))
(swh-download-archive (match archive-type
('flat
(string-append
"swh:1:dir:" (revision-directory revision)))
('git-bare
(string-append
"swh:1:rev:" (revision-id revision))))
output
#:archive-type archive-type
#:log-port log-port))
(#f
(format log-port
"SWH: revision ~s originating from ~a could not be found~%"
reference url)
#f)))
(define* (swh-download-directory-by-nar-hash hash algorithm output
#:key
(log-port (current-error-port)))
"Download from Software Heritage the directory with the given nar HASH for
ALGORITHM (a symbol such as 'sha256), and unpack it in OUTPUT. Return #t on
success and #f on failure.
This procedure uses the \"vault\", which contains \"cooked\" directories in
the form of tarballs. If the requested directory is not cooked yet, it will
wait until it becomes available, which could take several minutes."
(match (lookup-directory-by-nar-hash hash algorithm)
(#f
(format log-port
"SWH: directory with nar-~a hash ~a not found~%"
algorithm (bytevector->base16-string hash))
#f)
(swhid
(format log-port "SWH: found directory with nar-~a hash ~a at '~a'~%"
algorithm (bytevector->base16-string hash) swhid)
(swh-download-archive swhid output
#:archive-type 'flat ;SWHID denotes a directory
#:log-port log-port))))
