Su: Tutorial di Scheme [Contenuti][Indice]

Successivo: Packaging Workflows, Su: Impacchettamento [Contenuti][Indice]

2.1.1 Un pacchetto "Hello World"

La sezione "Definire i pacchetti" del manuale introduce le basi dell’impacchettamento con Guix (vedi Definire i pacchetti in Manuale di riferimento di GNU Guix). Nella sezione seguente, ripercorreremo in parte queste basi.

GNU Hello è un progetto fittizio che serve come esempio idiomatico per l’impacchettamento. Utilizza il sistema di compilazione GNU (./configure && make && make install). Guix fornisce già una definizione di pacchetto che è un esempio perfetto da cui partire. Puoi consultare la sua dichiarazione con guix edit hello dalla riga di comando. Vediamo come appare:

(define-public hello
 (package
 (name "hello")
 (version "2.10")
 (source (origin
 (method url-fetch )
 (uri (string-append "mirror://gnu/hello/hello-" version
 ".tar.gz"))
 (sha256
 (base32
 "0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i"))))
 (build-system gnu-build-system )
 (synopsis "Ciao, mondo GNU: Un esempio di pacchetto GNU")
 (description
 "GNU Hello stampa il messaggio \"Ciao, mondo!\" e poi esce. Serve come esempio di pratiche di codifica standard GNU. Come tale, supporta argomenti da riga di comando, più lingue, e così via.")
 (home-page "https://www.gnu.org/software/hello/")
 (license gpl3+)))

Come puoi vedere, la maggior parte è piuttosto semplice. Ma esaminiamo i campi insieme:

‘name’

Il nome del progetto. Usando le convenzioni di Scheme, preferiamo mantenerlo in minuscolo, senza trattini bassi e usando parole separate da trattini.

‘source’

Questo campo contiene una descrizione dell’origine del codice sorgente. Il record origin contiene questi campi:

1. Il metodo, qui url-fetch per scaricare via HTTP/FTP, ma altri metodi esistono, come git-fetch per i repository Git.
2. L’URI, che è tipicamente una posizione https:// per url-fetch. Qui lo speciale ‘mirror://gnu‘ si riferisce a un insieme di posizioni note, tutte utilizzabili da Guix per recuperare il sorgente, nel caso in cui alcune di esse fallissero.
3. La somma di controllo sha256 del file richiesto. Questo è essenziale per garantire che il sorgente non sia corrotto. Notare che Guix lavora con stringhe base32, da cui la chiamata alla funzione base32.

‘build-system’

È qui che il potere di astrazione fornito dal linguaggio Scheme brilla davvero: in questo caso, il gnu-build-system astrae le famose invocazioni di shell ./configure && make && make install. Altri sistemi di compilazione includono il trivial-build-system che non fa nulla e richiede al manutentore del pacchetto di programmare tutti i passaggi di compilazione, il python-build-system, il emacs-build-system e molti altri (vedi Sistemi di build in Manuale di riferimento di GNU Guix).

‘synopsis’

Dovrebbe essere un riassunto conciso di ciò che fa il pacchetto. Per molti pacchetti, uno slogan dalla home page del progetto può essere usato come sinossi.

‘description’

Come per la sinossi, va bene riutilizzare la descrizione del progetto dalla homepage. Notare che Guix usa la sintassi Texinfo.

‘home-page’

Usa HTTPS se disponibile.

‘license’

Vedere guix/licenses.scm nel sorgente del progetto per un elenco completo delle licenze disponibili.

È ora di compilare il nostro primo pacchetto! Niente di speciale per ora: ci atterremo a un fittizio my-hello, una copia della dichiarazione precedente.

Come per il rituale "Hello World" insegnato con la maggior parte dei linguaggi di programmazione, questo sarà probabilmente l’approccio più "manuale". Elaboreremo una configurazione ideale più tardi; per ora seguiremo la strada più semplice.

Salva quanto segue in un file my-hello.scm.

(use-modules (guix packages)
 (guix download)
 (guix build-system gnu)
 (guix licenses))
(package
 (name "my-hello")
 (version "2.10")
 (source (origin
 (method url-fetch )
 (uri (string-append "mirror://gnu/hello/hello-" version
 ".tar.gz"))
 (sha256
 (base32
 "0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i"))))
 (build-system gnu-build-system )
 (synopsis "Ciao, mondo Guix: Un esempio di pacchetto Guix personalizzato")
 (description
 "GNU Hello stampa il messaggio \"Ciao, mondo!\" e poi esce. Serve
come esempio delle pratiche di codifica standard di GNU. Come tale, supporta
argomenti da riga di comando, più linguaggi, e così via.")
 (home-page "https://www.gnu.org/software/hello/")
 (license gpl3+))

Spiegheremo il codice extra tra un momento.

Sentiti libero di giocare con i diversi valori dei vari campi. Se cambi la sorgente, dovrai aggiornare il checksum. Infatti, Guix si rifiuta di compilare qualsiasi cosa se il checksum fornito non corrisponde al checksum calcolato del codice sorgente. Per ottenere il checksum corretto della dichiarazione del pacchetto, dobbiamo scaricare la sorgente, calcolare il checksum sha256 e convertirlo in base32.

Fortunatamente, Guix può automatizzare questo compito per noi; tutto ciò di cui abbiamo bisogno è fornire l’URI:

$ guix download mirror://gnu/hello/hello-2.10.tar.gz
Inizio download di /tmp/guix-file.JLYgL7
Da https://ftpmirror.gnu.org/gnu/hello/hello-2.10.tar.gz...
redirezione a `https://mirror.ibcp.fr/pub/gnu/hello/hello-2.10.tar.gz'...
 ...10.tar.gz 709KiB 2.5MiB/s 00:00 [##################] 100.0%
/gnu/store/hbdalsf5lpf01x4dcknwx6xbn6n5km6k-hello-2.10.tar.gz
0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i

In questo caso specifico l’output ci dice quale mirror è stato scelto. Se il risultato del comando precedente non è lo stesso dello snippet sopra, aggiorna di conseguenza la tua dichiarazione my-hello.

Nota che i tarball dei pacchetti GNU sono dotati di una firma OpenPGP, quindi dovresti assolutamente controllare la firma di questo tarball con ‘gpg‘ per autenticarlo prima di procedere:

$ guix download mirror://gnu/hello/hello-2.10.tar.gz.sig
Inizio download di /tmp/guix-file.03tFfb
Da https://ftpmirror.gnu.org/gnu/hello/hello-2.10.tar.gz.sig...
redirezione a `https://ftp.igh.cnrs.fr/pub/gnu/hello/hello-2.10.tar.gz.sig'. ..
 ....tar.gz.sig 819B 1.2MiB/s 00:00 [##################] 100.0%
/gnu/store/rzs8wba9ka7grrmgcpfyxvs58mly0sx6-hello-2.10.tar.gz.sig
0q0v86n3y38z17rl146gdakw9xc4mcscpk8dscs412j22glrv9jf
$ gpg --verify /gnu/store/rzs8wba9ka7grrmgcpfyxvs58mly0sx6-hello-2.10.tar.gz.sig /gnu/store/hbdalsf5lpf01x4dcknwx6xbn6n5km6k-hello-2.10.tar.gz
gpg: Firma creata dom 16 nov 2014 13:08:37 CET
gpg: usando la chiave RSA A9553245FDE9B739
gpg: Buona firma da "Sami Kerola <kerolasa@iki.fi>" [sconosciuto]
gpg: alias "Sami Kerola (http://www.iki.fi/kerolasa/) <kerolasa@iki.fi>" [sconosciuto]
gpg: ATTENZIONE: Questa chiave non è certificata con una firma fidata!
gpg: Non c'è alcuna indicazione che la firma appartenga al proprietario.
Impronta della chiave primaria: 8ED3 96E3 7E38 D471 A005 30D3 A955 3245 FDE9 B739

Puoi quindi eseguire felicemente

$ guix package --install-from-file=my-hello.scm

Ora dovresti avere my-hello nel tuo profilo!

$ guix package --list-installed=my-hello
my-hello	2.10	out
/gnu/store/f1db2mfm8syb8qvc357c53slbvf1g9m9-my-hello-2.10

Siamo andati il più lontano possibile senza alcuna conoscenza di Scheme. Prima di passare a pacchetti più complessi, ora è il momento giusto per rispolverare la tua conoscenza di Scheme. Vedi Un corso intensivo di Scheme per mettersi al passo.

2.1.2 Configurazione

Nel resto di questo capitolo faremo affidamento su alcune conoscenze di base di programmazione in Scheme. Ora analizziamo le diverse possibili configurazioni per lavorare sui pacchetti Guix.

Ci sono diversi modi per configurare un ambiente di pacchettizzazione Guix.

Ti consigliamo di lavorare direttamente sul checkout del sorgente di Guix poiché rende più facile per tutti contribuire al progetto.

Ma prima, diamo un’occhiata ad altre possibilità.

• File locale
• Canali
• Modifica diretta dal checkout

 -f, --install-from-file=FILE
 installa il pacchetto a cui il codice all'interno di FILE
 valuta

mkdir ~/my-channel

(define-module (my-hello)
 #:use-module (guix licenses)
 #:use-module (guix packages)
 #:use-module (guix build-system gnu)
 #:use-module (guix download))
(define-public my-hello
 (package
 (name "my-hello")
 (version "2.10")
 (source (origin
 (method url-fetch )
 (uri (string-append "mirror://gnu/hello/hello-" version
 ".tar.gz"))
 (sha256
 (base32
 "0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i"))))
 (build-system gnu-build-system )
 (synopsis "Ciao, mondo Guix: Un esempio di pacchetto Guix personalizzato")
 (description
 "GNU Hello stampa il messaggio \"Ciao, mondo!\" e poi esce. Serve come esempio delle pratiche di codifica standard di GNU. Come tale, supporta
argomenti da riga di comando, più linguaggi, e così via.")
 (home-page "https://www.gnu.org/software/hello/")
 (license gpl3+)))

;; ...
(define-public my-hello
 ;; ...
 )
my-hello

guix show -L ~/my-channel my-hello
guix build -L ~/my-channel my-hello

cd ~/my-channel
git init
git add my-hello.scm
git commit -m "Primo commit del mio canale."

(append (list (channel
 (name 'my-channel)
 (url (string-append "file://" (getenv "HOME")
 "/my-channel"))))
 %default-channels)

$ git clone https://git.guix.gnu.org/guix.git

2.1.3 Esempio esteso

L’esempio "Ciao Mondo" sopra è il più semplice possibile. I pacchetti possono essere più complessi di così e Guix può gestire scenari più avanzati. Diamo un’occhiata a un altro pacchetto più sofisticato (leggermente modificato dalla fonte):

(define-module (gnu packages version-control)
 #:use-module ((guix licenses) #:prefix license:)
 #:use-module (guix utils)
 #:use-module (guix packages)
 #:use-module (guix git-download)
 #:use-module (guix build-system cmake)
 #:use-module (gnu packages)
 #:use-module (gnu packages compression)
 #:use-module (gnu packages pkg-config)
 #:use-module (gnu packages python)
 #:use-module (gnu packages ssh)
 #:use-module (gnu packages tls)
 #:use-module (gnu packages web))
(define-public my-libgit2
 (let ((commit "e98d0a37c93574d2c6107bf7f31140b548c6a7bf")
 (revision "1"))
 (package
 (name "my-libgit2")
 (version (git-version "0.26.6" revision commit))
 (source (origin
 (method git-fetch )
 (uri (git-reference
 (url "https://github.com/libgit2/libgit2/")
 (commit commit)))
 (file-name (git-file-name name version ))
 (sha256
 (base32
 "17pjvprmdrx4h6bb1hhc98w9qi6ki7yl57f090n9kbhswxqfs7s3"))
 (patches (search-patches "libgit2-mtime-0.patch"))
 (modules '((guix build utils)))
 ;; Rimuovi software in bundle.
 (snippet '(delete-file-recursively "deps"))))
 (build-system cmake-build-system )
 (outputs '("out" "debug"))
 (arguments
 `(#:tests? #true ; Esegui la suite di test (questo è il valore predefinito)
 #:configure-flags '("-DUSE_SHA1DC=ON") ; Rilevamento collisioni SHA-1
 #:phases
 (modify-phases %standard-phases
 (add-after 'unpack 'fix-hardcoded-paths
 (lambda _
 (substitute* "tests/repo/init.c"
 (("#!/bin/sh") (string-append "#!" (which "sh"))))
 (substitute* "tests/clar/fs.h"
 (("/bin/cp") (which "cp"))
 (("/bin/rm") (which "rm")))))
 ;; Esegui i controlli in modo più verboso.
 (replace 'check
 (lambda* (#:key tests? #:allow-other-keys)
 (when tests?
 (invoke "./libgit2_clar" "-v" "-Q"))))
 (add-after 'unpack 'make-files-writable-for-tests
 (lambda _ (for-each make-file-writable (find-files ".")))))))
 (inputs
 (list libssh2 http-parser python-wrapper))
 (native-inputs
 (list pkg-config))
 (propagated-inputs
 ;; Queste due librerie sono in 'Requires.private' in libgit2.pc.
 (list openssl zlib))
 (home-page "https://libgit2.github.com/")
 (synopsis "Libreria che fornisce i metodi core di Git")
 (description
 "Libgit2 è un'implementazione portatile e pura in C dei metodi core di Git
fornita come libreria rientrante collegabile con una solida API, che consente di
scrivere applicazioni Git personalizzate a velocità nativa in qualsiasi linguaggio con binding.")
 ;; GPLv2 con eccezione di linking
 (license license:gpl2))))

(Nei casi in cui si desidera solo modificare alcuni campi da una definizione di pacchetto, si dovrebbe fare affidamento sull’ereditarietà invece di copiare e incollare tutto. Vedi sotto.)

Discutiamo questi campi in dettaglio.

• Metodo git-fetch
• Frammenti
• Input
• Prodotti
• Argomenti del sistema di compilazione
• Code staging
• Funzioni di utilità
• Prefisso modulo

git clone https://github.com/libgit2/libgit2/
cd libgit2
git checkout v0.26.6
guix hash -rx .

#:make-flags (list (string-append "prefix=" (assoc-ref %outputs "out"))
 "CC=gcc")

$ make CC=gcc prefix=/gnu/store/...-<out>

#:configure-flags '("-DUSE_SHA1DC=ON")

(define %standard-phases
 ;; Fasi di compilazione standard, come un elenco di coppie simbolo/procedura.
 (let-syntax ((phases (syntax-rules ()
 ((_ p ... ) `((p . ,p) ... )))))
 (phases set-SOURCE-DATE-EPOCH set-paths install-locale unpack
 bootstrap
 patch-usr-bin-file
 patch-source-shebangs configure patch-generated-file-shebangs
 build check install
 patch-shebangs strip
 validate-runpath
 validate-documentation-location
 delete-info-dir-file
 patch-dot-desktop-files
 make-dynamic-linker-cache
 install-license-files
 reset-gzip-timestamps
 compress-documentation)))

(add-to-load-path "/path/to/guix/checkout")
,use (guix build gnu-build-system )
(map car %standard-phases)
⇒ (set-SOURCE-DATE-EPOCH set-paths install-locale unpack bootstrap patch-usr-bin-file patch-source-shebangs configure patch-generated-file-shebangs build check install patch-shebangs strip validate-runpath validate-documentation-location delete-info-dir-file patch-dot-desktop-files make-dynamic-linker-cache install-license-files reset-gzip-timestamps compress-documentation)

(define* (unpack #:key source #:allow-other-keys)
 "Decomprime SOURCE nella directory di lavoro e cambia directory all'interno del
sorgente. Quando SOURCE è una directory, copiala in una sottodirectory della
directory di lavoro corrente."
 (if (file-is-directory? source)
 (begin
 (mkdir "source")
 (chdir "source")
 ;; Preserva i timestamp (impostati sull'Epoch) sull'albero copiato in modo che
 ;; le cose funzionino in modo deterministico.
 (copy-recursively source "."
 #:keep-mtime? #t)
 ;; Rendi scrivibili i file del checkout sorgente, per comodità.
 (for-each (lambda (f)
 (false-if-exception (make-file-writable f)))
 (find-files ".")))
 (begin
 (cond
 ((string-suffix? ".zip" source)
 (invoke "unzip" source))
 ((tarball? source)
 (invoke "tar" "xvf" source))
 (else
 (let ((name (strip-store-file-name source))
 (command (compressor source)))
 (copy-file source name)
 (when command
 (invoke command "--decompress" name)))))
 ;; Tenta di cambiare nella directory figlia.
 (and=> (first-subdirectory ".") chdir ))))

(lambda* (#:key inputs outputs #:allow-other-keys)
 (let ((bash-directory (assoc-ref inputs "bash"))
 (output-directory (assoc-ref outputs "out"))
 (doc-directory (assoc-ref outputs "doc")))
 ;; ... ))

2.1.4 Altri sistemi di build

Quanto abbiamo visto finora copre la maggior parte dei pacchetti che utilizzano un sistema di compilazione diverso da trivial-build-system. Quest’ultimo non automatizza nulla e ti lascia il compito di compilare tutto manualmente. Questo può essere più impegnativo e per ora non lo tratteremo qui, ma fortunatamente è raramente necessario ricorrere a questo sistema.

Per gli altri sistemi di compilazione, come ASDF, Emacs, Perl, Ruby e molti altri, il processo è molto simile al sistema di compilazione GNU, ad eccezione di alcuni argomenti specializzati.

Vedi Sistemi di build in Manuale di riferimento di GNU Guix, per maggiori informazioni sui sistemi di compilazione, o controlla il codice sorgente nelle directory ‘$GUIX_CHECKOUT/guix/build’ e ‘$GUIX_CHECKOUT/guix/build-system’.

2.1.5 Definizione di pacchetto programmabile e automatizzata

Non possiamo ripeterlo abbastanza: avere un linguaggio di programmazione completo a portata di mano ci dà potere in modi che vanno ben oltre la tradizionale gestione dei pacchetti.

Illustriamo questo con alcune fantastiche funzionalità di Guix!

• Importatori ricorsivi
• Aggiornamento automatico
• Ereditarietà

$ guix import cran --recursive walrus
(define-public r-mc2d
 ; ...
 (license gpl2+)))
(define-public r-jmvcore
 ; ...
 (license gpl2+)))
(define-public r-wrs2
 ; ...
 (license gpl3)))
(define-public r-walrus
 (package
 (name "r-walrus")
 (version "1.0.3")
 (source
 (origin
 (method url-fetch)
 (uri (cran-uri "walrus" version))
 (sha256
 (base32
 "1nk2glcvy4hyksl5ipq2mz8jy4fss90hx6cq98m3w96kzjni6jjj"))))
 (build-system r-build-system)
 (propagated-inputs
 (list r-ggplot2 r-jmvcore r-r6 r-wrs2))
 (home-page "https://github.com/jamovi/walrus")
 (synopsis "Metodi Statistici Robusti")
 (description
 "Questo pacchetto fornisce una cassetta degli attrezzi di comuni test statistici robusti,
inclusi descrittori robusti, t-test robusti e ANOVA robusta.
È disponibile anche come modulo per 'jamovi' (vedere
<https://www.jamovi.org> per maggiori informazioni). Walrus si basa sul
pacchetto WRS2 di Patrick Mair, che a sua volta si basa sugli script e sul
lavoro di Rand Wilcox. Queste analisi sono descritte in dettaglio nel libro
'Introduction to Robust Estimation & Hypothesis Testing'.")
 (license gpl3)))

$ guix refresh hello

$ guix refresh hello --update

(define-public adwaita-icon-theme
 (package (inherit gnome-icon-theme)
 (name "adwaita-icon-theme")
 (version "3.26.1")
 (source (origin
 (method url-fetch )
 (uri (string-append "mirror://gnome/sources/" name "/"
 (version-major+minor version ) "/"
 name "-" version ".tar.xz"))
 (sha256
 (base32
 "17fpahgh5dyckgz7rwqvzgnhx53cx9kr2xw0szprc6bnqy977fi8"))))
 (native-inputs (list `(,gtk+ "bin")))))

2.1.6 Ottenere aiuto

Purtroppo, alcune applicazioni possono essere difficili da impacchettare. A volte hanno bisogno di una patch per funzionare con la gerarchia del file system non standard imposta dallo store. A volte i test non vengono eseguiti correttamente. (Possono essere saltati ma questo non è raccomandato.) Altre volte il pacchetto risultante non sarà riproducibile.

Se dovessi trovarti bloccato, incapace di capire come risolvere qualsiasi tipo di problema di packaging, non esitare a chiedere aiuto alla comunità.

Vedi la homepage di Guix per informazioni sulle mailing list, IRC, ecc.

2.1.7 Conclusione

Questo tutorial è stato una vetrina della sofisticata gestione dei pacchetti di cui Guix si vanta. A questo punto abbiamo in gran parte limitato questa introduzione al gnu-build-system che è un livello di astrazione fondamentale su cui si basano astrazioni più avanzate.

Da dove proseguiamo? Successivamente dovremmo dissezionare le viscere del sistema di compilazione rimuovendo tutte le astrazioni, usando il trivial-build-system: questo dovrebbe darci una comprensione approfondita del processo prima di indagare su alcune tecniche di packaging più avanzate e casi limite.

Altre funzionalità degne di esplorazione sono le capacità di editing e debugging interattivi di Guix fornite dal Guile REPL.

Queste fantasiose funzionalità sono completamente opzionali e possono aspettare; ora è un buon momento per prendersi una meritata pausa. Con quanto abbiamo introdotto qui dovresti essere ben attrezzato per impacchettare molti programmi. Puoi iniziare subito e speriamo di vedere i tuoi contributi presto!

2.1.8 Riferimenti

• La reference del pacchetto nel manuale
• la guida di hacking di Pjotr a GNU Guix
• “GNU Guix: Package without a scheme!”, di Andreas Enge

Precedente: Tutorial sull’Impacchettamento, Su: Impacchettamento [Contenuti][Indice]

2.2.1 Packaging Rust Crates

In preparation, add the following packages to our environment:

$ guix shell rust rust:cargo cargo-audit cargo-license

• Common Workflow for Rust Packaging
• Cargo Workspaces and Development Snapshots
• Using Rust Libraries in Other Build Systems

(define-public niri
 (package
 (name "niri")
 (version "25.02")
 (source (origin
 (method git-fetch )
 (uri (git-reference
 (url "https://github.com/YaLTeR/niri")
 (commit (string-append "v" version ))))
 (file-name (git-file-name name version ))
 (sha256
 (base32
 "0vzskaalcz6pcml687n54adjddzgf5r07gggc4fhfsa08h1wfd4r"))))
 (build-system cargo-build-system )
 (arguments
 (list #:install-source? #f
 #:phases
 #~(modify-phases %standard-phases
 (add-after 'unpack 'use-guix-vendored-dependencies
 (lambda _
 (substitute* "Cargo.toml"
 (("# version =.*")
 "version = \"*\"")
 (("git.*optional")
 "version = \"*\", optional")
 (("^git = .*")
 "")))))))
 (native-inputs
 (list pkg-config))
 (inputs
 (cons* clang
 libdisplay-info
 libinput-minimal
 libseat
 libxkbcommon
 mesa
 pango
 pipewire
 wayland
 (cargo-inputs 'niri)))
 (home-page "https://github.com/YaLTeR/niri")
 (synopsis "Scrollable-tiling Wayland compositor")
 (description
 "Niri is a scrollable-tiling Wayland compositor which arranges windows in a
scrollable format. It is considered stable for daily use and performs most
functions expected of a Wayland compositor.")
 (license license:gpl3+)))

(define-public rust-pipewire-0.8.0.fd3d8f7
 (let ((commit "fd3d8f7861a29c2eeaa4c393402e013578bb36d9")
 (revision "0"))
 (package
 (name "rust-pipewire")
 (version (git-version "0.8.0" revision commit))
 (source
 (origin
 (method git-fetch )
 (uri (git-reference
 (url "https://gitlab.freedesktop.org/pipewire/pipewire-rs.git")
 (commit commit)))
 (file-name (git-file-name name version ))
 (sha256
 (base32 "1hzyhz7xg0mz8a5y9j6yil513p1m610q3j9pzf6q55vdh5mcn79v"))))
 (build-system cargo-build-system )
 (arguments
 (list #:skip-build? #t
 #:cargo-package-crates
 ''("libspa-sys" "libspa" "pipewire-sys" "pipewire")))
 (inputs (cargo-inputs 'rust-pipewire-0.8.0.fd3d8f7))
 (home-page "https://pipewire.org/")
 (synopsis "Rust bindings for PipeWire")
 (description "This package provides Rust bindings for PipeWire.")
 (license license:expat))))

(define rust-pipewire-0.8.0.fd3d8f7 rust-pipewire-0.8.0.fd3d8f7)
(define rust-pipewire-sys-0.8.0.fd3d8f7 rust-pipewire-0.8.0.fd3d8f7)
...
(define rust-libspa-0.8.0.fd3d8f7 rust-pipewire-0.8.0.fd3d8f7)
(define rust-libspa-sys-0.8.0.fd3d8f7 rust-pipewire-0.8.0.fd3d8f7)

(define-public libchewing
 (package
 (name "libchewing")
 (version "0.9.1")
 (source
 (origin
 (method git-fetch )
 (uri (git-reference
 (url "https://github.com/chewing/libchewing")
 (commit (string-append "v" version ))))
 (file-name (git-file-name name version ))
 (sha256
 (base32 "0gh64wvrk5pn0fhmpvj1j99d5g7f7697rk96zbkc8l72yjr819z5"))))
 (build-system cmake-build-system )
 (arguments
 (list #:imported-modules
 (append %cmake-build-system-modules
 %cargo-build-system-modules)
 #:modules
 '(((guix build cargo-build-system ) #:prefix cargo:)
 (guix build cmake-build-system )
 (guix build utils))
 #:phases
 #~(modify-phases %standard-phases
 (add-after 'unpack 'prepare-cargo-build-system
 (lambda args
 (for-each
 (lambda (phase)
 (format #t "Running cargo phase: ~a~%" phase)
 (apply (assoc-ref cargo:%standard-phases phase)
 ;; For cross-compilation.
 #:cargo-target #$(cargo-triplet)
 args))
 '(unpack-rust-crates
 configure
 check-for-pregenerated-files
 patch-cargo-checksums)))))))
 (native-inputs
 (append
 (list rust `(,rust "cargo") )
 ;; For cross-compilation.
 (or (and=> (%current-target-system)
 (compose list make-rust-sysroot))
 '())))
 (inputs
 (cons* corrosion ncurses sqlite (cargo-inputs 'libchewing)))
 (synopsis "Chinese phonetic input method")
 (description "Chewing is an intelligent phonetic (Zhuyin/Bopomofo) input
method, one of the most popular choices for Traditional Chinese users.")
 (home-page "https://chewing.im/")
 (license license:lgpl2.1+)))

Successivo: Personalizzazione del kernel, Su: Configurazione di sistema [Contenuti][Indice]

(define (auto-login-to-tty config tty user)
 (if (string=? tty (mingetty-configuration-tty config))
 (mingetty-configuration
 (inherit config)
 (auto-login user))
 config))
(define %my-services
 (modify-services %base-services
 ;; ...
 (mingetty-service-type config =>
 (auto-login-to-tty
 config "tty3" "alice"))))
(operating-system
 ;; ...
 (services %my-services))

Successivo: API immagine di Sistema Guix, Precedente: Accesso automatico a una TTY specifica, Su: Configurazione di sistema [Contenuti][Indice]

(define* (make-linux-libre* version gnu-revision source supported-systems
 #:key
 (extra-version #f)
 ;; Una funzione che accetta un'architettura e una variante.
 ;; Vedi kernel-config per un esempio.
 (configuration-file #f)
 (defconfig "defconfig")
 (extra-options (default-extra-linux-options version )))
 ... )

(define-public linux-libre-5.15
 (make-linux-libre* linux-libre-5.15-version
 linux-libre-5.15-gnu-revision
 linux-libre-5.15-source
 '("x86_64-linux" "i686-linux" "armhf-linux"
 "aarch64-linux" "riscv64-linux")
 #:configuration-file kernel-config))

(define-public my-linux-libre
 (package
 (inherit (customize-linux
 #:linux linux-libre
 #:defconfig
 (local-file "defconfig")))
 (name "my-linux-libre")))

(define (default-extra-linux-options version )
 `(;; https://lists.gnu.org/archive/html/guix-devel/2014-04/msg00039.html
 ("CONFIG_DEVPTS_MULTIPLE_INSTANCES" . #true)
 ;; Moduli richiesti per initrd:
 ("CONFIG_NET_9P" . m)
 ("CONFIG_NET_9P_VIRTIO" . m)
 ("CONFIG_VIRTIO_BLK" . m)
 ("CONFIG_VIRTIO_NET" . m)
 ("CONFIG_VIRTIO_PCI" . m)
 ("CONFIG_VIRTIO_BALLOON" . m)
 ("CONFIG_VIRTIO_MMIO" . m)
 ("CONFIG_FUSE_FS" . m)
 ("CONFIG_CIFS" . m)
 ("CONFIG_9P_FS" . m)))
(define (config->string options)
 (string-join (map (match-lambda
 ((option . 'm)
 (string-append option "=m"))
 ((option . #true)
 (string-append option "=y"))
 ((option . #false)
 (string-append option "=n")))
 options)
 "\n"))

;; L'aggiunta funziona anche se l'opzione non era presente nel
;; file. L'ultima prevale se duplicata.
(let ((port (open-file ".config" "a"))
 (extra-configuration ,(config->string extra-options)))
 (display extra-configuration port)
 (close-port port))
(invoke "make" "oldconfig")

(define %macbook41-full-config
 (append %macbook41-config-options
 %file-systems
 %efi-support
 %emulation
 ((@@ (gnu packages linux) default-extra-linux-options) version )))
(define-public linux-libre-macbook41
 ;; XXX: Accedere alla procedura interna 'make-linux-libre*', che è
 ;; privata e non esportata, e soggetta a modifiche future.
 ((@@ (gnu packages linux) make-linux-libre*)
 (@@ (gnu packages linux) linux-libre-version)
 (@@ (gnu packages linux) linux-libre-gnu-revision)
 (@@ (gnu packages linux) linux-libre-source)
 '("x86_64-linux")
 #:extra-version "macbook41"
 #:extra-options %macbook41-config-options))

tar xf $(guix build linux-libre --source)

guix shell -D linux-libre -- make localmodconfig

il modulo pcspkr non aveva configurazioni CONFIG_INPUT_PCSPKR

CONFIG_INPUT_PCSPKR=m
CONFIG_VIRTIO=m

Successivo: Utilizzo di chiavi di sicurezza, Precedente: Personalizzazione del kernel, Su: Configurazione di sistema [Contenuti][Indice]

(define-record-type* <image>
 image make-image
 image?
 (name image-name ;simbolo
 (default #f))
 (format image-format) ;simbolo
 (target image-target
 (default #f))
 (size image-size ;dimensione in byte come intero
 (default 'guess))
 (operating-system image-operating-system ;<operating-system>
 (default #f))
 (partitions image-partitions ;lista di <partition>
 (default '()))
 (compression? image-compression? ;booleano
 (default #t))
 (volatile-root? image-volatile-root? ;booleano
 (default #t))
 (substitutable? image-substitutable? ;booleano
 (default #t)))

(define pine64-barebones-os
 (operating-system
 (host-name "vignemale")
 (timezone "Europe/Paris")
 (locale "en_US.utf8")
 (bootloader (bootloader-configuration
 (bootloader u-boot-pine64-lts-bootloader)
 (targets '("/dev/vda"))))
 (initrd-modules '())
 (kernel linux-libre-arm64-generic)
 (file-systems (cons (file-system
 (device (file-system-label "my-root"))
 (mount-point "/")
 (type "ext4"))
 %base-file-systems ))
 (services (cons (service agetty-service-type
 (agetty-configuration
 (extra-options '("-L")) ; nessun rilevamento portante
 (baud-rate "115200")
 (term "vt100")
 (tty "ttyS0")))
 %base-services ))))

(define pine64-image-type
 (image-type
 (name 'pine64-raw)
 (constructor (cut image-with-os arm64-disk-image <>))))

(define-record-type* <image-type>
 image-type make-image-type
 image-type?
 (name image-type-name) ;simbolo
 (constructor image-type-constructor)) ;<operating-system> -> <image>

guix system image my-os.scm

guix system image --image-type=pine64-raw my-os.scm

(image
 (format 'disk-image)
 (target "aarch64-linux-gnu")
 (operating-system my-os)
 (partitions
 (list (partition
 (inherit root-partition)
 (offset root-offset)))))

mathieu@cervin:~$ guix system --list-image-types
I tipi di immagine disponibili sono:
 - unmatched-raw
 - rock64-raw
 - pinebook-pro-raw
 - pine64-raw
 - novena-raw
 - hurd-raw
 - hurd-qcow2
 - qcow2
 - iso9660
 - uncompressed-iso9660
 - tarball
 - efi-raw
 - mbr-raw
 - docker
 - wsl2
 - raw-with-offset
 - efi32-raw

(use-modules (gnu services linux)
 (gnu system images pine64))
(let ((base-os pine64-barebones-os))
 (operating-system
 (inherit base-os)
 (timezone "America/Indiana/Indianapolis")
 (services
 (cons
 (service earlyoom-service-type
 (earlyoom-configuration
 (prefer-regexp "icecat|chromium")))
 (operating-system-user-services base-os)))))

guix system image --image-type=pine64-raw my-pine-os.scm

guix system image --image-type=hurd-raw my-hurd-os.scm

guix system image --image-type=hurd-qcow2 my-hurd-os.scm

Successivo: Processo mcron per DNS dinamico, Precedente: API immagine di Sistema Guix, Su: Configurazione di sistema [Contenuti][Indice]

3.4.1 Configurazione per l’uso come autenticatore a due fattori (2FA)

Per essere utilizzabile, le regole udev del sistema dovrebbero essere estese con regole specifiche per la chiave. Il seguente mostra come estendere le tue regole udev con il file di regole udev lib/udev/rules.d/70-u2f.rules fornito dal pacchetto libfido2 dal modulo (gnu packages security-token) e aggiungere il tuo utente al gruppo ‘"plugdev"’ che utilizza:

(use-package-modules ... security-token ... )
...
(operating-system
 ...
 (users (cons* (user-account
 (name "tuo-utente")
 (group "users")
 (supplementary-groups
		'("wheel" "netdev" "audio" "video"
 "plugdev")) ;<- gruppo di sistema aggiunto
 (home-directory "/home/tuo-utente"))
 %base-user-accounts ))
 ...
 (services
 (cons*
 ...
 (udev-rules-service 'fido2 libfido2 #:groups '("plugdev")))))

Dopo aver riconfigurato il sistema e aver effettuato nuovamente l’accesso alla sessione grafica in modo che il nuovo gruppo sia effettivo per il tuo utente, puoi verificare che la tua chiave sia utilizzabile avviando:

guix shell ungoogled-chromium -- chromium chrome://settings/securityKeys

e verificando che la chiave di sicurezza possa essere resettata tramite il menu “Reset your security key”. Se funziona, congratulazioni, la tua chiave di sicurezza è pronta per essere utilizzata con applicazioni che supportano l’autenticazione a due fattori (2FA).

3.4.2 Disabilitazione della generazione di codici OTP per una Yubikey

Se utilizzi una chiave di sicurezza Yubikey e sei irritato dai codici OTP spuri che genera quando tocchi involontariamente la chiave (ad esempio, facendoti diventare uno spammer nel canale ‘#guix’ mentre discuti dal tuo client IRC preferito!), puoi disabilitarlo tramite il seguente comando ykman:

guix shell python-yubikey-manager -- ykman config usb --force --disable OTP

In alternativa, potresti usare il comando ykman-gui fornito dal pacchetto yubikey-manager-qt e disabilitare completamente l’applicazione ‘OTP’ per l’interfaccia USB oppure, dalla vista ‘Applications -> OTP’, eliminare la configurazione dello slot 1, che viene preconfigurata con l’applicazione Yubico OTP.

3.4.3 Richiedere una Yubikey per aprire un database KeePassXC

L’applicazione KeePassXC, gestore di password, supporta le Yubikey, ma richiede l’installazione di regole udev per il tuo sistema Guix e una certa configurazione dell’applicazione Yubico OTP sulla chiave.

Il file di regole udev necessario proviene dal pacchetto yubikey-personalization, e può essere installato così:

(use-package-modules ... security-token ... )
...
(operating-system
 ...
 (services
 (cons*
 ...
 (udev-rules-service 'yubikey yubikey-personalization))))

Dopo aver riconfigurato il sistema (e ricollegato la tua Yubikey), dovrai poi configurare l’applicazione di sfida/risposta OTP della tua Yubikey sullo slot 2, che è ciò che KeePassXC usa. È facile farlo tramite lo strumento di configurazione grafica Yubikey Manager, che può essere invocato con:

guix shell yubikey-manager-qt -- ykman-gui

Innanzitutto, assicurati che ‘OTP’ sia abilitato nella scheda ‘Interfacce’, quindi vai a ‘Applicazioni -> OTP’ e fai clic sul pulsante ‘Configura’ nella sezione ‘Tocco lungo (Slot 2)’. Seleziona ‘Challenge-response’, inserisci o genera una chiave segreta e fai clic sul pulsante ‘Fine’. Se hai una seconda Yubikey che desideri utilizzare come backup, dovresti configurarla nello stesso modo, utilizzando la stessa chiave segreta.

La tua Yubikey dovrebbe ora essere rilevata da KeePassXC. Può essere aggiunta a un database navigando nel menu ‘Database -> Sicurezza database...’ di KeePassXC, quindi facendo clic sul pulsante ‘Aggiungi protezione aggiuntiva...’, quindi su ‘Aggiungi Challenge-Response’, selezionando la chiave di sicurezza dal menu a discesa e facendo clic sul pulsante ‘OK’ per completare la configurazione.

Successivo: Connessione a una VPN Wireguard, Precedente: Utilizzo di chiavi di sicurezza, Su: Configurazione di sistema [Contenuti][Indice]

(define duckdns-job
 ;; Aggiorna l'IP del dominio personale ogni 5 minuti.
 #~(job '(next-minute (range 0 60 5))
	 #$(program-file
 "duckdns-update"
 (with-extensions (list guile-gnutls) ;richiesto da (web client)
 #~(begin
 (use-modules (ice-9 textual-ports)
 (web client))
 (let ((token (string-trim-both
 (call-with-input-file "/etc/duckdns/DOMAIN.token"
 get-string-all )))
 (query-template (string-append "https://www.duckdns.org/"
 "update?domains=DOMAIN"
 "&token=~a&ip=")))
 (http-get (format #f query-template token))))))
 "duckdns-update"
 #:user "nobody"))

(operating-system
 (services
 (cons* (service mcron-service-type
 (mcron-configuration
 (jobs (list duckdns-job ... ))))
 ...
 %base-services )))

Successivo: Personalizzazione di un Window Manager, Precedente: Processo mcron per DNS dinamico, Su: Configurazione di sistema [Contenuti][Indice]

(use-modules (gnu))
(use-service-modules desktop)
(use-package-modules vpn)
(operating-system
 ;; ...
 (services (cons (simple-service 'wireguard-module
 kernel-module-loader-service-type
 '("wireguard"))
 %desktop-services ))
 (packages (cons wireguard-tools %base-packages))
 (kernel-loadable-modules (list wireguard-linux-compat)))

3.6.1 Utilizzo degli strumenti Wireguard

Per testare la tua configurazione Wireguard è comodo usare wg-quick. Basta dargli un file di configurazione wg-quick up ./wg0.conf; o metterlo in /etc/wireguard ed eseguire wg-quick up wg0 invece.

Nota: Si noti che l’autore ha descritto questo comando come: "[...] uno script bash molto veloce e sporco [...]".

3.6.2 Utilizzo di NetworkManager

Grazie al supporto di NetworkManager per Wireguard, possiamo connetterci alla nostra VPN usando il comando nmcli. Fino a questo punto, questa guida presuppone che stai usando il servizio Network Manager fornito da %desktop-services. Altrimenti devi regolare l’elenco dei tuoi servizi per caricare network-manager-service-type e riconfigurare il tuo sistema Guix.

Per importare la tua configurazione VPN, esegui il comando nmcli import:

# nmcli connection import type wireguard file wg0.conf
Connessione 'wg0' (edbee261-aa5a-42db-b032-6c7757c60fde) aggiunta con successo

Questo creerà un file di configurazione in /etc/NetworkManager/ wg0.nmconnection. Quindi connettiti al server Wireguard:

$ nmcli connection up wg0
Connessione attivata con successo (percorso attivo D-Bus: /org/freedesktop/
NetworkManager/ActiveConnection/6)

Per impostazione predefinita, NetworkManager si connetterà automaticamente all’avvio del sistema. Per modificare questo comportamento, devi modificare la tua configurazione:

# nmcli connection modify wg0 connection.autoconnect no

Per informazioni più specifiche su NetworkManager e Wireguard, vedi questo post di Thaller.

Successivo: Eseguire Guix su un Server Linode, Precedente: Connessione a una VPN Wireguard, Su: Configurazione di sistema [Contenuti][Indice]

3.7.1 StumpWM

Potresti installare StumpWM con un sistema Guix aggiungendo i pacchetti stumpwm e opzionalmente `(,stumpwm "lib") a un file di configurazione di sistema, ad esempio: /etc/config.scm.

Una configurazione di esempio può apparire così:

(use-modules (gnu))
(use-package-modules wm)
(operating-system
 ;; ...
 (packages (append (list sbcl stumpwm `(,stumpwm "lib"))
 %base-packages)))

Per impostazione predefinita StumpWM utilizza i font X11, che potrebbero essere piccoli o pixelati sul tuo sistema. Puoi risolvere questo problema installando il modulo Lisp di StumpWM contrib sbcl-ttf-fonts, aggiungendolo ai pacchetti di sistema Guix:

(use-modules (gnu))
(use-package-modules fonts wm)
(operating-system
 ;; ...
 (packages (append (list sbcl stumpwm `(,stumpwm "lib"))
 sbcl-ttf-fonts font-dejavu %base-packages)))

Quindi devi aggiungere il seguente codice a un file di configurazione di StumpWM ~/.stumpwm.d/init.lisp:

(require :ttf-fonts)
(setf xft:*font-dirs* '("/run/current-system/profile/share/fonts/"))
(setf clx-truetype:+font-cache-filename+ (concat (getenv "HOME")
 "/.fonts/font-cache.sexp"))
(xft:cache-fonts)
(set-font (make-instance 'xft:font :family "DejaVu Sans Mono"
 :subfamily "Book" :size 11))

3.7.2 Blocco sessione

A seconda del tuo ambiente, il blocco dello schermo della tua sessione potrebbe essere integrato o potresti doverlo configurare tu stesso. Se usi un ambiente desktop come GNOME o KDE, di solito è integrato. Se usi un semplice window manager come StumpWM o EXWM, potresti doverlo configurare tu stesso.

• Xorg

xss-lock -- slock &
exec stumpwm

(service screen-locker-service-type
 (screen-locker-configuration
 (name "slock")
 (program (file-append slock "/bin/slock"))))

Successivo: Eseguire Guix su un Server Kimsufi, Precedente: Personalizzazione di un Window Manager, Su: Configurazione di sistema [Contenuti][Indice]

ssh-keygen

cat ~/.ssh/<nomeutente>_rsa.pub

sudo apt-get install gpg
wget https://sv.gnu.org/people/viewgpg.php?user_id=15145 -qO - | gpg --import -
wget https://git.savannah.gnu.org/cgit/guix.git/plain/etc/guix-install.sh
chmod +x guix-install.sh
./guix-install.sh
guix pull

(use-modules (gnu)
 (guix modules))
(use-service-modules networking
 ssh)
(use-package-modules admin
 package-management
 ssh
 tls)
(operating-system
 (host-name "my-server")
 (timezone "America/New_York")
 (locale "en_US.UTF-8")
 ;; Questo codice strambo genererà il grub.cfg
 ;; senza installare il bootloader grub sul disco.
 (bootloader (bootloader-configuration
 (bootloader
 (bootloader
 (inherit grub-bootloader)
 (installer #~(const #true))))))
 (file-systems (cons (file-system
 (device "/dev/sda")
 (mount-point "/")
 (type "ext4"))
 %base-file-systems ))
 (swap-devices (list "/dev/sdb"))
 (initrd-modules (cons "virtio_scsi" ; Necessario per trovare il disco
 %base-initrd-modules ))
 (users (cons (user-account
 (name "janedoe")
 (group "users")
 ;; Aggiungendo l'account al gruppo "wheel"
 ;; lo rende un sudoer.
 (supplementary-groups '("wheel"))
 (home-directory "/home/janedoe"))
 %base-user-accounts ))
 (packages (cons* openssh-sans-x
 %base-packages))
 (services (cons*
 (service dhcp-client-service-type )
 (service openssh-service-type
 (openssh-configuration
 (openssh openssh-sans-x)
 (password-authentication? #false)
 (authorized-keys
 `(("janedoe" ,(local-file "janedoe_rsa.pub"))
 ("root" ,(local-file "janedoe_rsa.pub"))))))
 %base-services )))

(host-name "il-mio-server") ; sostituisci con il nome del tuo server
; se hai scelto un server linode fuori dagli Stati Uniti, allora
; usa tzselect per trovare una stringa di fuso orario corretta
(timezone "America/New_York") ; se necessario sostituisci il fuso orario
(name "janedoe") ; sostituisci con il tuo nome utente
("janedoe" ,(local-file "janedoe_rsa.pub")) ; sostituisci con la tua chiave ssh
("root" ,(local-file "janedoe_rsa.pub")) ; sostituisci con la tua chiave ssh

sftp root@<indirizzo ip del server remoto>
put /percorso/ai/files/<nomeutente>_rsa.pub .
put /percorso/ai/files/guix-config.scm .

mkdir /mnt/guix
mount /dev/sdc /mnt/guix

mkdir -p /mnt/guix/boot/grub
cp -r /boot/grub/* /mnt/guix/boot/grub/

guix system init guix-config.scm /mnt/guix

$ ssh root@<indirizzo ip del server>
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@  ATTENZIONE: L'IDENTIFICAZIONE DELL'HOST REMOTO È CAMBIATA! @@@@@@@@@@@@@@@@@@@@@@@@@@@@@ È POSSIBILE CHE QUALCUNO STIA FACENDO QUALCOSA DI BRUTTO!
Qualcuno potrebbe intercettarti in questo momento (attacco man-in-the-middle)!
È anche possibile che una chiave host sia stata appena cambiata.
L'impronta digitale della chiave ECDSA inviata dall'host remoto è
SHA256:0B+wp33w57AnKQuHCvQP0+ZdKaqYrI/kyU7CfVbS7R4.
Si prega di contattare l'amministratore del sistema.
Aggiungi la chiave host corretta in /home/joshua/.ssh/known_hosts per eliminare questo messaggio.
Chiave ECDSA offensiva in /home/joshua/.ssh/known_hosts:3
La chiave host ECDSA per 198.58.98.76 è cambiata e hai richiesto un controllo rigoroso.
Verifica della chiave host fallita.

ssh root@<indirizzo ip remoto>
passwd ; per la password di root
passwd <nomeutente> ; per la password utente

Successivo: Configurazione di un bind mount, Precedente: Eseguire Guix su un Server Linode, Su: Configurazione di sistema [Contenuti][Indice]

wget https://git.savannah.gnu.org/cgit/guix.git/plain/etc/guix-install.sh
chmod +x guix-install.sh
./guix-install.sh
guix pull

mdadm --stop /dev/md127
mdadm --zero-superblock /dev/sda2 /dev/sdb2

wipefs -a /dev/sda
wipefs -a /dev/sdb
parted /dev/sda --align=opt -s -m -- mklabel gpt
parted /dev/sda --align=opt -s -m -- \
 mkpart bios_grub 1049kb 512MiB \
 set 1 bios_grub on
parted /dev/sda --align=opt -s -m -- \
 mkpart primary 512MiB -512MiB
 set 2 raid on
parted /dev/sda --align=opt -s -m -- mkpart primary linux-swap 512MiB 100%
parted /dev/sdb --align=opt -s -m -- mklabel gpt
parted /dev/sdb --align=opt -s -m -- \
 mkpart bios_grub 1049kb 512MiB \
 set 1 bios_grub on
parted /dev/sdb --align=opt -s -m -- \
 mkpart primary 512MiB -512MiB \
 set 2 raid on
parted /dev/sdb --align=opt -s -m -- mkpart primary linux-swap 512MiB 100%

mdadm --create /dev/md127 --level=1 --raid-disks=2 \
 --metadata=0.90 /dev/sda2 /dev/sdb2

mkfs.ext4 /dev/sda1
mkfs.ext4 /dev/sdb1

mkfs.ext4 /dev/md127

mkswap /dev/sda3
swapon /dev/sda3
mkswap /dev/sdb3
swapon /dev/sdb3

mkdir /mnt/guix
mount /dev/md127 /mnt/guix

(use-modules (gnu) (guix))
(use-service-modules networking ssh vpn virtualization sysctl admin mcron)
(use-package-modules ssh tls tmux vpn virtualization)
(operating-system
 (host-name "kimsufi")
 (bootloader (bootloader-configuration
	 (bootloader grub-bootloader)
	 (targets (list "/dev/sda" "/dev/sdb"))
	 (terminal-outputs '(console))))
 ;; Aggiungi un modulo del kernel per RAID-1 (alias "mirror").
 (initrd-modules (cons* "raid1" %base-initrd-modules ))
 (mapped-devices
 (list (mapped-device
 (source (list "/dev/sda2" "/dev/sdb2"))
 (target "/dev/md127")
 (type raid-device-mapping ))))
 (swap-devices
 (list (swap-space
 (target "/dev/sda3"))
 (swap-space
 (target "/dev/sdb3"))))
 (issue
 ;; Contenuti predefiniti per /etc/issue.
 "\
Questo è il sistema GNU su Kimsufi. Benvenuto.\n")
 (file-systems (cons* (file-system
		 (mount-point "/")
		 (device "/dev/md127")
		 (type "ext4")
		 (dependencies mapped-devices))
		 %base-file-systems ))
 (users (cons (user-account
	 (name "guix")
	 (comment "guix")
	 (group "users")
	 (supplementary-groups '("wheel"))
	 (home-directory "/home/guix"))
	 %base-user-accounts ))
 (sudoers-file
 (plain-file "sudoers" "\
root ALL=(ALL) ALL
%wheel ALL=(ALL) ALL
guix ALL=(ALL) NOPASSWD:ALL\n"))
 ;; Pacchetti installati globalmente.
 (packages (cons* tmux gnutls wireguard-tools %base-packages))
 (services
 (cons*
 (service static-networking-service-type
	 (list (static-networking
		 (addresses (list (network-address
				 (device "enp3s0")
				 (value "indirizzo-ip-server/24"))))
		 (routes (list (network-route
				 (destination "default")
				 (gateway "server-gateway"))))
		 (name-servers '("213.186.33.99")))))
 (service unattended-upgrade-service-type )
 (service openssh-service-type
	 (openssh-configuration
	 (openssh openssh-sans-x)
	 (permit-root-login #f)
	 (authorized-keys
	 `(("guix" ,(plain-file "ssh-key-name.pub"
 "contenuto-chiave-pubblica-ssh"))))))
 (modify-services %base-services
 (sysctl-service-type
 config =>
 (sysctl-configuration
	(settings (append '(("net.ipv6.conf.all.autoconf" . "0")
			 ("net.ipv6.conf.all.accept_ra" . "0"))
			 %default-sysctl-settings ))))))))

guix install bash-static parted util-linux-with-udev coreutils guix

cd /mnt && \
mkdir -p bin etc gnu/store root/.guix-profile/ root/.config/guix/current \
 var/guix proc sys dev

cp /etc/resolv.conf etc/

mount --rbind /proc /mnt/proc
mount --rbind /sys /mnt/sys
mount --rbind /dev /mnt/dev
mount --rbind /var/guix/ var/guix/
mount --rbind /gnu/store gnu/store/
mount --rbind /root/.config/ root/.config/
mount --rbind /root/.guix-profile/bin/ bin
mount --rbind /root/.guix-profile root/.guix-profile/

chroot /mnt/ /bin/bash
guix system init /root/os.scm /guix

Successivo: Ottenere sostituti da Tor, Precedente: Eseguire Guix su un Server Kimsufi, Su: Configurazione di sistema [Contenuti][Indice]

(define source-drive ;; "source-drive" può essere chiamato come vuoi.
 (file-system
 (device (uuid "UUID va qui"))
 (mount-point "/percorso-al-disco-rotante-va-qui")
 (type "ext4"))) ;Assicurati di impostarlo al tipo appropriato per la tua unità.

;; "source-directory" può essere qualsiasi nome di variabile valido.
(define (%source-directory) "/percorso-al-disco-rotante-va-qui/tmp")

(file-systems (cons*
 ...<altre unità omesse per chiarezza>...
 ;; Deve corrispondere al nome che hai dato all'unità sorgente nella definizione precedente.
 source-drive
 (file-system
 ;; Assicurati che "source-directory" corrisponda alla tua definizione precedente.
 (device (%source-directory))
 (mount-point "/tmp")
 ;; Stiamo montando una cartella, non una partizione, quindi questo tipo deve essere "none"
 (type "none")
 (flags '(bind-mount))
 ;; Assicurati che "source-drive" corrisponda al nome che hai dato alla variabile per l'unità.
 (dependencies (list source-drive))
 )
 ...<altre unità omesse per chiarezza>...
 ))

Successivo: Configurazione di NGINX con Lua, Precedente: Configurazione di un bind mount, Su: Configurazione di sistema [Contenuti][Indice]

(use-modules (gnu))
(use-service-module base networking)
(operating-system
 ...
 (services
 (cons
 (service tor-service-type
 (tor-configuration
 (config-file (plain-file "tor-config"
 "HTTPTunnelPort 127.0.0.1:9250"))))
 (modify-services %base-services
 (guix-service-type
 config => (guix-configuration
 (inherit config)
 ;; servizio Onion di ci.guix.gnu.org
 (substitute-urls "\
https://4zwzi66wwdaalbhgnix55ea3ab4pvvw66ll2ow53kjub6se4q2bclcyd.onion")
 (http-proxy "http://localhost:9250")))))))

sudo herd set-http-proxy guix-daemon http://localhost:9250
guix build \
 --substitute-urls=https://4zwzi66wwdaalbhgnix55ea3ab4pvvw66ll2ow53kjub6se4q2bclcyd.onion …

Successivo: Server musicale con audio Bluetooth, Precedente: Ottenere sostituti da Tor, Su: Configurazione di sistema [Contenuti][Indice]

local shell = require "resty.shell"
local stdin = ""
local timeout = 1000 -- ms
local max_size = 4096 -- byte
local ok, stdout, stderr, reason, status =
 shell.run([[/run/current-system/profile/bin/ls /tmp]], stdin, timeout, max_size)
ngx.say(stdout)

(use-modules (gnu))
(use-service-modules #;... web)
(use-package-modules #;... lua)
(operating-system
 ;; ...
 (services
 ;; ...
 (service nginx-service-type
 (nginx-configuration
 (modules
 (list
 (file-append nginx-lua-module "/etc/nginx/modules/ngx_http_lua_module.so")))
 (lua-package-path (list lua-resty-core
 lua-resty-lrucache
 lua-resty-signal
 lua-tablepool
 lua-resty-shell))
 (lua-package-cpath (list lua-resty-signal))
 (server-blocks
 (list (nginx-server-configuration
 (server-name '("localhost"))
 (listen '("80"))
 (root "/etc")
 (locations (list
 (nginx-location-configuration
 (uri "/hello")
 (body (list #~(format #f "content_by_lua_file ~s;"
 #$(local-file "index.lua"))))))))))))))

Precedente: Configurazione di NGINX con Lua, Su: Configurazione di sistema [Contenuti][Indice]

(operating-system
 ;; ...
 (packages (cons* bluez bluez-alsa
 %base-packages))
 (services
 ;; ...
 (dbus-service #:services (list bluez-alsa))
 (bluetooth-service #:auto-enable? #t)))

$ bluetoothctl 
[NEW] Controller 00:11:22:33:95:7F BlueZ 5.40 [default]
[bluetooth]# power on
[bluetooth]# Changing power on succeeded
[bluetooth]# agent on
[bluetooth]# Agente registrato
[bluetooth]# default-agent
[bluetooth]# Richiesta agente predefinito riuscita
[bluetooth]# scan on
[bluetooth]# Rilevamento avviato
[CHG] Controller 00:11:22:33:95:7F Rilevamento: sì
[NEW] Dispositivo AA:BB:CC:A4:AA:CD Il mio altoparlante Bluetooth
[NEW] Dispositivo 44:44:FF:2A:20:DC TV del mio vicino
…
[bluetooth]# pair AA:BB:CC:A4:AA:CD
Tentativo di accoppiamento con AA:BB:CC:A4:AA:CD
[CHG] Dispositivo AA:BB:CC:A4:AA:CD Connesso: sì
[My Bluetooth Speaker]# [CHG] Dispositivo AA:BB:CC:A4:AA:CD UUIDs: 0000110b-0000-1000-8000-00xxxxxxxxxx
[CHG] Dispositivo AA:BB:CC:A4:AA:CD UUIDs: 0000110c-0000-1000-8000-00xxxxxxxxxx
[CHG] Dispositivo AA:BB:CC:A4:AA:CD UUIDs: 0000110e-0000-1000-8000-00xxxxxxxxxx
[CHG] Dispositivo AA:BB:CC:A4:AA:CD Accoppiato: sì
Accoppiamento riuscito
[CHG] Dispositivo AA:BB:CC:A4:AA:CD Connesso: no
[bluetooth]# 
[bluetooth]# trust AA:BB:CC:A4:AA:CD
[bluetooth]# [CHG] Dispositivo AA:BB:CC:A4:AA:CD Affidabile: sì
Modifica dell'affidabilità di AA:BB:CC:A4:AA:CD riuscita
[bluetooth]# 
[bluetooth]# connect AA:BB:CC:A4:AA:CD
Tentativo di connessione a AA:BB:CC:A4:AA:CD
[bluetooth]# [CHG] Dispositivo AA:BB:CC:A4:AA:CD RSSI: -63
[CHG] Dispositivo AA:BB:CC:A4:AA:CD Connesso: sì
Connessione riuscita
[My Bluetooth Speaker]# scan off
[CHG] Dispositivo AA:BB:CC:A4:AA:CD RSSI è nullo
Rilevamento interrotto
[CHG] Controller 00:11:22:33:95:7F Rilevamento: no

(use-modules (gnu))
(use-service-modules audio dbus sound #;... etc)
(use-package-modules audio linux #;... etc)
(operating-system
 ;; ...
 (packages (cons* bluez bluez-alsa
 %base-packages))
 (services
 ;; ...
 (service mpd-service-type
 (mpd-configuration
 (user "il-tuo-nome-utente")
 (music-dir "/percorso/alla/tua/musica")
 (address "192.168.178.20")
 (outputs (list (mpd-output
 (type "alsa")
 (name "MPD")
 (extra-options
 ;; Usa lo stesso nome della configurazione ALSA
 ;; qui sotto.
 '((device . "pcm.btspeaker"))))
 (mpd-output
 (type "httpd")
 (name "streaming")
 (enabled? #false)
 (always-on? #true)
 (tags? #true)
 (mixer-type 'null)
 (extra-options
 '((encoder . "vorbis")
 (port . "8080")
 (bind-to-address . "192.168.178.20")
 (max-clients . "0") ;nessun limite
 (quality . "5.0")
 (format . "44100:16:1"))))))))
 (dbus-service #:services (list bluez-alsa))
 (bluetooth-service #:auto-enable? #t)
 (service alsa-service-type
 (alsa-configuration
 (pulseaudio? #false) ;non ne abbiamo bisogno
 (extra-options
 #~(string-append "\
# Dichiara il tipo di dispositivo audio Bluetooth \"bluealsa\" dal modulo bluealsa
pcm_type.bluealsa {
 lib \""
#$(file-append bluez-alsa "/lib/alsa-lib/libasound_module_pcm_bluealsa.so") "\"
}
# Dichiara il tipo di dispositivo di controllo \"bluealsa\" dallo stesso modulo
ctl_type.bluealsa {
 lib \""
#$(file-append bluez-alsa "/lib/alsa-lib/libasound_module_ctl_bluealsa.so") "\"
}
# Definisci il dispositivo audio Bluetooth effettivo.
pcm.btspeaker {
 type bluealsa
 device \"AA:BB:CC:A4:AA:CD\" # identificatore unico del dispositivo
 profile \"a2dp\"
}
# Definisci un controller associato.
ctl.btspeaker {
 type bluealsa
}
"))))))

Successivo: Contenitori di Sistema Guix, Su: Contenitori [Contenuti][Indice]

guix shell --container

$ echo /gnu/store/*
/gnu/store/…-gcc-10.3.0-lib
/gnu/store/…-glibc-2.33
/gnu/store/…-bash-static-5.1.8
/gnu/store/…-ncurses-6.2.20210619
/gnu/store/…-bash-5.1.8
/gnu/store/…-profile
/gnu/store/…-readline-8.1.1

$ guix shell --container --share=/etc=/the/host/etc coreutils
$ ls /the/host/etc

(specifications->manifest
 (list "r-minimal"
 ;; pacchetti base
 "bash-minimal"
 "glibc-locales"
 "nss-certs"
 ;; Strumenti comuni da riga di comando per evitare che il contenitore sia troppo vuoto.
 "coreutils"
 "grep"
 "which"
 "wget"
 "sed"
 ;; Strumenti R markdown
 "pandoc"
 ;; Toolchain e librerie comuni per "install.packages"
 "gcc-toolchain@10"
 "gfortran-toolchain"
 "gawk"
 "tar"
 "gzip"
 "unzip"
 "make"
 "cmake"
 "pkg-config"
 "cairo"
 "libxt"
 "openssl"
 "curl"
 "zlib"))

$ guix shell --container --network --manifest=manifest.scm -- R
R version 4.2.1 (2022年06月23日) -- "Funny-Looking Kid"
Copyright (C) 2022 The R Foundation for Statistical Computing
…
> e <- Sys.getenv("GUIX_ENVIRONMENT")
> Sys.setenv(GIT_SSL_CAINFO=paste0(e, "/etc/ssl/certs/ca-certificates.crt"))
> Sys.setenv(SSL_CERT_FILE=paste0(e, "/etc/ssl/certs/ca-certificates.crt"))
> Sys.setenv(SSL_CERT_DIR=paste0(e, "/etc/ssl/certs"))
> install.packages("Cairo", lib=paste0(getwd()))
…
* installing *source* package 'Cairo' ...
…
* DONE (Cairo)
I pacchetti sorgente scaricati si trovano in
	'/tmp/RtmpCuwdwM/downloaded_packages'
> library("Cairo", lib=getwd())
> # successo!

Precedente: Contenitori Guix, Su: Contenitori [Contenuti][Indice]

4.2.1 Un contenitore Database

Un buon esempio potrebbe essere un server di database PostgreSQL. Gran parte della complessità della configurazione di un tale server di database è incapsulata in questa ingannevolmente breve dichiarazione di servizio:

(service postgresql-service-type
 (postgresql-configuration
 (postgresql postgresql-14)))

Una dichiarazione completa del sistema operativo da utilizzare con un contenitore del sistema Guix sarebbe simile a questa:

(use-modules (gnu))
(use-package-modules databases)
(use-service-modules databases)
(operating-system
 (host-name "container")
 (timezone "Europe/Berlin")
 (file-systems (cons (file-system
 (device (file-system-label "non-importa"))
 (mount-point "/")
 (type "ext4"))
 %base-file-systems ))
 (bootloader (bootloader-configuration
 (bootloader grub-bootloader)
 (targets '("/dev/sdX"))))
 (services
 (cons* (service postgresql-service-type
 (postgresql-configuration
 (postgresql postgresql-14)
 (config-file
 (postgresql-config-file
 (log-destination "stderr")
 (hba-file
 (plain-file "pg_hba.conf"
 "\
local	all	all			trust
host	all	all	10.0.0.1/32 	trust"))
 (extra-config
 '(("listen_addresses" "*")
 ("log_directory" "/var/log/postgresql")))))))
 (service postgresql-role-service-type
 (postgresql-role-configuration
 (roles
 (list (postgresql-role
 (name "test")
 (create-database? #t))))))
 %base-services )))

Con postgresql-role-service-type definiamo un ruolo “test” e creiamo un database corrispondente, in modo da poter testare subito senza alcuna ulteriore configurazione manuale. Le impostazioni di postgresql-config-file permettono a un client dall’indirizzo IP 10.0.0.1 di connettersi senza richiedere autenticazione—una cattiva idea nei sistemi di produzione, ma comoda per questo esempio.

Costruiamo uno script che avvierà un’istanza di questo sistema Guix come contenitore. Scrivi la dichiarazione operating-system sopra in un file os.scm e poi usa guix system container per costruire il launcher. (vedi Invocare guix system in Manuale di riferimento di GNU Guix).

$ guix system container os.scm
Verranno costruite le seguenti derivazioni:
 /gnu/store/…-run-container.drv
 …
costruzione di /gnu/store/…-run-container.drv...
/gnu/store/…-run-container

Ora che abbiamo uno script di avvio, possiamo eseguirlo per avviare il nuovo sistema con un servizio PostgreSQL in esecuzione. Si noti che a causa di alcune limitazioni non ancora risolte, dobbiamo eseguire il launcher come utente root, ad esempio con sudo.

$ sudo /gnu/store/…-run-container
il contenitore di sistema è in esecuzione come PID 5983
…

Metti in background il processo con Ctrl-z seguito da bg. Nota il ID del processo nell’output; ci servirà per connetterci al contenitore più tardi. Sai cosa? Proviamo a connetterci al contenitore subito. Useremo nsenter, uno strumento fornito dal pacchetto util-linux:

$ guix shell util-linux
$ sudo nsenter -a -t 5983
root@container /# pgrep -a postgres
49 /gnu/store/…-postgresql-14.4/bin/postgres -D /var/lib/postgresql/data --config-file=/gnu/store/…-postgresql.conf -p 5432
51 postgres: checkpointer
52 postgres: background writer
53 postgres: walwriter
54 postgres: autovacuum launcher
55 postgres: stats collector
56 postgres: logical replication launcher
root@container /# exit

Il servizio PostgreSQL è in esecuzione nel contenitore!

4.2.2 Networking dei contenitori

A che serve un sistema Guix che esegue un servizio di database PostgreSQL come contenitore quando possiamo comunicare con esso solo con processi originari del contenitore? Sarebbe molto meglio se potessimo comunicare con il database tramite la rete.

Il modo più semplice per farlo è creare una coppia di dispositivi Ethernet virtuali connessi (noti come veth). Spostiamo uno dei dispositivi (ceth-test) nel namespace net del contenitore e lasciamo l’altra estremità (veth-test) della connessione sul sistema host.

pid=5983
ns="guix-test"
host="veth-test"
client="ceth-test"
# Collega il nuovo net namespace "guix-test" al PID del contenitore.
sudo ip netns attach $ns $pid
# Crea la coppia di dispositivi
sudo ip link add $host type veth peer name $client
# Sposta il dispositivo client nel namespace di rete del contenitore
sudo ip link set $client netns $ns

Quindi configuriamo il lato host:

sudo ip link set $host up
sudo ip addr add 10.0.0.1/24 dev $host

…e poi configuriamo il lato client:

sudo ip netns exec $ns ip link set lo up
sudo ip netns exec $ns ip link set $client up
sudo ip netns exec $ns ip addr add 10.0.0.2/24 dev $client

A questo punto l’host può raggiungere il contenitore all’indirizzo IP 10.0.0.2, e il contenitore può raggiungere l’host all’IP 10.0.0.1. Questo è tutto ciò di cui abbiamo bisogno per parlare con il server di database all’interno del contenitore dal sistema host all’esterno.

$ psql -h 10.0.0.2 -U test
psql (14.4)
Digita "help" per aiuto.
test=> CREATE TABLE hello (who TEXT NOT NULL);
CREATE TABLE
test=> INSERT INTO hello (who) VALUES ('world');
INSERT 0 1
test=> SELECT * FROM hello;
 who
-------
 world
(1 riga)

Ora che abbiamo finito con questa piccola dimostrazione, puliamo:

sudo kill $pid
sudo ip netns del $ns
sudo ip link del $host

Successivo: Rete instradata per libvirt, Su: Macchine virtuali [Contenuti][Indice]

5.1.1 Creazione di un’interfaccia bridge di rete

Esistono molti modi per creare un bridge di rete. Il seguente comando mostra come usare NetworkManager e il suo strumento nmcli da riga di comando (CLI), che dovrebbe essere già disponibile se la dichiarazione del tuo sistema operativo si basa su uno dei modelli desktop:

# nmcli con add type bridge con-name br0 ifname br0

Per far sì che questo bridge faccia parte della tua rete, devi associare il tuo bridge di rete all’interfaccia Ethernet usata per connetterti alla rete. Supponendo che la tua interfaccia si chiami ‘enp2s0’, il seguente comando può essere usato per farlo:

# nmcli con add type bridge-slave ifname enp2s0 master br0

Importante: Solo le interfacce Ethernet possono essere aggiunte a un bridge. Per le interfacce wireless, considerare l’approccio di rete instradata dettagliato in Vedi Rete instradata per libvirt.

Per impostazione predefinita, il bridge di rete consentirà ai tuoi ospiti di ottenere il loro indirizzo IP tramite DHCP, se disponibile sulla tua rete locale. Per semplicità, questo è ciò che useremo qui. Per trovare facilmente gli ospiti, possono essere configurati per pubblicizzare i loro nomi host tramite mDNS.

5.1.2 Configurazione dello script helper del bridge QEMU

QEMU viene fornito con un programma di aiuto per utilizzare comodamente un’interfaccia bridge di rete come utente non privilegiato vedi Network options in Documentazione QEMU. Il binario deve essere reso setuid root per il corretto funzionamento; questo può essere ottenuto aggiungendolo al campo privileged-programs della tua definizione operating-system (host), come mostrato sotto:

(privileged-programs
 (cons (privileged-program
 (program (file-append qemu "/libexec/qemu-bridge-helper"))
 (setuid? #t))
 %default-privileged-programs))

Il file /etc/qemu/bridge.conf deve anche essere modificato per consentire l’interfaccia del bridge, poiché l’impostazione predefinita è di negare tutto. Aggiungi quanto segue all’elenco dei servizi per farlo:

(extra-special-file "/etc/qemu/host.conf"
 (plain-file "host.conf" "allow br0\n"))

5.1.3 Avviare QEMU con le opzioni da riga di comando corrette

Quando si invoca QEMU, le seguenti opzioni devono essere fornite in modo che il bridge di rete sia utilizzato, dopo aver selezionato un indirizzo MAC unico per il guest.

Importante: Per impostazione predefinita, viene utilizzato un singolo indirizzo MAC per tutti gli ospiti, a meno che non venga fornito. Il mancato fornitura di indirizzi MAC diversi a ciascuna macchina virtuale che utilizza il bridge causerebbe problemi di rete.

$ qemu-system-x86_64 [...] \
 -device virtio-net-pci,netdev=user0,mac=XX:XX:XX:XX:XX:XX \
 -netdev bridge,id=user0,br=br0 \
 [...]

Per generare indirizzi MAC che hanno il prefisso registrato da QEMU, può essere utilizzato il seguente frammento:

mac_address="52:54:00:$(dd if=/dev/urandom bs=512 count=1 2>/dev/null \
 | md5sum \
 | sed -E 's/^(..)(..)(..).*$/1円:2円:3円/')"
echo $mac_address

5.1.4 Problemi di rete causati da Docker

Se usi Docker sulla tua macchina, potresti riscontrare problemi di connettività quando tenti di usare un bridge di rete, causati dal fatto che Docker si basa anche sui bridge di rete e configura le proprie regole di routing. La soluzione è aggiungere il seguente frammento iptables alla tua dichiarazione operating-system:

(service iptables-service-type
 (iptables-configuration
 (ipv4-rules (plain-file "iptables.rules" "\
*filter
:INPUT ACCEPT [0:0]
:FORWARD DROP [0:0]
:OUTPUT ACCEPT [0:0]
-A FORWARD -i br0 -o br0 -j ACCEPT
COMMIT
"))

Successivo: Rete personalizzata basata su NAT per libvirt, Precedente: Ponte di rete per QEMU, Su: Macchine virtuali [Contenuti][Indice]

5.2.1 Creazione di uno switch di rete virtuale

Uno switch di rete virtuale consiste in un dispositivo di rete virtuale chiamato ‘bridge virtuale’, server DHCP (dnsmasq) e regole firewall (iptables). Vedi l’articolo wiki di libvirt sulle Reti Virtuali per maggiori dettagli sulle modalità di funzionamento, gestione e implementazione degli switch di rete virtuali.

Il comando virsh, fornito dal pacchetto libvirt, rende molto facile creare uno switch virtuale. Per prima cosa devi scegliere una sottorete di rete per il tuo switch virtuale; se la tua LAN domestica è nella rete ‘192.168.1.0/24’, potresti optare per l’uso ad es.: ‘192.168.2.0/24’. Definisci un file XML, ad es.: /tmp/virbr0.xml, contenente quanto segue:

<network>
 <name>virbr0</name>
 <bridge name="virbr0" />
 <forward mode="route"/>
 <ip address="192.168.2.0" netmask="255.255.255.0">
 <dhcp>
 <range start="192.168.2.1" end="192.168.2.254"/>
 </dhcp>
 </ip>
</network>

Quindi crea e configura l’interfaccia usando il comando virsh, come root:

virsh net-define /tmp/virbr0.xml
virsh net-autostart virbr0
virsh net-start virbr0

L’interfaccia ‘virbr0’ dovrebbe ora essere visibile ad es.: tramite il comando ‘ip address’. Verrà avviata automaticamente ogni volta che la tua macchina virtuale libvirt viene avviata.

5.2.2 Configurazione delle rotte statiche per il tuo bridge virtuale

Se hai configurato la tua macchina virtuale per utilizzare la tua nuova interfaccia bridge virtuale ‘virbr0’, dovrebbe già ricevere un IP tramite DHCP come ‘192.168.2.15’ ed essere raggiungibile dal server che la ospita, ad es.: tramite ‘ping 192.168.2.15’. C’è un’ultima configurazione necessaria affinché la VM possa raggiungere la rete esterna: aggiungere rotte statiche al router della rete.

In questo esempio, la rete LAN è ‘192.168.1.0/24’ e la pagina web di configurazione del router potrebbe essere accessibile ad es.: tramite la pagina http://192.168.1.1. Su un router che esegue il firmware libreCMC, dovresti navigare alla pagina Rete → Rotte Statiche (https://192.168.1.1/cgi-bin/luci/admin/network/routes), e aggiungeresti una nuova voce a ‘Rotte IPv4 Statiche’ con le seguenti informazioni:

‘Interfaccia’

lan

‘Destinazione’

192.168.2.0

‘Maschera di rete IPv4’

255.255.255.0

‘Gateway IPv4’

ip-server

‘Tipo di rotta’

unicast

dove server-ip è l’indirizzo IP della macchina che ospita le VM, che dovrebbe essere statico.

Dopo aver salvato/applicato questa nuova rotta statica, la connettività esterna dovrebbe funzionare all’interno della tua VM; puoi ad es.: eseguire ‘ping gnu.org’ per verificare che funzioni correttamente.

Successivo: Riferimenti, Precedente: Rete instradata per libvirt, Su: Macchine virtuali [Contenuti][Indice]

5.3.1 Creazione del bridge di rete virtuale

Il static-networking-service-type può essere usato per creare un bridge di rete virtuale e assegnargli un indirizzo IP:

(service static-networking-service-type
 (list (static-networking
 ;; La fornitura predefinita è 'networking; se stai usando qualsiasi
 ;; altro servizio con questa fornitura, come
 ;; `network-manager-service-type`, allora devi cambiare il
 ;; predefinito.
 (provision '(static-networking))
 (links
 (list (network-link
 (name "virbr0")
 (type 'bridge)
 (arguments '()))))
 (addresses
 (list (network-address
 (device "virbr0")
 (value "192.168.10.1/24")))))))

5.3.2 Esecuzione di dnsmasq per il bridge di rete virtuale

Il dnsmasq-service-type può essere usato per fornire DNS e DHCP per gli ospiti connessi a questo switch di rete virtuale:

(service dnsmasq-service-type
 (dnsmasq-configuration
 ;; Puoi avere più istanze di `dnsmasq-service-type` purché
 ;; ognuna abbia una diversa shepherd-provision.
 (shepherd-provision '(dnsmasq-virbr0))
 (extra-options (list
 ;; Bind solo al bridge virtuale. Questo
 ;; evita conflitti con altre istanze di
 ;; dnsmasq in esecuzione.
 "--except-interface=lo"
 "--interface=virbr0"
 "--bind-dynamic"
 ;; Indirizzi IPv4 da offrire alle VM. Questo
 ;; dovrebbe corrispondere alla sottorete scelta.
 "--dhcp-range=192.168.10.2,192.168.10.254"))))

5.3.3 Configurazione del NAT per lo switch di rete virtuale

Se intendi utilizzare lo switch di rete virtuale in modalità NAT, dovrai utilizzare le regole nftables (o iptables) per impostare il masquerading IP. Il seguente esempio mostra come utilizzare nftables-service-type per farlo:

(service nftables-service-type
 (nftables-configuration
 (ruleset
 (plain-file "nftables.conf"
 "\
table inet filter {
 input catena {
 tipo filtro hook input priorità filtro; policy drop;
 # Aggiungi qui le tue regole di filtraggio pacchetti esistenti...
 iifname virbr0 udp dport 67 contatore accetta commento \"consenti DHCP su virbr0\"
 iifname virbr0 meta l4proto {tcp, udp} th dport 53 accetta \\
 commento \"consenti DNS su virbr0\"
 }
 chain forward {
 type filter hook forward priority filter; policy drop;
 # Aggiungi qui le tue regole di inoltro esistenti...
 iifname virbr0 accept comment \"consenti il traffico in uscita da virbr0\"
 oifname virbr0 ct state {established, related } accept \\
 comment \"consenti il traffico stabilito verso virbr0\"
 }
}
table inet nat {
 chain postrouting {
 type nat hook postrouting priority srcnat; policy accept;
 # Aggiungi qui le tue regole NAT esistenti...
 iifname virbr0 ip daddr { 224.0.0.0/24, 255.255.255.255/32 } return \\
 comment \"non mascherare verso blocchi di indirizzi riservati\"
 iifname virbr0 oifname != virbr0 masquerade \\
 comment \"mascherare tutto il traffico in uscita dalle VM\"
 }
}
"))))

Assicurati di avere l’inoltro IPv4 abilitato (puoi usare sysctl-service-type per questo).

Precedente: Rete personalizzata basata su NAT per libvirt, Su: Macchine virtuali [Contenuti][Indice]

Su: Gestione avanzata dei pacchetti [Contenuti][Indice]

6.1.1 Configurazione di base con i manifesti

Un profilo Guix può essere configurato via un manifest. Un manifest è uno snippet di codice Scheme che specifica l’insieme di pacchetti che desideri avere nel tuo profilo; assomiglia a questo:

(specifications->manifest
 '("pacchetto-1"
 ;; Versione 1.3 del pacchetto-2.
 "pacchetto-2@1.3"
 ;; L'output "lib" del pacchetto-3.
 "pacchetto-3:lib"
 ; ...
 "pacchetto-N"))

Vedi Scrivere manifesti in Manuale di riferimento GNU Guix, per maggiori informazioni sulla sintassi.

Possiamo creare una specifica di manifest per ogni profilo e installarli in questo modo:

GUIX_EXTRA_PROFILES=$HOME/.guix-extra-profiles
mkdir -p "$GUIX_EXTRA_PROFILES"/my-project # se non esiste ancora
guix package --manifest=/percorso/a/guix-my-project-manifest.scm \
 --profile="$GUIX_EXTRA_PROFILES"/my-project/my-project

Qui impostiamo una variabile arbitraria ‘GUIX_EXTRA_PROFILES’ per indicare la directory dove memorizzeremo i nostri profili nel resto di questo articolo.

Posizionare tutti i tuoi profili in una singola directory, con ogni profilo che ottiene la propria sottodirectory, è un po’ più pulito. In questo modo, ogni sottodirectory conterrà tutti i symlink per un solo profilo. Inoltre, “iterare sui profili” diventa ovvio da qualsiasi linguaggio di programmazione (ad esempio: uno script di shell) semplicemente iterando sulle sottodirectory di ‘$GUIX_EXTRA_PROFILES’.

Nota che è anche possibile scorrere l’output di

guix package --list-profiles

anche se probabilmente dovrai filtrare ~/.config/guix/current.

Per abilitare tutti i profili all’accesso, aggiungi questo al tuo ~/.bash_profile (o simile):

for i in $GUIX_EXTRA_PROFILES/*; do
 profile=$i/$(basename "$i")
 if [ -f "$profile"/etc/profile ]; then
 GUIX_PROFILE="$profile"
 . "$GUIX_PROFILE"/etc/profile
 fi
 unset profile
done

Nota per gli utenti di Guix System: quanto sopra riflette come il tuo profilo predefinito ~/.guix-profile viene attivato da /etc/profile, quest’ultimo caricato da ~/.bashrc per impostazione predefinita.

Puoi ovviamente scegliere di abilitarne solo un sottoinsieme:

for i in "$GUIX_EXTRA_PROFILES"/my-project-1 "$GUIX_EXTRA_PROFILES"/my-project-2; do
 profile=$i/$(basename "$i")
 if [ -f "$profile"/etc/profile ]; then
 GUIX_PROFILE="$profile"
 . "$GUIX_PROFILE"/etc/profile
 fi
 unset profile
done

Quando un profilo è disabilitato, è semplice abilitarlo per una singola shell senza "inquinare" il resto della sessione utente:

GUIX_PROFILE="percorso/al/mio-progetto" ; . "$GUIX_PROFILE"/etc/profile

La chiave per abilitare un profilo è source il suo file ‘etc/profile’. Questo file contiene codice shell che esporta le variabili d’ambiente corrette necessarie per attivare il software contenuto nel profilo. È costruito automaticamente da Guix e destinato all’esecuzione. Contiene le stesse variabili che otterresti eseguendo:

guix package --search-paths=prefix --profile=$my_profile"

Ancora una volta, vedi Invocare guix package in Manuale di riferimento di GNU Guix per le opzioni della riga di comando.

Per aggiornare un profilo, è sufficiente installare di nuovo il manifest:

guix package -m /percorso/a/guix-my-project-manifest.scm \
 -p "$GUIX_EXTRA_PROFILES"/my-project/my-project

Per aggiornare tutti i profili, è abbastanza facile scorrerli. Ad esempio, supponendo che le specifiche del tuo manifest siano archiviate in ~/.guix-manifests/guix-$profile-manifest.scm, con ‘$profile’ che è il nome del profilo (es.: "project1"), potresti fare quanto segue in una shell Bourne:

for profile in "$GUIX_EXTRA_PROFILES"/*; do
 guix package --profile="$profile" \
 --manifest="$HOME/.guix-manifests/guix-$profile-manifest.scm"
done

Ogni profilo ha le sue generazioni:

guix package -p "$GUIX_EXTRA_PROFILES"/my-project/my-project --list-generations

Puoi tornare indietro a qualsiasi generazione di un dato profilo:

guix package -p "$GUIX_EXTRA_PROFILES"/my-project/my-project --switch-generations=17

Infine, se vuoi passare a un profilo senza ereditare dall’ambiente corrente, puoi attivarlo da una shell vuota:

env -i $(which bash) --login --noprofile --norc
. my-project/etc/profile

6.1.2 Pacchetti richiesti

L’attivazione di un profilo si riduce essenzialmente all’esportazione di una serie di variabili d’ambiente. Questo è il ruolo del file ‘etc/profile’ all’interno del profilo.

Nota: verranno impostate solo le variabili d’ambiente dei pacchetti che le consumano.

Ad esempio, ‘MANPATH’ non verrà impostato se non esiste un’applicazione che consuma le pagine man all’interno del profilo. Quindi, se hai bisogno di accedere in modo trasparente alle pagine man una volta caricato il profilo, hai due opzioni:

• Esporta la variabile manualmente, ad esempio

  export MANPATH=/percorso/al/profilo${MANPATH:+:}$MANPATH
  

• Oppure includi ‘man-db’ nel manifest del profilo.

Lo stesso vale per ‘INFOPATH’ (puoi installare ‘info-reader’), ‘PKG_CONFIG_PATH’ (installa ‘pkg-config’), ecc.

6.1.3 Profilo predefinito

Che dire del profilo predefinito che Guix mantiene in ~/.guix-profile?

Puoi assegnargli il ruolo che desideri. Tipicamente installeresti il manifest dei pacchetti che vuoi usare sempre.

In alternativa, potresti mantenerlo “senza manifest” per pacchetti usa-e-getta che useresti solo per un paio di giorni. In questo modo è comodo eseguire

guix install package-foo
guix upgrade package-bar

senza dover specificare il percorso di un profilo.

6.1.4 I benefici dei manifesti

I manifest ti permettono di declare l’insieme di pacchetti che vorresti avere in un profilo (vedi Scrivere manifesti in Manuale di riferimento GNU Guix). Sono un modo conveniente per tenere a portata di mano gli elenchi dei pacchetti e, ad esempio, sincronizzarli su più macchine utilizzando un sistema di controllo versione.

Una lamentela comune sui manifest è che possono essere lenti da installare quando contengono un gran numero di pacchetti. Questo è particolarmente ingombrante quando si desidera solo un aggiornamento per un pacchetto all’interno di un manifest grande.

Questo è un motivo in più per utilizzare più profili, che si rivelano perfetti per suddividere i manifest in più insiemi di pacchetti semanticamente collegati. L’utilizzo di più profili piccoli offre maggiore flessibilità e usabilità.

I manifest offrono numerosi vantaggi. In particolare, facilitano la manutenzione:

• Quando un profilo viene configurato da un manifest, il manifest stesso è autosufficiente per mantenere un “elenco di pacchetti” e reinstallare il profilo in seguito o su un sistema diverso. Per i profili ad-hoc, dovremmo generare manualmente una specifica di manifest e mantenere le versioni dei pacchetti per i pacchetti che non utilizzano la versione predefinita.
• guix package --upgrade tenta sempre di aggiornare i pacchetti che hanno input propagati, anche se non c’è nulla da fare. I manifest di Guix rimuovono questo problema.
• Quando si aggiorna parzialmente un profilo, possono sorgere conflitti (a causa di dipendenze divergenti tra i pacchetti aggiornati e quelli non aggiornati) e possono essere fastidiosi da risolvere manualmente. I manifest eliminano del tutto questo problema, poiché tutti i pacchetti vengono sempre aggiornati contemporaneamente.
• Come accennato in precedenza, i manifest consentono profili riproducibili, mentre i comandi imperativi guix install, guix upgrade, ecc. non lo fanno, poiché producono profili diversi ogni volta anche quando contengono gli stessi pacchetti. Vedi la discussione correlata sull’argomento.
• Le specifiche dei manifest sono utilizzabili da altri comandi ‘guix’. Ad esempio, puoi eseguire guix weather -m manifest.scm per vedere quanti sostituti sono disponibili, il che può aiutarti a decidere se vuoi provare ad aggiornare oggi o aspettare un po’. Un altro esempio: puoi eseguire guix pack -m manifest.scm per creare un pacchetto contenente tutti i pacchetti nel manifest (e i loro riferimenti transitivi).
• Infine, i manifest hanno una rappresentazione Scheme, il tipo di record ‘<manifest>’. Possono essere manipolati in Scheme e passati alle varie API di Guix.

È importante capire che, sebbene i manifest possano essere usati per dichiarare i profili, non sono strettamente equivalenti: i profili hanno l’effetto collaterale di “fissare” i pacchetti nello store, il che impedisce che vengano raccolti dalla spazzatura (vedi Invocare guix gc in Manuale di riferimento GNU Guix) e assicura che saranno ancora disponibili in qualsiasi momento in futuro. Il comando guix shell protegge anche i profili usati di recente dalla raccolta della spazzatura; i profili che non sono stati usati per un po’ possono essere comunque raccolti dalla spazzatura, insieme ai pacchetti a cui si riferiscono.

Per essere sicuri al 100% che un dato profilo non verrà mai raccolto, installare il manifest in un profilo e usare GUIX_PROFILE=/il/profilo; . "$GUIX_PROFILE"/etc/profile come spiegato sopra: questo garantisce che il nostro ambiente di hacking sarà sempre disponibile.

Avviso di sicurezza: Sebbene mantenere i vecchi profili possa essere comodo, tieni presente che i pacchetti obsoleti potrebbero non aver ricevuto le ultime correzioni di sicurezza.

6.1.5 Profili riproducibili

Per riprodurre un profilo bit per bit, abbiamo bisogno di due informazioni:

• un manifest (vedi Scrivere manifesti in Manuale di riferimento GNU Guix);
• una specifica di canale Guix (vedi Replicare Guix in Manuale di riferimento GNU Guix).

Infatti, i soli manifest potrebbero non essere sufficienti: diverse versioni di Guix (o diversi canali) possono produrre output diversi per un dato manifest.

È possibile generare la specifica del canale Guix con ‘guix describe --format=channels’ (vedi Invocare guix describe in Manuale di riferimento GNU Guix). Salva questo in un file, ad esempio ‘channel-specs.scm’.

Su un altro computer, è possibile utilizzare il file di specifica del canale e il manifest per riprodurre lo stesso identico profilo:

GUIX_EXTRA_PROFILES=$HOME/.guix-extra-profiles
GUIX_EXTRA=$HOME/.guix-extra
mkdir -p "$GUIX_EXTRA"/my-project
guix pull --channels=channel-specs.scm --profile="$GUIX_EXTRA/my-project/guix"
mkdir -p "$GUIX_EXTRA_PROFILES/my-project"
"$GUIX_EXTRA"/my-project/guix/bin/guix package \
 --manifest=/percorso/a/guix-my-project-manifest.scm \
 --profile="$GUIX_EXTRA_PROFILES"/my-project/my-project

È sicuro eliminare il profilo del canale Guix che hai appena installato con la specifica del canale, il profilo del progetto non dipende da esso.

Successivo: Livello 1: Costruire con Guix, Su: Sviluppo software [Contenuti][Indice]

;; Il file «guix.scm» per Guile, da usare con «guix shell».

(use-modules (guix)
 (guix build-system gnu)
 ((guix licenses) #:prefix license:)
 (gnu packages autotools)
 (gnu packages base)
 (gnu packages bash)
 (gnu packages bdw-gc)
 (gnu packages compression)
 (gnu packages flex)
 (gnu packages gdb)
 (gnu packages gettext )
 (gnu packages gperf)
 (gnu packages libffi)
 (gnu packages libunistring)
 (gnu packages linux)
 (gnu packages pkg-config)
 (gnu packages readline )
 (gnu packages tex)
 (gnu packages texinfo)
 (gnu packages version-control))
(package
 (name "guile")
 (version "3.0.99-git") ;numero di versione strano
 (source #f) ;nessuna fonte
 (build-system gnu-build-system )
 (native-inputs
 (append (list autoconf
 automake
 libtool
 gnu-gettext
 flex
 texinfo
 texlive-base ;per "make pdf"
 texlive-epsf
 gperf
 git
 gdb
 strace
 readline
 lzip
 pkg-config)
 ;; Quando si esegue la compilazione incrociata, è necessaria una
 ;; versione nativa di Guile.
 (if (%current-target-system)
 (list this-package )
 '())))
 (inputs
 (list libffi bash-minimal))
 (propagated-inputs
 (list libunistring libgc))
 (native-search-paths
 (list (search-path-specification
 (variable "GUILE_LOAD_PATH")
 (files '("share/guile/site/3.0")))
 (search-path-specification
 (variable "GUILE_LOAD_COMPILED_PATH")
 (files '("lib/guile/3.0/site-ccache")))))
 (synopsis "Implementazione Scheme destinata in particolare alle estensioni")
 (description
 "Guile è il Linguaggio Intelligente Onnipresente GNU per le Estensioni,
ed è in realtà un'implementazione Scheme completa!")
 (home-page "https://www.gnu.org/software/guile/")
 (license license:lgpl3+))

guix shell

Successivo: Livello 2: Il Repository come Canale, Precedente: Per iniziare, Su: Sviluppo software [Contenuti][Indice]

(use-modules (guix)
 (guix git-download) ;per ‘git-predicate’
 ...)
(define vcs-file?
 ;; Restituisce vero se il file dato è sotto controllo di versione.
 (or (git-predicate (current-source-directory))
 (const #t))) ;non in un checkout Git

(package
 (name "guile")
 (version "3.0.99-git") ;numero di versione strano
 (source (local-file "." "guile-checkout"
 #:recursive? #t
 #:select? vcs-file?))
 ...)

guix build -f guix.scm

guix build -f guix.scm -s aarch64-linux -s riscv64-linux

guix build -f guix.scm --target=x86_64-w64-mingw32

# E se costruissimo con Clang invece di GCC?
guix build -f guix.scm \
 --with-c-toolchain=guile@3.0.99-git=clang-toolchain
# E quel flag di configurazione poco testato?
guix build -f guix.scm \
 --with-configure-flag=guile@3.0.99-git=--disable-networking

Successivo: Bonus: Varianti di Pacchetto, Precedente: Livello 1: Costruire con Guix, Su: Sviluppo software [Contenuti][Indice]

mkdir -p .guix/modules
mv guix.scm .guix/modules/guile-package.scm
ln -s .guix/modules/guile-package.scm guix.scm

(define-module (guile-package)
 #:use-module (guix)
 #:use-module (guix git-download) ;per ‘git-predicate’
 ...)
(define vcs-file?
 ;; Restituisce vero se il file dato è sotto controllo di versione.
 (or (git-predicate (dirname (dirname (current-source-directory))))
 (const #t))) ;non in un checkout Git

(define-public guile
 (package
 (name "guile")
 (version "3.0.99-git") ;numero di versione strano
 (source (local-file "../.." "guile-checkout"
 #:recursive? #t
 #:select? vcs-file?))
 ...))
;; Restituisce l'oggetto pacchetto definito sopra alla fine del modulo.
guile

;; Questo file ci permette di presentare questo repository come un canale Guix.

(channel
 (version 0)
 (directory ".guix/modules")) ;cerca i moduli dei pacchetti sotto .guix/modules/

.
├── .guix-channel
├── guix.scm → .guix/modules/guile-package.scm
└── .guix
  └── modules
    └── guile-package.scm

(append (list (channel
 (name 'guile)
 (url "https://git.savannah.gnu.org/git/guile.git")
 (branch "main")))
 %default-channels)

$ guix describe
Generazione 264 26 maggio 2023 16:00:35 (corrente)
 guile 36fd2b4
 URL repository: https://git.savannah.gnu.org/git/guile.git
 ramo: main
 commit: 36fd2b4920ae926c79b936c29e739e71a6dff2bc
 guix c5bc698
 URL repository: https://git.guix.gnu.org/guix.git
 commit: c5bc698e8922d78ed85989985cc2ceb034de2f23
$ guix package -A ^guile$
guile 3.0.99-git out,debug guile-package.scm:51:4
guile 3.0.9 out,debug gnu/packages/guile.scm:317:2
guile 2.2.7 out,debug gnu/packages/guile.scm:258:2
guile 2.2.4 out,debug gnu/packages/guile.scm:304:2
guile 2.0.14 out,debug gnu/packages/guile.scm:148:2
guile 1.8.8 out gnu/packages/guile.scm:77:2
$ guix build guile@3.0.99-git
[…]
/gnu/store/axnzbl89yz7ld78bmx72vpqp802dwsar-guile-3.0.99-git-debug
/gnu/store/r34gsij7f0glg2fbakcmmk0zn4v62s5w-guile-3.0.99-git

# Che ne dici di un'immagine Docker del nostro snapshot Guile?
guix pack -f docker -S /bin=bin guile@3.0.99-git
# E un RPM rilocabile?
guix pack -f rpm -R -S /bin=bin guile@3.0.99-git

Successivo: Livello 3: Configurazione dell’Integrazione Continua, Precedente: Livello 2: Il Repository come Canale, Su: Sviluppo software [Contenuti][Indice]

;; Questo è il file «.guix/modules/guile-package.scm».

(define-module (guile-package)
 ...)
(define-public guile
 ...)
(define (package-with-configure-flags p flags)
 "Restituisce P con FLAGS come flag 'configure' aggiuntivi."
 (package/inherit p
 (arguments
 (substitute-keyword-arguments (package-arguments p)
 ((#:configure-flags original-flags #~(list ))
 #~(append #$original-flags #$flags))))))
(define-public guile-without-threads
 (package
 (inherit (package-with-configure-flags guile
 #~(list "--without-threads")))
 (name "guile-without-threads")))
(define-public guile-without-networking
 (package
 (inherit (package-with-configure-flags guile
 #~(list "--disable-networking")))
 (name "guile-without-networking")))
;; Restituisce l'oggetto pacchetto definito sopra alla fine del modulo.
guile

guix build -L $PWD/.guix/modules guile-without-threads

Successivo: Bonus: Manifest di costruzione, Precedente: Bonus: Varianti di Pacchetto, Su: Sviluppo software [Contenuti][Indice]

guix build -L $PWD/.guix/modules guile@3.0.99-git

;; File di specifica Cuirass per costruire tutti i pacchetti del canale «guile».
(list (specification
 (name "guile")
 (build '(channels guile))
 (channels
 (append (list (channel
 (name 'guile)
 (url "https://git.savannah.gnu.org/git/guile.git")
 (branch "main")))
 %default-channels))))

Successivo: In conclusione, Precedente: Livello 3: Configurazione dell’Integrazione Continua, Su: Sviluppo software [Contenuti][Indice]

;; Questo è «.guix/manifest.scm».

(use-modules (guix)
 (guix profiles)
 (guile-package)) ;importa il nostro modulo pacchetto

(define* (package->manifest-entry* package system
 #:key target)
 "Restituisce una voce di manifest per PACKAGE su SYSTEM, opzionalmente cross-compilato su
TARGET."
 (manifest-entry
 (inherit (package->manifest-entry package ))
 (name (string-append (package-name package ) "." system
 (if target
 (string-append "." target)
 "")))
 (item (with-parameters ((%current-system system )
 (%current-target-system target))
 package ))))
(define native-builds
 (manifest
 (append (map (lambda (system )
 (package->manifest-entry* guile system ))
 '("x86_64-linux" "i686-linux"
 "aarch64-linux" "armhf-linux"
 "powerpc64le-linux"))
 (map (lambda (guile)
 (package->manifest-entry* guile "x86_64-linux"))
 (cons (package
 (inherit (package-with-c-toolchain
 guile
 `(("clang-toolchain"
 ,(specification->package
 "clang-toolchain")))))
 (name "guile-clang"))
 (list guile-without-threads
 guile-without-networking
 guile-debug
 guile-strict-typing))))))
(define cross-builds
 (manifest
 (map (lambda (target)
 (package->manifest-entry* guile "x86_64-linux"
 #:target target))
 '("i586-pc-gnu"
 "aarch64-linux-gnu"
 "riscv64-linux-gnu"
 "i686-w64-mingw32"
 "x86_64-linux-gnu"))))
(concatenate-manifests (list native-builds cross-builds))