\input texinfo
@c ===========================================================================
@c
@c This file was generated with po4a. Translate the source file.
@c
@c ===========================================================================

@c -*-texinfo-*-

@c %**start of header
@setfilename guix-cookbook.sk.info
@documentencoding UTF-8
@documentlanguage sk
@settitle Receptár GNU Guix
@c %**end of header

@c Onion service for ci.guix.gnu.org.
@set SUBSTITUTE-TOR-URL https://4zwzi66wwdaalbhgnix55ea3ab4pvvw66ll2ow53kjub6se4q2bclcyd.onion

@copying
Copyright @copyright{} 2019, 2022 Ricardo Wurmus@* Copyright @copyright{}
2019 Efraim Flashner@* Copyright @copyright{} 2019 Pierre Neidhardt@*
Copyright @copyright{} 2020 Oleg Pykhalov@* Copyright @copyright{} 2020
Matthew Brooks@* Copyright @copyright{} 2020 Marcin Karpezo@* Copyright
@copyright{} 2020 Brice Waegeneire@* Copyright @copyright{} 2020 André
Batista@* Copyright @copyright{} 2020 Christine Lemmer-Webber@* Copyright
@copyright{} 2021 Joshua Branson@* Copyright @copyright{} 2022 Maxim
Cournoyer*

Tento dokument môžete kopírovať, ďalej šíriť a/alebo upravovať pod
podmienkami licencie GNU Free Documentation License vo verzii 1.3 alebo v
akejkoľvek novšej verzii, ktorú vydáva Free Software Foundation; bez
nemenných oddielov, úvodnej strany a propagačného textu.  Kópia tejto
licencie je priložená v oddiele „GNU Free Documentation License“.
@end copying

@dircategory Správa systému
@direntry
* Receptár Guix: (guix-cookbook).  Návody a príklady GNU Guix.
@end direntry

@titlepage
@title Receptár GNU Guix
@subtitle Návody na používanie funkcionálneho správcu balíkov GNU Guix a príklady z praxe
@author Vývojári GNU Guix

@page
@vskip 0pt plus 1filll

@insertcopying
@end titlepage

@contents

@c *********************************************************************
@node Top
@top Receptár GNU Guix

Tento dokument obsahuje návody a podrobné príklady použitia GNU@tie{}Guix,
funkcionálneho správcu balíkov napísaného pre systém GNU.  Získajte viac
podrobností o systéme, jeho API a súvisiacich pojmoch v @pxref{Top,,, guix,
GNU Guix reference manual}.

@c TRANSLATORS: You can replace the following paragraph with information on
@c how to join your own translation team and how to report issues with the
@c translation.
Táto príručka je dostupná aj v angličtine (@pxref{Top,,, guix-cookbook, GNU
Guix Cookbook}), francúzštine (@pxref{Top,,, guix-cookbook.fr, Livre de
recettes de GNU Guix}) a nemčine (@pxref{Top,,, guix-cookbook.de,
GNU-Guix-Kochbuch}).  Ak chcete pomôcť s prekladom tohto dokumentu do vášho
rodného jazyka, pripojte sa k
@uref{https://translate.fedoraproject.org/projects/guix/documentation-cookbook,
Weblate} (@pxref{Translating Guix,,, guix, GNU Guix reference manual}).

@menu
* Návody na Scheme::        Zoznámte sa s vašim novým 
                               najobľúbenejším jazykom!
* Zadávanie balíkov::      Návody na zadávanie balíkov
* Nastavenie systému::      Prispôsobenie systému GNU
* Containers::               Isolated environments and nested systems
* Pokročilá správa balíkov::  Moc pre používateľov!
* Správa prostredí::       Kontrolné prostredie

* Poďakovanie::             Ďakujeme!
* Licencia GNU Free Documentation::  Licencia, ktorej podlieha tento 
                                       dokument.
* Zoznam pojmov::            Pojmy.

@detailmenu
 --- Podrobný zoznam uzlov ---



Návody na Scheme



* Zrýchlené školenie jazyka Scheme::  Naučte sa základy jazyka Scheme

Zadávanie balíkov



* Návod na zadávanie balíkov::  Pridajme do Guixu nejaký balík!

Nastavenie systému



* Automatické pripojenie k určitému TTY::  Automaticky pripojiť 
                                                používateľa k určitému 
                                                TTY
* Prispôsobenie jadra::     Vytvorenie a používanie vlastného 
                               Linuxového jadra v systéme Guix.
* API pre vytváranie obrazov systému Guix::  Prispôsobenie obrazov 
                                                 nezvyčajným platformám.
* Using security keys::      How to use security keys with Guix System.
* Pripojenie k Wireguard VPN::  Pripojenie k Wireguard VPN sieti.
* Prispôsobenie správcu okien::  Spravovať prispôsobenie správcu okien 
                                     v systéme Guix.
* Spúšťanie Guixu na serveri Linode::  Running Guix on a Linode Server.  
                                            Running Guix on a Linode Server
* Nastavenie podvojného pripojenia::  Nastavenie podvojného pripojenia v 
                                         zadaní systému súborov.
* Získavanie náhrad prostredníctvom Tor::  Nastavenie démona Guix na 
                                                získavanie náhrad cez Tor.
* Nastavenia NGINX a Lua::   Nastavenie web-servera NGINX na načítavanie 
                               Lua modulov.
* Music Server with Bluetooth Audio::  Headless music player with Bluetooth 
                                         output.

@end detailmenu
@end menu

@c *********************************************************************
@node Návody na Scheme
@chapter Návody na Scheme

GNU@tie{}Guix je zapísaný v programovacom jazyku Scheme. K mnohým jeho
súčastiam je možné pristupovať a upravovať ich prostredníctvom
programovania.  Pomocou jazyka Scheme môžete zadávať, upravovať a zostavovať
balíky, nasadzovať celé operačné systémy, atď.

Poznať základy programovania v jazyku Scheme vám otvorí dvere k množstvu
pokročilých súčastí, ktoré Guix ponúka --- a to ani nemusíte byť skúseným
vývojárom, aby ste ich mohli využívať!

Poďme na to!

@node Zrýchlené školenie jazyka Scheme
@section Zrýchlené školenie jazyka Scheme

@cindex Scheme, rýchlokurz

Guix používa Guile implementáciu jazyka Scheme. Ak si chcete tento jazyk
vyskúšať, nainštalujte si Guile pomocou @code{guix install guile} a spustite
@dfn{REPL},
tzv.
@uref{https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop,
@dfn{slučku čítaj-vykonaj-zobraz}}, zadaním @code{guile} v príkazovom
riadku.

Alternatively you can also run @code{guix shell guile -- guile} if you'd
rather not have Guile installed in your user profile.

Riadky v nasledovných príkladoch znázorňujú to, čo treba zadať v rámci REPL;
riadky začínajúce na „@result{}“ znázorňujú výsledok vykonania príkazu,
zatiaľ čo riadky začínajúce na „@print{}“ znázorňujú to čo sa zobrazí na
obrazovke. @xref{Using Guile Interactively,,, guile, GNU Guile Reference
Manual}, pre viac podrobností o REPL.

@itemize
@item
Skladbu jazyka Scheme si možno predstaviť ako strom výrazov (alebo ako
@emph{s-expression} v jazyku Lisp). Výrazom môže byť priama konštanta,
napr. číselná hodnota či reťazec znakov, alebo môže predstavovať zoznam
iných zložených prvkov a priamych konštánt ohraničený v
zátvorkách. @code{#true} a @code{#false} (skrátene @code{#t} a @code{#f})
znázorňujú logické hodnoty „pravda“ a „nepravda“.

Príklady platných výrazov:

@lisp
"Ahoj svet!"
@result{} "Ahoj svet!"

17
@result{} 17

(display (string-append "Ahoj " "Guix" "\n"))
@print{} Ahoj Guix!
@result{} #<unspecified>
@end lisp

@item
Tento posledný príklad znázorňuje volanie funkcie vnorené do iného volania
funkcie. Pri vykonávaní výrazu v zátvorkách predstavuje prvá položka funkciu
a zvyšok sú parametre volania. Návratová hodnota každej funkcie je výsledok
vykonania posledného výrazu v nej.

@item
Bezmenné funkcie možno zadávať pomocou slova @code{lambda}:

@lisp
(lambda (x) (* x x))
@result{} #<procedure 120e348 at <unknown port>:24:0 (x)>
@end lisp

Vyššie uvedená funkcia vracia druhú mocninu hodnoty jej parametra. Keďže
všetko sa považuje za výraz, aj výraz @code{lambda} vracia bezmennú funkciu,
ktorú je následne možné uplatniť na nejaký parameter:

@lisp
((lambda (x) (* x x)) 3)
@result{} 9
@end lisp

@item
Všetkému je možné prideliť globálny názov pomocou @code{define}:

@lisp
(define a 3)
(define druha-mocnina (lambda (x) (* x x)))
(druha-mocnina a)
@result{} 9
@end lisp

@item
Funkcie možno zadávať aj v kratšom tvare s použitím nasledovnej skladby:

@lisp
(define (druha-mocnina x) (* x x))
@end lisp

@item
Zoznam je možné vytvoriť pomocou funkcie @code{list}:

@lisp
(list 2 a 5 7)
@result{} (2 3 5 7)
@end lisp

@item
@dfn{quote} (jednoduchá úvodzkovka) zabraňuje vykonaniu výrazu v zátvorkách:
prvá položka sa nevykoná ako volanie funkcie s ostatnými položkami ako
parametrami (@pxref{Expression Syntax, quote,, guile, GNU Guile Reference
Manual}). Výsledkom je teda zoznam výrazov.

@lisp
'(display (string-append "Ahoj " "Guix" "\n"))
@result{} (display (string-append "Ahoj " "Guix" "\n"))

'(2 a 5 7)
@result{} (2 a 5 7)
@end lisp

@item
@dfn{quasiquote} (obrátená jednoduchá úvodzovka) zabraňuje vykonaniu výrazu
v zátvorke dovtedy, kým nie je jeho vykonanie opätovne povolené pomocou
@dfn{unquote} (čiarky). Týmto spôsobom si zachovávame kontrolu nad tým, čo
sa vykoná a čo nie.

@lisp
`(2 a 5 7 (2 ,a 5 ,(+ a 4)))
@result{} (2 a 5 7 (2 3 5 7))
@end lisp

Všimnite si, že hore uvedený výsledok je zoznam rôznorodých položiek: čísel,
znakov (@code{a}) a posledná položka je tiež zoznam.

@item
Pomocou @code{let} (@pxref{Local Bindings,,, guile, GNU Guile Reference
Manual}) môžeme zadať a pomenovať viacero miestnych premenných:

@lisp
(define x 10)
(let ((x 2)
      (y 3))
  (list x y))
@result{} (2 3)

x
@result{} 10

y
@error{} In procedure module-lookup: Unbound variable: y
@end lisp

Ak chcete, aby bolo možné v neskorších zadaniach premenných odkazovať na
predtým zadané premenné, použite @code{let*}.

@lisp
(let* ((x 2)
       (y (* x 3)))
  (list x y))
@result{} (2 6)
@end lisp

@item
@dfn{Kľúčové slová} sa bežne používajú na stotožnenie pomenovaných
parametrov funkcie. Začínajú sa @code{#:} (mriežkou a dvojbodkou), po
ktorých nasledujú písmenové či číselné znaky:
@code{#:takto}. @xref{Keywords,,, guile, GNU Guile Reference Manual}.

@item
Znak percento @code{%} je bežne používaný pre globálne premenné s prístupom
len na čítanie počas zostavovania. Všimnite si, že je to len všeobecným
zvykom, ako napr. @code{_} v jazyku C. Scheme spracúva  @code{%} ako
hocijaký iný znak.

@item
Moduly sa vytvárajú pomocou @code{define-module} (@pxref{Creating Guile Modules,,, guile, GNU Guile Reference Manual}). Napríklad

@lisp
(define-module (guix build-system ruby)
  #:use-module (guix store)
  #:export (ruby-build
            ruby-build-system))
@end lisp

určuje modul @code{guix build-system ruby}, ktorý má byť umiestnený v
@file{guix/build-system/ruby.scm} niekde vo vyhľadávacej ceste Guilu. Závisí
na module @code{(guix store)} a určuje dve premenné, @code{ruby-build} a
@code{ruby-build-system}.
@end itemize

@quotation Going further
Scheme is a language that has been widely used to teach programming and
you'll find plenty of material using it as a vehicle.  Here's a selection of
documents to learn more about Scheme:

@itemize
@item
@uref{https://spritely.institute/static/papers/scheme-primer.html, @i{A
Scheme Primer}}, by Christine Lemmer-Webber and the Spritely Institute.

@item
@uref{http://www.troubleshooters.com/codecorn/scheme_guile/hello.htm,
@i{Scheme at a Glance}}, by Steve Litt.

@item
@uref{https://mitpress.mit.edu/sites/default/files/sicp/index.html,
@i{Structure and Interpretation of Computer Programs}}, by Harold Abelson
and Gerald Jay Sussman, with Julie Sussman.  Colloquially known as ``SICP'',
this book is a reference.

You can also install it and read it from your computer:

@example
guix install sicp info-reader
info sicp
@end example

An @uref{https://sarabander.github.io/sicp/, unofficial ebook} is also
available.

@end itemize

Ďalšie knihy, návody ako aj iné druhy zdrojov nájdete na
@url{https://schemers.org/}.
@end quotation


@c *********************************************************************
@node Zadávanie balíkov
@chapter Zadávanie balíkov

@cindex zadávanie balíkov

Tento oddiel je zameraný na pridávanie nových balíkov do zbierky balíkov GNU
Guix, čo zahŕňa zadávanie balíkov v Guile Scheme, ich usporadúvanie do
modulov a zostavovanie.

@menu
* Návod na zadávanie balíkov::  Návod na pridávanie balíkov do Guixu.
@end menu

@node Návod na zadávanie balíkov
@section Návod na zadávanie balíkov

GNU Guix sa vyznačuje ako @emph{prispôsobiteľný} správca balíkov hlavne
preto, že používa @uref{https://www.gnu.org/software/guile/, GNU Guile},
výkonný vysokoúrovňový programovací jazyk, jedno z nárečí jazyka
@uref{https://en.wikipedia.org/wiki/Scheme_%28programming_language%29,
Scheme} z jazykovej rodiny
@uref{https://en.wikipedia.org/wiki/Lisp_%28programming_language%29, Lispu}.

Zadania balíkov sú rovnako písané v jazyku Scheme, čo dáva Guixu jedinečnú
výhodu v porovnaní s ostatnými správcami balíkov, ktoré používajú skripty
shellu alebo jednoduché programovacie jazyky.

@itemize
@item
Vo vašich zadaniach balíkov môžete využiť funkcie, štruktúry, makrá a všetku
schopnosť vyjadrovania jazyka Scheme.

@item
Dedičnosť zjednodušuje prispôsobovanie balíka tým, že umožňuje zdediť
vybraný jestvujúci balík a upraviť len to čo je potrebné.

@item
Dávkové spracovanie: celú zbierku balíkov je možné načítať, prefiltrovať a
spracovať. Potrebujete zostaviť server bez grafického rozhrania? Dá sa
to. Potrebujete opätovne zostaviť všetko zo zdrojových súborov s použitím
odlišných optimalizačných príznakov? Pridajte parameter @code{#:make-flags
"..."} do zoznamu balíkov. Tiež by nebolo od veci spomenúť
@uref{https://wiki.gentoo.org/wiki/USE_flag, Gentoo príznak USE}, ale to je
na dlhšie: tvorca balíkov nemusí vopred myslieť na tieto zmeny, pretože ich
môže neskôr @emph{naprogramovať} koncový používateľ!
@end itemize

Nasledovný návod vysvetľuje základy vytvárania balíkov s
Guixom. Nepredpokladá žiadnu znalosť systému Guix ani jazyka Lisp. Čitateľ
by však mal byť oboznámený s príkazovým riadkom a mať aspoň základnú znalosť
programovania.

@node Balík „Vitaj svet“
@subsection Balík „Vitaj svet“

Oddiel „Zadávanie balíkov“ v príručke obsahuje základy tvorby balíkov s
Guixom (@pxref{Defining Packages,,, guix, GNU Guix Reference Manual}). V
nasledovnom oddieli si tieto základy z časti pripomenieme.

GNU@tie{}Hello je šablóna projektu, ktorá slúži ako základný príklad
zadávania balíkov. Využíva zostavovací systém GNU (@code{./configure && make
&& make install}). Guix už obsahuje zadanie príslušného balíka, ktoré
predstavuje vhodný odrazový bod. Môžete si zadanie balíka prezrieť zadaním
@code{guix edit hello} do príkazového riadku. Pozrime sa ako toto zadania
balíka vyzerá:

@lisp
(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 "Hello, GNU world: An example GNU package")
    (description
     "GNU Hello prints the message \"Hello, world!\" and then exits.  It
serves as an example of standard GNU coding practices.  As such, it supports
command-line arguments, multiple languages, and so on.")
    (home-page "https://www.gnu.org/software/hello/")
    (license gpl3+)))
@end lisp

Ako môžete vidieť, tá najobsiahlejšia časť je dosť jednoduchá. Ale prejdime
si spoločne jednotlivé polia:

@table @samp
@item name
Názov projektu. Podľa všeobecných zvyklostí ho zapisujeme malými písmenami,
bez podčiarkovníkov a s použitím pomlčiek na oddelenie jednotlivých slov.

@item source
Toto pole obsahuje popis pôvodu zdrojového kódu. Záznam @code{origin}
obsahuje tieto polia:

@enumerate
@item Spôsob, v tomto prípade @code{url-fetch} pre stiahnutie prostredníctvom HTTP/FTP, ale poznáme
    aj iné spôsoby, ako napr. @code{git-fetch} pre Git repozitáre.
@item Prepojenie (URI), čo obyčajne predstavuje nejaké umiestnenie @code{https://} pre @code{url-fetch}. V tomto prípade
    zvláštne „mirror://gnu“ odkazuje na súbor dobre známych umiestnení, ktoré
môžu byť všetky použité na získanie zdrojového kódu ak by niektoré z nich
nebolo dostupné.
@item Kontrolný súčet @code{sha256} požadovaného súboru. Je dôležitý pre zaistenie
    celistvosti zdroja. Všimnite si, že Guix pracuje z base32 reťazcami, čo
vysvetľuje použitie funkcie @code{base32}.
@end enumerate

@item build-system

Práve tu má príležitosť zažiariť sila všeobecnosti jazyka Scheme: v tomto
prípade, @code{gnu-build-system} je zovšeobecnenie známych príkazov shellu
@code{./configure && make && make install}. Medzi ďalšie zostavovacie
systémy patrí @code{trivial-build-system}, ktorý nerobí nič a necháva na
programátorovi, aby zadal všetky potrebné kroky zostavenia,
@code{python-build-system}, @code{emacs-build-system} a mnohé ďalšie
(@pxref{Build Systems,,, guix, GNU Guix Reference Manual}).

@item synopsis
Toto by mal byť súhrnný popis toho, na čo balík slúži. Pri mnohých balíkoch
je vhodné použiť slogan zo stránky príslušného projektu.

@item description
Podobne ako v prípade súhrnného popisu je vhodné použiť popis projektu z
jeho domovskej stránky. Všimnite si, že Guix používa značkovanie Texinfo.

@item home-page
Použitie HTTPS prepojenie, ak je dostupné.

@item license
Viď @code{guix/licenses.scm} v zdrojovom kóde projektu pre zoznam všetkých
dostupných licencií.
@end table

Nastal čas na zostavenie nášho prvého balíka! Zatiaľ nič zvláštne:
spoľahneme sa jednoducho na kópiu vyššie uvedeného zadania @code{my-hello}.

Tak ako pri rituálnom „Ahoj svet“, ktorý sa vyučuje pri väčšine
programovacích jazykov, toto bude ten „najručnejší“ spôsob zadávania balíka,
ktorý použijete. Neskôr si ukážeme dokonalejší postup, no zatiaľ sa
vyberieme tou najjednoduchšou cestou.

Uložte nasledujúci obsah do súboru s názvom @file{my-hello.scm}.

@lisp
(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 "Hello, Guix world: An example custom Guix package")
  (description
   "GNU Hello prints the message \"Hello, world!\" and then exits.  It
serves as an example of standard GNU coding practices.  As such, it supports
command-line arguments, multiple languages, and so on.")
  (home-page "https://www.gnu.org/software/hello/")
  (license gpl3+))
@end lisp

Dodatočné príkazy si vysvetlíme o chvíľu.

Neváhajte a vyskúšajte si, čo sa stane ak zmeníte hodnoty niektorých
polí. Ak zmeníte zdroj balíka, budete musieť aktualizovať aj kontrolný
súčet. Guix nezostaví nič ak daný kontrolný súčet neodpovedá kontrolnému
súčtu zdrojového kódu. Pre získanie správneho kontrolného súčtu potrebujeme
stiahnuť zdroj, vypočítať kontrolný súčet sha256 a previesť ho do base32.

Našťastie, Guix to môže urobiť za nás; všetko čo budeme potrebovať je
prepojenie (URI) zdroja:

@c TRANSLATORS: This is example shell output.
@example sh
$ guix download mirror://gnu/hello/hello-2.10.tar.gz

Starting download of /tmp/guix-file.JLYgL7
From https://ftpmirror.gnu.org/gnu/hello/hello-2.10.tar.gz...
following redirection to `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
@end example

V tomto konkrétnom prípade nám výstup hovorí, aké zrkadlo bolo vybraté. Ak
výsledok tohto príkazu nie je rovnaký ako v predchádzajúcom úryvku,
aktualizujte vaše zadanie @code{my-hello} podľa potreby.

Všimnite si, že archívy GNU balíkov sú poskytované spolu s OpenPGP podpisom,
takže by ste si jednoznačne mali overiť podpis tohto archívu pomocou „gpg“
predtým než budete pokračovať:

@c TRANSLATORS: This is example shell output.
@example sh
$ guix download mirror://gnu/hello/hello-2.10.tar.gz.sig

Starting download of /tmp/guix-file.03tFfb
From https://ftpmirror.gnu.org/gnu/hello/hello-2.10.tar.gz.sig...
following redirection to `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: Podpis vytvorený Ne 16. november 2014, 13:08:37 CET
gpg:                pomocou RSA kľúča A9553245FDE9B739
gpg: Dobrý podpis od "Sami Kerola <kerolasa@@iki.fi>" neznáme
gpg:                 alias "Sami Kerola (http://www.iki.fi/kerolasa/) <kerolasa@@iki.fi>" neznáme
gpg: VAROVANIE: Tento kľúč nie certifikovaný dôveryhodným podpisom!
gpg:          Nič nenaznačuje tomu, že tento podpis patrí vlastníkovi kľúča.
Primárny fingerprint kľúča: 8ED3 96E3 7E38 D471 A005  30D3 A955 3245 FDE9 B739
@end example

Potom môžete spokojne spustiť

@c TRANSLATORS: Do not translate this command
@example sh
$ guix package --install-from-file=my-hello.scm
@end example

Teraz by ste už mali mať @code{my-hello} vo vašom profile!

@c TRANSLATORS: Do not translate this command
@example sh
$ guix package --list-installed=my-hello
my-hello	2.10	out
/gnu/store/f1db2mfm8syb8qvc357c53slbvf1g9m9-my-hello-2.10
@end example

Dostali sme sa tak ďaleko ako sa dalo bez znalosti Scheme. Predtým než
prejdeme k zložitejším balíkom si dáme rýchlokurz jazyka Scheme. Na začiatok
odporúčame @pxref{Zrýchlené školenie jazyka Scheme}.

@node Nastavenie
@subsection Nastavenie

V ďalších častiach tohto oddielu sa budeme spoliehať na vašu základnú
znalosť jazyka Scheme. Teraz si predstavíme rôzne možnosti práce s balíkmi
Guix.

Jestvuje viacero spôsobov nastavenia prostredia pre zadávanie balíkov Guix.

Odporúčame vám pracovať priamo v repozitári zdrojových súborov Guixu za
účelom jednoduchšieho prispievania do projektu.

Ale najprv sa pozrime na ostatné možnosti.

@node Miestny súbor
@subsubsection Miestny súbor

Toto je spôsob, ktorý sme práve použili v prípade @samp{my-hello}. Vďaka
základom Scheme, ktoré sme si predstavili, vám teraz môžeme vysvetliť tie
najdôležitejšie časti. Ako je uvedené v @code{guix package --help}:

@example
  -f, --install-from-file=SÚBOR
                         inštalovať balíky priamo definované
                         v SÚBORE
@end example

Teda, posledný výraz @emph{musí} vracať balík, čo pre náš skorší príklad aj
platí.

Výraz @code{use-modules} nám hovorí, ktoré moduly potrebujeme. Moduly
predstavujú zbierky hodnôt a funkcií. V iných programovacích jazykoch sa
všeobecne označujú ako „knižnice“ alebo „balíky“.

@node @samp{GUIX_PACKAGE_PATH}
@subsubsection @samp{GUIX_PACKAGE_PATH}

@emph{Upozornenie: Počínajúc Guix 0.16 sú Guix @dfn{channels} uprednostňovaným
spôsobom práce a nahrádzajú použitie @samp{GUIX_PACKAGE_PATH}. Viď
nasledujúci oddiel.}

Uvádzanie súboru so zadaním balíka v príkazovom riadku namiesto použitia
@code{guix package --install my-hello}, ako v prípade oficiálnych balíkov,
môže byť zdĺhavé.

Guix umožňuje zjednodušiť túto úlohu pridaním toľkých „priečinkov zadaní
balíkov“, koľkých chcete.

Vytvorte priečinok, povedzme @file{~/guix-packages} a pridajte cestu k nemu
do premennej prostredia @samp{GUIX_PACKAGE_PATH}:

@example
$ mkdir ~/guix-packages
$ export GUIX_PACKAGE_PATH=~/guix-packages
@end example

Pri pridávaní viacerých priečinkov oddeľte jednotlivé cesty k nim dvojbodkou
(@code{:}).

Avšak, náš predchádzajúci príklad @samp{my-hello} vyžaduje niekoľko úprav:

@lisp
(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 "Hello, Guix world: An example custom Guix package")
    (description
     "GNU Hello prints the message \"Hello, world!\" and then exits.  It
serves as an example of standard GNU coding practices.  As such, it supports
command-line arguments, multiple languages, and so on.")
    (home-page "https://www.gnu.org/software/hello/")
    (license gpl3+)))
@end lisp

Všimnite si, že sme tentokrát zadanie balíka uložili do verejnej premennej
@code{my-hello} pomocou @code{define-public}, na ktorú je možné odkazovať,
medzi iným aj ako na závislosť v rámci zadania nejakého ďalšieho balíka.

Ak spustíte @code{guix package --install-from-file=my-hello.scm} s použitím
vyššie uvedeného súboru, tak príkaz zlyhá, pretože posledný výraz,
@code{define-public}, nevracia balík. Ak aj napriek tomu chcete v tomto
prípade použiť @code{define-public}, uistite sa, že súbor končí vykonaním
@code{my-hello}:

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

my-hello
@end lisp

Tento posledný príklad nie je veľmi bežný.

Teraz by už mal byť @samp{my-hello} súčasťou zbierky balíkov ako všetky
ostatné oficiálne balíky. Môžete si to overiť pomocou:

@example
$ guix package --show=my-hello
@end example

@node Kanály Guix
@subsubsection Kanály Guix

Guix 0.16 uvádza kanály, čo je mechanizmus veľmi podobný
@samp{GUIX_PACKAGE_PATH}, ale ponúka lepšie začlenenie a sledovanie
pôvodu. Kanály nemusia byť miestne, môžu byť udržiavané, napríklad, vo forme
verejných Git repozitárov. Je samozrejme možné použiť viacero kanálov naraz.

Viď @xref{Channels,,, guix, GNU Guix Reference Manual} pre viac podrobností
o používaní kanálov.

@node Priamy zásah do git repozitára
@subsubsection Priamy zásah do git repozitára

Odporúčame vám pracovať priamo v rámci projektu Guix: znižuje to čas
potrebný na odoslanie a zapracovanie vašich zmien do oficiálnej verzie
Guixu, aby aj ostatní mali úžitok z vašej ťažkej práce!

Na rozdiel od väčšiny softvérových distribúcií, repozitár Guixu obsahuje aj
nástroje (vrátane správcu balíkov) aj zadania balíkov. Vývojárom je takto
možné zaistiť pružnosť potrebnú pre upravovanie API bez toho, aby niečo
pokazili. Všetky zadania balíkov sa po každej úprave samy aktualizujú, čím
sa predíde zdržaniam vo vývoji.

Vytvorte si kópiu oficiálneho @uref{https://git-scm.com/, Git} repozitára:

@example
$ git clone https://git.savannah.gnu.org/git/guix.git
@end example

Vo zvyšku tohto príspevku použijeme pri odkazovaní na túto kópiu premennú
@samp{$GUIX_CHECKOUT}.


Pre nastavenie prostredia repozitára postupujte podľa pokynov v príručke
(@pxref{Contributing,,, guix, GNU Guix Reference Manual}).

Keď budete pripravení, mali by ste byť schopní použiť zadania balíkov z
prostredia repozitára.

Nebojte sa upravovať zadania balíkov v @samp{$GUIX_CHECKOUT/gnu/packages}.

Skript @samp{$GUIX_CHECKOUT/pre-inst-env} vám umožňuje použiť @samp{guix} so
zbierkou balíkov v repozitári (@pxref{Running Guix Before It Is Installed,,,
guix, GNU Guix Reference Manual}).

@itemize
@item
Vyhľadávajte balíky, napríklad Ruby:

@example
  $ cd $GUIX_CHECKOUT
  $ ./pre-inst-env guix package --list-available=ruby
      ruby    1.8.7-p374      out     gnu/packages/ruby.scm:119:2
      ruby    2.1.6   out     gnu/packages/ruby.scm:91:2
      ruby    2.2.2   out     gnu/packages/ruby.scm:39:2
@end example

@item
Zostavte balík, v tomto prípade Ruby vo verzii 2.1:

@example
  $ ./pre-inst-env guix build --keep-failed ruby@@2.1
  /gnu/store/c13v73jxmj2nir2xjqaz5259zywsa9zi-ruby-2.1.6
@end example

@item
Nainštaluje ho do vášho používateľského profilu:

@example
  $ ./pre-inst-env guix package --install ruby@@2.1
@end example

@item
Overte si, či ste neurobili niektorú z častých chýb:

@example
  $ ./pre-inst-env guix lint ruby@@2.1
@end example
@end itemize

Guix sa usiluje udržať vysokú úroveň zadávania balíkov; pri prispievaní do
projektu Guix si zapamätajte, že je potrebné

@itemize
@item
dodržiavať spôsob kódovania (@pxref{Coding Style,,, guix, GNU Guix Reference
Manual}),
@item
a prejsť si kontrolný zoznam z príručky (@pxref{Submitting Patches,,, guix,
GNU Guix Reference Manual}).
@end itemize

Keď ste spokojní s výsledkom, privítame, ak nám zašlete váš príspevok, aby
sa mohol stať súčasťou Guixu. Tento postup je tiež opísaný v
príručke. (@pxref{Contributing,,, guix, GNU Guix Reference Manual})


Guix závisí od spoločného úsilia, preto čím viac ľudí prispeje, tým bude
Guix lepší!

@node Zložitejší príklad
@subsection Zložitejší príklad

Vyššie uvedený príklad zadania balíka „Ahoj svet“ je taký jednoduchý ako sa
len dá. Avšak, zadania balíkov môžu byť zložitejšie a Guix si poradí aj s
omnoho náročnejšími balíkmi. Pozrime sa teda na iné, zložitejšie zadanie
balíka (mierne upravené v porovnaní s pôvodným zadaním):

@lisp
(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 ssh)
  #:use-module (gnu packages web)
  #:use-module (gnu packages pkg-config)
  #:use-module (gnu packages python)
  #:use-module (gnu packages compression)
  #:use-module (gnu packages tls))

(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)))
                ;; Odstrániť pribalený softvér.
                (snippet '(delete-file-recursively "deps"))))
      (build-system cmake-build-system)
      (outputs '("out" "debug"))
      (arguments
       `(#:tests? #true                         ; Preveriť výsledok zostavenia (predvolené).
         #:configure-flags '("-DUSE_SHA1DC=ON") ; Zisťovanie rozporov v odtlačkoch 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")))))
           ;; Bohatší výstup pri preverovaní zostavenia
           (replace 'check
             (lambda _ (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
       ;; Tieto dve knižnice sa nachádzajú v „Requires.private“ v libgit2.pc.
       (list openssl zlib))
      (home-page "https://libgit2.github.com/")
      (synopsis "Library providing Git core methods")
      (description
       "Libgit2 is a portable, pure C implementation of the Git core methods
provided as a re-entrant linkable library with a solid API, allowing you to
write native speed custom Git applications in any language with bindings.")
      ;; GPLv2 s odkazovou výnimkou
      (license license:gpl2))))
@end lisp

(V prípade, že chcete zmeniť len pár polí v pôvodnom zadaní balíka by ste sa
mali spoľahnúť na dedičnosť namiesto skopírovania celého zadania. Viď
nižšie.)

Pozrime sa teraz na tieto polia zblízka.

@subsubsection spôsob @code{git-fetch}

Narozdiel od funkcie @code{url-fetch}, @code{git-fetch} vyžaduje
@code{git-reference}, ktorú určuje Git repozitár a príslušná úprava. Úpravou
sa rozumie akýkoľvek odkaz Git ako napríklad značka. Teda, ak je
@code{version} označená, tak je možné použiť priamo číslo verzie. Niekedy
majú značky verzií perdponu @code{v}. V tomto prípade môžete použiť
@code{(commit (string-append "v" version))}.

Aby sme sa uistili, že sa zdrojový kód z Git repozitára uloží do priečinka s
výstižným názvom, použijeme @code{(file-name (git-file-name name version))}.

Keď zadávate balík pre program s určitým číslom úpravy, môžete pre odvodenie
správneho označenia verzie použiť funkciu @code{git-version} podľa pokynov v
príručke prispievateľa do Guixu (@pxref{Version Numbers,,, guix, GNU Guix
Reference Manual}).

Pýtate sa ako získať správny odtlačok @code{sha256}? Vyvolaním @command{guix
hash} na miestnej kópii repozitára v požadovanej úprave, asi takto:

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

@command{guix hash -rx} vypočíta odtlačok SHA256 celého priečinka
nezahŕňajúc pod-priečinok @file{.git} (@pxref{Invoking guix hash,,, guix,
GNU Guix Reference Manual}).

Do budúcna bude snáď @command{guix download} schopný vykonávať tieto kroky
za vás, tak ako je tomu pri bežných sťahovaniach súborov.

@subsubsection Kusy kódu

Kusy kódu predstavujú malé časti Scheme kódu v úvodzovkách, t.j. bežne
nevykonávané, ktoré sa používajú na plátanie zdrojových súborov. Je to taká
Guixová náhrada za dobre známe @file{.patch} súbory. Vďaka úvodzovkám sa
daný kód vykoná len vtedy, keď sa odošle démonovi Guixu na zostavenie. V
praxi môžeme použiť toľko kusov kódu, koľko potrebujeme.

Kusy kódu môžu vyžadovať prídavné moduly Guilu, ktoré je možné načítať
pomocou poľa @code{modules}.

@subsubsection Vstupy

Jestvujú tri rôzne druhy vstupov. V skratke:

@table @asis
@item native-inputs
Vyžadované pri zostavovaní ale nie pri spúšťaní. V prípade inštalácie balíka
prostredníctvom náhrady sa tieto vstupy nebudú inštalovať.
@item vstupy
Inštalované do úložiska ale nie do profilu a prítomné pri zostavovaní.
@item propagated-inputs
Inštalované do úložiska aj do profilu a prítomné pri zostavovaní.
@end table

@xref{package Reference,,, guix, GNU Guix Reference Manual} for more
details.

Správne rozlišovanie medzi jednotlivými druhmi vstupov je dôležité: ak je
možné závislosť zaradiť ako @emph{input} namiesto @emph{propagated input},
tak by sa to tak malo urobiť. Inak bezdôvodne „znečistí“ používateľský
profil.

Napríklad, ak inštalujete grafický program, ktorý závisí na nejakom nástroji
spúšťanom v príkazovom riadku, tak vám pravdepodobne ide len o tú grafickú
časť. Nie je teda potrebné siliť inštaláciu nástroja spúšťaného v príkazovom
riadku do používateľského profilu. Závislosti sú spravované balíkmi a nie
používateľmi. @emph{Vstupy} umožňujú spravovať závislosti bez toho, aby to
nejako zaťažovalo používateľov pridávaním neužitočných programov či knižníc
do ich profilu.

Rovnako to platí aj pre @emph{native-inputs}: po inštalácii programu môžu
byť závislosti vyžadované pri zostavovaní bezpečne odstránené zberačom
odpadkov. Okrem toho, ak je dostupná binárna náhrada, stiahnu sa len
@emph{inputs} a @emph{propagated inputs}: @emph{native inputs} nie sú pri
inštalácii balíka prostredníctvom náhrady potrebné.

@quotation Poznámka
Tu a tam nájdete úryvky, v ktorých sú vstupy zapísané pomerne odlišne, teda
asi takto:

@lisp
;; „Pôvodný tvar“ zápisu vstupov
(inputs
 `(("libssh2" ,libssh2)
   ("http-parser" ,http-parser)
   ("python" ,python-wrapper)))
@end lisp

Toto je „pôvodný tvar“, v ktorom má každá položka zoznamu vstupov pridelenú
menovku (reťazec).  Tento tvar je stále podporovaný ale odporúčame vám
používať už len vyššie uvedený tvar.  Viď @xref{package Reference,,, guix,
GNU Guix Reference Manual} pre viac podrobností.
@end quotation

@subsubsection Výstupy

Tak ako môže mať balík viacero vstupov, môže mať aj viacero výstupov.

Každý výstup má osobitný priečinok v úložisku.

Používateľ si môže vybrať, ktorý výstup nainštaluje; pomáha to šetriť úložné
miesto a predchádzať znečisteniu používateľského profilu nechcenými
programami či knižnicami.

Oddeľovanie výstupov je voliteľné. Ak sa pole @code{outputs} vynechá,
predvoleným a jediným výstupom (celý balík) bude @code{"out"}.

Často vidíme oddelené výstupy s názvom @code{debug} alebo @code{doc}.

Oddelené výstupy by ste mali používať len vtedy, keď sa to oplatí: ak je
výstup značne veľký (možno porovnať pomocou @code{guix size}), alebo ak je
balík modulárny.

@subsubsection Argumenty zostavovacieho systému

Pole @code{arguments} obsahuje páry kľúč-hodnota používané pri nastavovaní
postupu zostavenia.

Ten najjednoduchší argument @code{#:tests?} možno použiť na vynechanie
testov po zostavení balíka. Je to užitočné najmä v prípade, keď balík
neobsahuje žiadnu testovaciu súpravu. Je dôrazne odporúčané ponechať
testovaciu súpravu povolenú, ak je nejaká dostupná.

Ďalším bežným argumentom je @code{:make-flags} určujúci zoznam dodatočných
príznakov, ktoré sa majú použiť pri spúšťaní nástroja make ako keby ste
pridali priamo do príkazového riadku. Napríklad, nasledovné príznaky

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

sú chápané ako

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

Toto nastaví prekladač jazyka C na @code{gcc} a premennú @code{prefix}
(cieľový priečinok inštalácie v prípade nástroja Make) na @code{(assoc-ref
%outputs "out")}, čo predstavuje globálnu premennú prítomnú pri zostavovaní,
ktorá udáva cestu k cieľovému priečinku v úložisku (niečo ako
@file{/gnu/store/...-my-libgit2-20180408}).

Podobným spôsobom môžete nastaviť aj príznaky nastavenia:

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

Dostupná je aj premenná @code{%build-inputs}. Predstavuje tabuľku, ktorá
priraďuje názvy vstupov k ich priečinkom v úložisku.

Kľúčové slovo @code{phases} predstavuje postupnosť krokov zostavovacieho
systému. Medzi bežné kroky patria @code{unpack}, @code{configure},
@code{build}, @code{install} a @code{check}. Ak chcete o týchto krokoch
zistiť viac, musíte nájsť to správne zadanie zostavovacieho systému v
@samp{$GUIX_CHECKOUT/guix/build/gnu-build-system.scm}:

@lisp
(define %standard-phases
  ;; Standard build phases, as a list of symbol/procedure pairs.
  (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
            install-license-files
            reset-gzip-timestamps
            compress-documentation)))
@end lisp

Alebo cez REPL:

@lisp
(add-to-load-path "/path/to/guix/checkout")
,use (guix build gnu-build-system)
(map first %standard-phases)
@result{} (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 install-license-files reset-gzip-timestamps compress-documentation)
@end lisp

Ak chcete vedieť čo sa počas jednotlivých krokov odohráva, preštudujte si
príslušné funkcie.

Napríklad, v čase písania týchto riadkov, bolo zadanie kroku @code{unpack} v
zostavovacom systéme GNU nasledovné:

@lisp
(define* (unpack #:key source #:allow-other-keys)
  "Unpack SOURCE in the working directory, and change directory within the
source.  When SOURCE is a directory, copy it in a sub-directory of the current
working directory."
  (if (file-is-directory? source)
      (begin
        (mkdir "source")
        (chdir "source")

        ;; Preserve timestamps (set to the Epoch) on the copied tree so that
        ;; things work deterministically.
        (copy-recursively source "."
                          #:keep-mtime? #true))
      (begin
        (if (string-suffix? ".zip" source)
            (invoke "unzip" source)
            (invoke "tar" "xvf" source))
        (chdir (first-subdirectory "."))))
  #true)
@end lisp

Všimnite si volanie @code{chdir}: zmení súčasný priečinok na umiestnenie,
kde boli rozbalené zdrojové súbory. To znamená, že kroky nasledujúce po
@code{unpack} použijú priečinok so zdrojovými súbormi ako ich pracovný
priečinok. Preto môžeme priamo narábať so zdrojovými súbormi. Teda aspoň
dovtedy, kým niektorý ďalší krok nezmení pracovný priečinok na iný.

Zoznam krokov @code{%standard-phases} zostavovacieho systému upravujeme
pomocou makra @code{modify-phases} určujúceho aké úpravy sa majú vykonať, čo
môže vyzerať asi takto:

@itemize
@item
@code{(add-before @var{krok} @var{novy-krok} @var{funkcia})}: Spustiť
@var{funkcia} s názvom @var{novy-krok} pred @var{krok}.
@item
@code{(add-after @var{krok} @var{novy-krok} @var{funkcia})}: Tak isto, ale
za @var{krok}.
@item
@code{(replace @var{krok} @var{funkcia})}.
@item
@code{(delete @var{krok})}.
@end itemize

@var{Funkcia} prijíma parametre @code{inputs} a @code{outputs} v tvare
kľúčových slov.  Každý vstup (či už @emph{pôvodný}, @emph{rozšírený} alebo
nie) a výstupný priečinok je označený svojim názvom v týchto premenných.
Takže @code{(assoc-ref outputs "out")} predstavuje priečinok úložiska
hlavného výstupu balíka.  Funkcia kroku vyzerá nasledovne:

@lisp
(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")))
    ;; ...
    #true))
@end lisp

Funkcia musí po úspešnom vykonaní vrátiť @code{#true}.  Nie je veľmi
spoľahlivé opierať sa o návratovú hodnotu posledného výrazu keďže nie je
isté, že to bude práve @code{#true}.  Koncové @code{#true} zaisťuje, že bude
po úspešnom vykonaní vrátená správna hodnota.

@subsubsection Oddialené vykonanie

Ak ste boli pozorní, mohli ste si všimnúť obrátenú úvodzovku a čiarku v poli
parametrov.  Vskutku, zdrojový kód zostavenia v zadaní balíka by sa nemal
vykonávať na strane klienta, ale až vtedy, keď sa odovzdá démonovi Guixu.
Toto odovzdávanie zdrojového kódu medzi dvoma procesmi nazývame
@uref{https://arxiv.org/abs/1709.00833, oddialené vykonanie}.

@subsubsection Pomocné funkcie

Pri prispôsobovaní @code{phases} budete často potrebovať funkcie
zodpovedajúce systémovým volaniam (@code{make}, @code{mkdir}, @code{cp},
atď.), ktoré sú zvyčajne dostupné na Unixových systémoch.

Niektoré z nich, ako napríklad @code{chmod}, sú priamo dostupné v jazyku
Guile.  Viď úplný zoznam v @xref{,,, guile, Guile reference manual}.

Guix poskytuje ďalšie pomocné funkcie, užitočné najmä v súvislosti so
správou balíkov.

Niektoré z týchto funkcií sa nachádzajú v
@samp{$GUIX_CHECKOUT/guix/guix/build/utils.scm}.  Väčšinou napodobňujú
správanie pôvodných Unixových systémových príkazov:

@table @code
@item which
Rovnaká ako systémový príkaz @samp{which}.
@item find-files
Podobná príkazu @samp{find}.
@item mkdir-p
Rovnaká ako príkaz @samp{mkdir -p}, ktorý v prípade potreby vytvorí aj
všetky nadradené priečinky.
@item install-file
Podobná ako príkaz @samp{install} na inštaláciu súboru do priečinka (aj
nejestvujúceho). Guile má funkciu @code{copy-file}, ktorá funguje ako príkaz
@samp{cp}.
@item copy-recursively
Ako @samp{cp -r}.
@item delete-file-recursively
Ako @samp{rm -rf}.
@item invoke
Vyvolať spustiteľný súbor.  Toto by ste mali používať namiesto
@code{system*}.
@item with-directory-excursion
Vykoná telo funkcie v odlišnom pracovnom priečinku a následne obnoví pôvodný
pracovný priečinok.
@item substitute*
Funkcia podobná príkazu @command{sed}.
@end table

Viď @xref{Build Utilities,,, guix, GNU Guix Reference Manual} pre viac
podrobností o pomocných funkciách.

@subsubsection Predpony modulov

Licencia v našom predošlom príklade je uvedená s predponou vzhľadom na
spôsob akým bol načítaný modul @code{licenses} v tomto balíku:
@code{#:use-module ((guix licenses) #:prefix license:)}.  Spôsob načítavania
modulov v Guile (@pxref{Using Guile Modules,,, guile, Guile reference
manual}) používateľovi dáva úplnú kontrolu nad menným priestorom.  Môže sa
tak predísť rozporom, povedzme, medzi premennou @samp{zlib} zo súboru
@samp{licenses.scm} (názov @emph{licencie}) a premennou @samp{zlib} zo
súboru @samp{compression.scm} (názov @emph{balíka}).

@node Ďalšie zostavovacie systémy
@subsection Ďalšie zostavovacie systémy

To čo sme doteraz videli pokrýva väčšinu balíkov využívajúcich iný
zostavovací systém ako je @code{trivial-build-system}, ktorý nič
neautomatizuje a nechá vás všetko zostaviť ručne.  Tento postup môže byť
náročnejší a zatiaľ sa tu ním nebudeme zaoberať.  Našťastie je nutné uchýliť
sa k nemu len zriedkavo.

Pri ostatných zostavovacích systémoch, ako sú ASDF, Emacs, Perl, Ruby a
mnoho ďalších, je postup, okrem niekoľkých zvláštnych parametrov, veľmi
podobný zostavovaciemu systému GNU.

Viď @xref{Build Systems,,, guix, GNU Guix Reference Manual} alebo zdrojový
kód v priečinkoch @samp{$GUIX_CHECKOUT/guix/build} a
@samp{$GUIX_CHECKOUT/guix/build-system} pre viac podrobností o zostavovacích
systémoch.

@node Programovateľné a automatické zadávanie balíkov
@subsection Programovateľné a automatické zadávanie balíkov

Nemôžme to nezdôrazniť: mať po ruke plnohodnotný programovací jazyk nám
umožňuje oveľa viac než len bežnú správu balíkov.

Ukážme si to na príklade niekoľkých úžasných súčastí Guixu!

@node Rekurzívne nahrávače
@subsubsection Rekurzívne nahrávače

Niektoré zostavovacie systémy sú natoľko dobré, že toho na zadanie balíka
ani veľa netreba, a to až do takej miery, že sa vám zadávanie balíkov rýchlo
zunuje.  Jedným z dôvodov bytia počítačov je nahradiť ľudí pri vykonávaní
týchto nudných činností.  Nechajme teda Guix urobiť to za nás a vytvoriť
zadanie nejakého balíka R pochádzajúceho z CRANu (výstup bol skrátený pre
ušetrenie miesta):

@example
$ 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 "Robust Statistical Methods")
    (description
      "This package provides a toolbox of common robust statistical
tests, including robust descriptives, robust t-tests, and robust ANOVA.
It is also available as a module for 'jamovi' (see
<https://www.jamovi.org> for more information).  Walrus is based on the
WRS2 package by Patrick Mair, which is in turn based on the scripts and
work of Rand Wilcox.  These analyses are described in depth in the book
'Introduction to Robust Estimation & Hypothesis Testing'.")
    (license gpl3)))
@end example

Rekurzívny nahrávač nahrá len balíky, pre ktoré Guix ešte nemá zadanie,
okrem úplne prvého.

Takto vytvoriť zadania balíkov nie je možné pre všetky aplikácie, iba pre
tie, ktoré sa opierajú o vybraný počet podporovaných systémov.  Viď úplný
zoznam nahrávačov v príslušnom oddiele príručky (@pxref{Invoking guix import,,, guix, GNU Guix Reference Manual}).

@node Automatické aktualizácie
@subsubsection Automatické aktualizácie

Guix môže byť dostatočne múdry na to, aby vyhľadal aktualizácie v systémoch,
ktoré pozná.  To, ktoré balíky sú zastarané možno zistiť pomocou

@example
$ guix refresh hello
@end example

Vo väčšine prípadov vyžaduje aktualizácia balíka na novšiu verziu len o
niečo viac ako zmeniť číslo verzie a kontrolný súčet.  Aj toto môže Guix
vykonať automaticky:

@example
$ guix refresh hello --update
@end example

@node Dedičnosť
@subsubsection Dedičnosť

Ak ste si už začali prezerať zadania jestvujúcich balíkov, možno ste si
všimli, že niektoré z nich obsahujú pole @code{inherit}:

@lisp
(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")))))
@end lisp

Všetky neupresnené polia sú zdedené z nadradeného balíka.  Je to veľmi
užitočné na vytváranie obmien balíkov, napr. s odlišným zdrojom, verziou
alebo voľbami zostavenia.

@node Získavanie pomoci
@subsection Získavanie pomoci

Nanešťastie, zadanie balíka môže byť pre niektoré aplikácie veľmi zložité.
Niekedy je potrebná záplata, aby mohla aplikácia fungovať v neobyčajnom
systéme súborov úložiska. Niekedy sa zase sústava testov nespúšťa správne
(môžete ich preskočiť ale neodporúča sa to).  Inokedy nie je výsledný balík
opakovateľný.

Keď už neviete ako ďalej a nie ste schopní prísť na to, ako vyriešiť nejakú
ťažkosť so zadávaním balíka, neváhajte požiadať o pomoc spoločenstvo.

Viď @uref{https://www.gnu.org/software/guix/contact/, Guix homepage} pre
podrobnosti o elektronických konferenciách, IRC, atď.

@node Záver
@subsection Záver

Tento návod vám predviedol vyumelkovanú správu balíkov, ktorou sa Guix
chváli.  V tejto chvíli sme tento úvod zúžili na @code{gnu-build-system}
predstavujúci ústrednú abstrakčnú vrstvu, na ktorej sú založené
pokročilejšie abstrakčné vrstvy.

Kam teraz? Ďalej by sme si mali posvietiť na vnútorné fungovanie
zostavovacích systémov vynechajúc všetky abstrakčné vrstvy prostredníctvom
@code{trivial-build-system}. Malo by nám to umožniť lepšie porozumieť
postupu zostavenia, skôr ako sa dostaneme k pokročilejším postupom a
výnimkám.

Ďalšie funkcie, ktoré sa oplatí preskúmať, sú interaktívna úprava a možnosti
ladenia Guixu poskytované cez Guile REPL@.

Tieto pokročilé funkcie sú len doplnkové a môžu počkať. Teraz je ten správny
čas na zaslúženú prestávku.  S tým, čo sme si ukázali, by ste si mali
vystačiť pri zadávaní balíkov pre mnoho programov.  Môžete sa do toho hneď
pustiť a dúfame, že nás vašim príspevkom potešíte už čoskoro!

@node Odkazy
@subsection Odkazy

@itemize
@item
@uref{https://www.gnu.org/software/guix/manual/en/html_node/Defining-Packages.html,
odvolávka na „package“ v príručke}

@item
@uref{https://gitlab.com/pjotrp/guix-notes/blob/master/HACKING.org, Pjotrova
príručka na prispôsobenie GNU Guix}

@item
@uref{https://www.gnu.org/software/guix/guix-ghm-andreas-20130823.pdf, „GNU
Guix: Package without a scheme!“}, od Andreasa Engeho
@end itemize

@c *********************************************************************
@node Nastavenie systému
@chapter Nastavenie systému

Guix ponúka všestranný jazyk na deklaratívne nastavenie vášho systému Guix.
Táto všestrannosť sa môže niekedy zdať nadmerná.  Účelom tohto oddielu je
predstaviť niektoré pokročilé spôsoby nastavenia.

Viď úplnú odvolávku v @pxref{Nastavenie systému,,, guix, GNU Guix
Reference Manual}.

@menu
* Automatické pripojenie k určitému TTY::  Automaticky pripojiť 
                                                používateľa k určitému 
                                                TTY
* Prispôsobenie jadra::     Vytvorenie a používanie vlastného 
                               Linuxového jadra v systéme Guix.
* API pre vytváranie obrazov systému Guix::  Prispôsobenie obrazov 
                                                 nezvyčajným platformám.
* Using security keys::      How to use security keys with Guix System.
* Pripojenie k Wireguard VPN::  Pripojenie k Wireguard VPN sieti.
* Prispôsobenie správcu okien::  Spravovať prispôsobenie správcu okien 
                                     v systéme Guix.
* Spúšťanie Guixu na serveri Linode::  Spúšťanie Guixu na serveri 
                                            Linode
* Nastavenie podvojného pripojenia::  Nastavenie podvojného pripojenia v 
                                         zadaní systému súborov.
* Získavanie náhrad prostredníctvom Tor::  Nastavenie démona Guix na 
                                                získavanie náhrad cez Tor.
* Nastavenia NGINX a Lua::   Nastavenie web-servera NGINX na načítavanie 
                               Lua modulov.
* Music Server with Bluetooth Audio::  Headless music player with Bluetooth 
                                         output.
@end menu

@node Automatické pripojenie k určitému TTY
@section Automatické pripojenie k určitému TTY

Zatiaľ čo príručka pre Guix popisuje automatické prihlásenie jedného
používateľa ku @emph{všetkým} TTY (@pxref{auto-login to TTY,,, guix, GNU
Guix Reference Manual}), mohol by vám viac vyhovovať stav, keď je jeden
používateľ pripojený k jednému TTY a ostatné TTY sú nastavené na
prihlasovanie ďalších používateľov alebo nikoho.  Všimnite si, že jedného
používateľa je možné automaticky prihlásiť k akémukoľvek TTY. Avšak, je
lepšie vynechať @code{tty1}, ktorý je predvolene využívaný na zobrazovanie
varovaných a chybových hlásení.

Takto je možné nastaviť automatické prihlásenie jedného používateľa k
jednému TTY:

@lisp
(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
    ;; @dots{}
    (mingetty-service-type config =>
                           (auto-login-to-tty
                            config "tty3" "alice"))))

(operating-system
  ;; @dots{}
  (services %my-services))
@end lisp

Tiež je možné použiť @code{compose} (@pxref{Higher-Order Functions,,, guile,
The Guile Reference Manual}) s @code{auto-login-to-tty} pre prihlásenie
viacerých používateľov k viacerým TTY.

Varovanie na koniec.  Nastavenie automatického prihlásenia k TTY znamená, že
ktokoľvek môže zapnúť váš počítač a spúšťať príkazy ako zvyčajný
používateľ.  Hoci, ak používate zašifrovaný koreňový systém a pri spustení
systému je nutné zadať heslo, automatické prihlásenie predstavuje praktickú
možnosť.


@node Prispôsobenie jadra
@section Prispôsobenie jadra

Guix je, vo svojom jadre, distribúcia založená na zdrojových súboroch a
náhradách (@pxref{Substitutes,,, guix, GNU Guix Reference Manual}).
Zostavovanie balíkov z ich zdrojových súborov je teda prirodzenou súčasťou
inštalácie a aktualizácie balíkov.  Vzhľadom na túto skutočnosť dáva zmysel
snaha o zníženie množstva času potrebného na zostavenie balíkov a nedávne
zmeny v zostavovaní a šírení náhrad sú aj naďalej súčasťou rozhovorov vrámci
projektu Guix.

Aj keď nevyžaduje veľké množstvo pamäte RAM, zostavenie jadra na priemerných
počítačoch môže trvať veľmi dlho.  Oficiálne nastavenie jadra, tak ako je to
v prípade mnohých iných distribúcií GNU/Linuxu, sa prikláňa k širšej ponuke
súčastí a to je to, čo spôsobuje, že zostavenie jadra zo zdrojových súborov
trvá tak dlho.

Avšak, aj samotné jadro Linuxu možno opísať ako balík a teda prispôsobiť ho
rovnako ako hociktorý iný balík.  Postup je mierne odlišný, aj keď hlavne
kvôli tomu ako je zadanie balíka napísané.

Balík jadra @code{linux-libre} je vlastne funkcia tvoriaca balík.

@lisp
(define* (make-linux-libre* version gnu-revision source supported-systems
                            #:key
                            (extra-version #f)
                            ;; Funkcia vyžadujúca označenie a druh architektúry.
                            ;; Viď príklad v kernel-config.
                            (configuration-file #f)
                            (defconfig "defconfig")
                            (extra-options %default-extra-linux-options))
  ...)
@end lisp

Terajší balík @code{linux-libre} pre vydania 5.15.x je zadaný nasledovne:

@lisp
(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))
@end lisp

Kľúče, ktoré nemajú pridelenú hodnotu dedia ich predvolenú hodnotu zo
zadania @code{make-linux-libre}.  Pri porovnávaní vyššie uvedených úryvkov
zdrojového kódu si všimnite komentár odvolávajúci sa na
@code{#:configuration-file}.  Kvôli tomu vlastne nie je jednoduché zahrnúť
do zadania svoje vlastné nastavenie jadra, ale nezúfajte, pretože jestvujú
ďalšie spôsoby ako pracovať s tým čo máme.

Jestvujú dva spôsoby ako vytvoriť jadro s vlastným nastavením.  Prvý je
poskytnúť zvyčajný súbor @file{.config} počas zostavenia zahrnutím tohto
súboru do pôvodných vstupov nášho vlastného jadra.  Nižšie je uvedený úryvok
kódu vlastného @code{'configure} kroku zo zadania balíka
@code{make-linux-libre}:

@lisp
(let ((build  (assoc-ref %standard-phases 'build))
      (config (assoc-ref (or native-inputs inputs) "kconfig")))

  ;; Použiť vlastný alebo predvolený súbor
  ;; nastavenia jadra.
  (if config
      (begin
        (copy-file config ".config")
        (chmod ".config" #o666))
      (invoke "make" ,defconfig)))
@end lisp

Tu je príklad balíka jadra. Balík @code{linux-libre} nie je ničím výnimočný,
môžeme ho zdediť a nahradiť jeho pôvodné polia ako pri hociktorom inom
balíku:

@lisp
(define-public linux-libre/E2140
  (package
    (inherit linux-libre)
    (native-inputs
     `(("kconfig" ,(local-file "E2140.config"))
      ,@@(alist-delete "kconfig"
                      (package-native-inputs linux-libre))))))
@end lisp

V rovnakom priečinku, kde je súbor zadávajúci @code{linux-libre-E2140} je aj
súbor s názvom @file{E2140.config}, ktorý predstavuje súbor nastavenia
jadra.  Kľúčové slovo @code{defconfig} funkcie @code{make-linux-libre} je tu
ponechané prázdne, takže jediné nastavenie jadra v balíku je to, ktoré bolo
zahrnuté do poľa @code{native-inputs}.

Druhý spôsob ako vytvoriť vlastné jadro je dať novú hodnotu kľúčovému slovu
@code{extra-options} funkcie @code{make-linux-libre}.  Kľúčové slovo
@code{extra-options} funguje s inou funkciou zadanou nižšie:

@lisp
(define %default-extra-linux-options
  `(;; https://lists.gnu.org/archive/html/guix-devel/2014-04/msg00039.html
   ("CONFIG_DEVPTS_MULTIPLE_INSTANCES" . #true)
   ;; Moduly potrebné pre 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"))
@end lisp

A vo vlastnom „configure“ skripte balíka „make-linux-libre“:

@lisp
;; Vkladanie na koniec funguje aj keď voľba v súbore nebola.
;; Pri viacnásobnom uvedení prevažuje to posledné.
(let ((port (open-file ".config" "a"))
      (extra-configuration ,(config->string extra-options)))
  (display extra-configuration port)
  (close-port port))

(invoke "make" "oldconfig")
@end lisp

Takže, neposkytnutie súboru nastavenia spôsobí, že je súbor @file{.config}
spočiatku prázdny. Potom doň zapíšeme voľby, ktoré chceme.  Viď ďalšie
vlastné zadanie jadra:

@lisp
(define %macbook41-full-config
  (append %macbook41-config-options
          %file-systems
          %efi-support
          %emulation
          (@@@@ (gnu packages linux) %default-extra-linux-options)))

(define-public linux-libre-macbook41
  ;; XXX: Prístup k funkcii „make-linux-libre*“, ktorá je súkromná,
  ;; neexportuje sa a v budúcnosti by sa mohla zmeniť.
  ((@@@@ (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))
@end lisp

V hore uvedenom príklade je @code{%file-systems} zbierkou volieb
povoľujúcich podporu rôznych systémov súborov, @code{%efi-support} povoľuje
podporu EFI a @code{%emulation} povoľuje strojom x86_64-linux pracovať v
32-bitovom režime.  Voľby @code{%default-extra-linux-options} sú tie
citované vyššie, ktoré bolo treba pridať, keďže boli prepísané v kľúčovom
slove @code{extra-options}.

Všetko toto znie veľmi dobre, ale ako zistiť, ktoré moduly vyžaduje určitý
systém? Na túto otázku nám môžu pomôcť odpovedať dva zdroje:
@uref{https://wiki.gentoo.org/wiki/Handbook:AMD64/Installation/Kernel,
Príručka Gentoo} a
@uref{https://www.kernel.org/doc/html/latest/admin-guide/README.html?highlight=localmodconfig,
dokumentácia samotného jadra}.  Podľa dokumentácie jadra sa zdá, že
@code{make localmodconfig} je príkaz, ktorý hľadáme.

Skôr ako budeme môcť spustiť @code{make localmodconfig}, musíme stiahnuť a
rozbaliť zdrojové súbory jadra:

@example shell
tar xf $(guix build linux-libre --source)
@end example

V priečinku obsahujúcom zdrojové súbory spustite @code{touch .config} pre
vytvorenie počiatočného prázdneho @file{.config} súboru.  @code{make
localmodconfig} funguje tak, že zistí, čo ste už zadali do @file{.config} a
povie vám, čo vám ešte chýba.  Ak je súbor prázdny, tak vám chýba všetko.
Ďalším krokom je spustiť:

@example shell
guix shell -D linux-libre -- make localmodconfig
@end example

a pozrite si výstup.  Všimnite si, že súbor @file{.config} je stále
prázdny.  Výstup obvykle obsahuje dva druhy varovných správ.  Prvá začína
slovom „WARNING“ a v našom prípade si ju nemusíme všímať.  Druhá správa nám
hovorí, že:

@example shell
module pcspkr did not have configs CONFIG_INPUT_PCSPKR
@end example

Pre každý z týchto riadkov skopírujte časť @code{CONFIG_XXXX_XXXX} do
@file{.config} súboru priečinka a pridajte @code{=m} tak, aby nakoniec
vyzeral takto:

@example shell
CONFIG_INPUT_PCSPKR=m
CONFIG_VIRTIO=m
@end example

Po skopírovaní všetkých volieb nastavenia znova spustite @code{make
localmodconfig}, aby ste sa uistili, že výstup už neobsahuje žiadne správy
začínajúce slovom „module“.  Okrem všetkých týchto modulov vzťahujúcich sa k
stroju nám ostáva ešte niekoľko ďalších dôležitých modulov.
@code{CONFIG_MODULES} umožňuje zostavovať a načítavať moduly oddelene, aby
nemuseli byť zabudované do jadra.  @code{CONFIG_BLK_DEV_SD} umožňuje čítať
pevné disky.  Je tiež možné, že budete potrebovať aj iné moduly.

Tento príspevok nemá za úlohu vás previesť nastavením vášho vlastného
jadra. Ak sa rozhodnete zostaviť si vlastné jadro, budete si musieť nájsť
iné návody na vytvorenie jadra, ktoré vám bude vyhovovať.

Druhý spôsob nastavenia jadra využíva funkcie Guixu vo väčšej miere a
umožňuje vám zdieľať časti nastavenia medzi rôznymi jadrami.  Napríklad,
všetky stroje používajúce na zavádzanie EFI vyžadujú určitý počet volieb
nastavenia EFI.  Je tiež pravdepodobné, že viaceré jadrá budú zdieľať
podporu niekoľkých súborových systémov.  Použitím premenných je jednoduchšie
spozorovať, ktoré súčasti sú povolené a uistiť sa, či nie sú niektoré z nich
prítomné v jednom jadre ale v druhom chýbajú.

Nepozreli sme sa však na initrd a jeho prispôsobenie.  Je pravdepodobné, že
budete potrebovať prispôsobiť initrd na stroji s vlastným jadrom, keďže
niektoré moduly nemusia byť dostupné pre zahrnutie do initrd.

@node API pre vytváranie obrazov systému Guix
@section API pre vytváranie obrazov systému Guix

Z dejinného pohľadu je systém Guix sústredený okolo štruktúry
@code{operating-system}.  Táto štruktúra obsahuje rôzne polia počínajúc
zadaním zavádzača a jadra až k službám, ktoré sa majú nainštalovať.

Požiadavky na obraz sa môžu značne líšiť v závislosti na cieľovom stroji, čo
môže byť obvyklý @code{x86_64} alebo malý jednodoskový počítač ako
Pine64. Výrobcovia technického vybavenia presadzujú rôzne formáty obrazov s
rôznymi veľkosťami a umiestneniami oddielov.

Na vytváranie obrazov vhodných pre všetky tieto stroje je nevyhnutné ďalšie
zovšeobecnenie, čo je cieľom záznamu @code{image}.  Tento záznam obsahuje
všetky potrebné údaje k premene na samostatný obraz, ktorý je možno priamo
zaviesť na hocijakom cieľovom stroji.

@lisp
(define-record-type* <image>
  image make-image
  image?
  (name               image-name ;symbol
                      (default #f))
  (format             image-format) ;symbol
  (target             image-target
                      (default #f))
  (size               image-size  ;size in bytes as integer
                      (default 'guess))
  (operating-system   image-operating-system  ;<operating-system>
                      (default #f))
  (partitions         image-partitions ;list of <partition>
                      (default '()))
  (compression?       image-compression? ;boolean
                      (default #t))
  (volatile-root?     image-volatile-root? ;boolean
                      (default #t))
  (substitutable?     image-substitutable? ;boolean
                      (default #t)))
@end lisp

Tento záznam obsahuje operačný systém na zostavenie. Pole @code{format}
určuje druh obrazu a medzi jeho platné hodnoty patria @code{efi-raw},
@code{qcow2} alebo @code{iso9660}. V budúcnosti by sa mohli rozšíriť o
@code{docker} a ďalšie druhy obrazov.

Na zadávanie obrazov bol spomedzi zdrojových súborov Guixu vyhradený nový
priečinok. Zatiaľ sa v ňom nachádzajú štyri súbory:

@itemize @bullet
@item @file{gnu/system/images/hurd.scm}
@item @file{gnu/system/images/pine64.scm}
@item @file{gnu/system/images/novena.scm}
@item @file{gnu/system/images/pinebook-pro.scm}
@end itemize

Pozrime sa na @file{pine64.scm}. Obsahuje premennú
@code{pine64-barebones-os} predstavujúcu najmenšie možné zadanie operačného
systému určeného pre dosku @b{Pine A64 LTS}.

@lisp
(define pine64-barebones-os
  (operating-system
   (host-name "vignemale")
   (timezone "Europe/Bratislava")
   (locale "sk_SK.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 "moj-korenovy-system"))
                        (mount-point "/")
                        (type "ext4"))
                       %base-file-systems))
   (services (cons (service agetty-service-type
                            (agetty-configuration
                             (extra-options '("-L")) ; bez zisťovania nosného signálu
                             (baud-rate "115200")
                             (term "vt100")
                             (tty "ttyS0")))
                   %base-services))))
@end lisp

Polia @code{kernel} a @code{bootloader} odkazujú na balíky určené pre túto
dosku.

Tesne pod nimi je zadaná aj premenná @code{pine64-image-type}.

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

Využíva záznam, o ktorom sme ešte nehovorili, a teda @code{image-type},
zadaný nasledovne:

@lisp
(define-record-type* <image-type>
  image-type make-image-type
  image-type?
  (name           image-type-name) ; znak
  (constructor    image-type-constructor)) ; <operating-system> -> <image>
@end lisp

Hlavným účelom tohto záznamu je priradiť názov funkcii pretvárajúcej
@code{operating-system} na obraz.  Aby sme pochopili, prečo je to dôležité,
pozrime sa na príkaz vytvárajúci obraz zo súboru nastavení
@code{operating-system}:

@example
guix system image moj-os.scm
@end example

Tento príkaz očakáva nastavenie druhu @code{operating-system}, ale ako by
sme mali určiť, že chceme obraz pre dosku Pine64? Musíme poskytnúť
doplňujúci údaj, @code{image-type}, pomocou voľby @code{--image-type} alebo
@code{-t} a to takto:

@example
guix system image --image-type=pine64-raw moj-os.scm
@end example

This @code{image-type} parameter points to the @code{pine64-image-type}
defined above. Hence, the @code{operating-system} declared in
@code{my-os.scm} will be applied the @code{(cut image-with-os
arm64-disk-image <>)} procedure to turn it into an image.

The resulting image looks like:

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

which is the aggregation of the @code{operating-system} defined in
@code{my-os.scm} to the @code{arm64-disk-image} record.

But enough Scheme madness. What does this image API bring to the Guix user?

One can run:

@example
mathieu@@cervin:~$ guix system --list-image-types
The available image types are:

   - pinebook-pro-raw
   - pine64-raw
   - novena-raw
   - hurd-raw
   - hurd-qcow2
   - qcow2
   - uncompressed-iso9660
   - efi-raw
   - arm64-raw
   - arm32-raw
   - iso9660
@end example

and by writing an @code{operating-system} file based on
@code{pine64-barebones-os}, you can customize your image to your preferences
in a file (@file{my-pine-os.scm}) like this:

@lisp
(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)))))
@end lisp

run:

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

or,

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

to get an image that can be written directly to a hard drive and booted
from.

Without changing anything to @code{my-hurd-os.scm}, calling:

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

will instead produce a Hurd QEMU image.

@node Using security keys
@section Using security keys
@cindex 2FA, two-factor authentication
@cindex U2F, Universal 2nd Factor
@cindex security key, configuration

The use of security keys can improve your security by providing a second
authentication source that cannot be easily stolen or copied, at least for a
remote adversary (something that you have), to the main secret (a passphrase
-- something that you know), reducing the risk of impersonation.

The example configuration detailed below showcases what minimal
configuration needs to be made on your Guix System to allow the use of a
Yubico security key.  It is hoped the configuration can be useful for other
security keys as well, with minor adjustments.

@subsection Configuration for use as a two-factor authenticator (2FA)

To be usable, the udev rules of the system should be extended with
key-specific rules.  The following shows how to extend your udev rules with
the @file{lib/udev/rules.d/70-u2f.rules} udev rule file provided by the
@code{libfido2} package from the @code{(gnu packages security-token)} module
and add your user to the @samp{"plugdev"} group it uses:

@lisp
(use-package-modules ... security-token ...)
...
(operating-system
 ...
 (users (cons* (user-account
               (name "your-user")
               (group "users")
               (supplementary-groups
		'("wheel" "netdev" "audio" "video"
                  "plugdev"))           ;<- added system group
               (home-directory "/home/your-user"))
              %base-user-accounts))
 ...
 (services
  (cons*
   ...
   (udev-rules-service 'fido2 libfido2 #:groups '("plugdev")))))
@end lisp

After re-configuring your system and re-logging in your graphical session so
that the new group is in effect for your user, you can verify that your key
is usable by launching:

@example
guix shell ungoogled-chromium -- chromium chrome://settings/securityKeys
@end example

and validating that the security key can be reset via the ``Reset your
security key'' menu.  If it works, congratulations, your security key is
ready to be used with applications supporting two-factor authentication
(2FA).

@node Pripojenie k Wireguard VPN
@section Pripojenie k Wireguard VPN

To connect to a Wireguard VPN server you need the kernel module to be loaded
in memory and a package providing networking tools that support it (e.g.
@code{wireguard-tools} or @code{network-manager}).

Here is a configuration example for Linux-Libre < 5.6, where the module is
out of tree and need to be loaded manually---following revisions of the
kernel have it built-in and so don't need such configuration:

@lisp
(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)))
@end lisp

After reconfiguring and restarting your system you can either use Wireguard
tools or NetworkManager to connect to a VPN server.

@subsection Using Wireguard tools

To test your Wireguard setup it is convenient to use @command{wg-quick}.
Just give it a configuration file @command{wg-quick up ./wg0.conf}; or put
that file in @file{/etc/wireguard} and run @command{wg-quick up wg0}
instead.

@quotation Poznámka
Be warned that the author described this command as a: “[…] very quick and
dirty bash script […]”.
@end quotation

@subsection Using NetworkManager

Thanks to NetworkManager support for Wireguard we can connect to our VPN
using @command{nmcli} command.  Up to this point this guide assumes that
you're using Network Manager service provided by @code{%desktop-services}.
Ortherwise you need to adjust your services list to load
@code{network-manager-service-type} and reconfigure your Guix system.

To import your VPN configuration execute nmcli import command:

@example shell
# nmcli connection import type wireguard file wg0.conf
Connection 'wg0' (edbee261-aa5a-42db-b032-6c7757c60fde) successfully added
@end example

This will create a configuration file in
@file{/etc/NetworkManager/wg0.nmconnection}.  Next connect to the Wireguard
server:

@example shell
$ nmcli connection up wg0
Connection successfully activated (D-Bus active path: /org/freedesktop/NetworkManager/ActiveConnection/6)
@end example

By default NetworkManager will connect automatically on system boot.  To
change that behaviour you need to edit your config:

@example shell
# nmcli connection modify wg0 connection.autoconnect no
@end example

For more specific information about NetworkManager and wireguard
@uref{https://blogs.gnome.org/thaller/2019/03/15/wireguard-in-networkmanager/,see
this post by thaller}.

@node Prispôsobenie správcu okien
@section Prispôsobenie správcu okien
@cindex wm

@node StumpWM
@subsection StumpWM
@cindex stumpwm

You could install StumpWM with a Guix system by adding @code{stumpwm} and
optionally @code{`(,stumpwm "lib")} packages to a system configuration file,
e.g.@: @file{/etc/config.scm}.

An example configuration can look like this:

@lisp
(use-modules (gnu))
(use-package-modules wm)

(operating-system
  ;; …
  (packages (append (list sbcl stumpwm `(,stumpwm "lib"))
                    %base-packages)))
@end lisp

@cindex stumpwm fonts
By default StumpWM uses X11 fonts, which could be small or pixelated on your
system.  You could fix this by installing StumpWM contrib Lisp module
@code{sbcl-ttf-fonts}, adding it to Guix system packages:

@lisp
(use-modules (gnu))
(use-package-modules fonts wm)

(operating-system
  ;; …
  (packages (append (list sbcl stumpwm `(,stumpwm "lib"))
                    sbcl-ttf-fonts font-dejavu %base-packages)))
@end lisp

Then you need to add the following code to a StumpWM configuration file
@file{~/.stumpwm.d/init.lisp}:

@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))
@end lisp

@node Session lock
@subsection Session lock
@cindex sessionlock

Depending on your environment, locking the screen of your session might come
built in or it might be something you have to set up yourself. If you use a
desktop environment like GNOME or KDE, it's usually built in. If you use a
plain window manager like StumpWM or EXWM, you might have to set it up
yourself.

@node Xorg
@subsubsection Xorg

If you use Xorg, you can use the utility
@uref{https://www.mankier.com/1/xss-lock, xss-lock} to lock the screen of
your session.  xss-lock is triggered by DPMS which since Xorg 1.8 is
auto-detected and enabled if ACPI is also enabled at kernel runtime.

To use xss-lock, you can simple execute it and put it into the background
before you start your window manager from e.g. your @file{~/.xsession}:

@example
xss-lock -- slock &
exec stumpwm
@end example

In this example, xss-lock uses @code{slock} to do the actual locking of the
screen when it determines it's appropriate, like when you suspend your
device.

For slock to be allowed to be a screen locker for the graphical session, it
needs to be made setuid-root so it can authenticate users, and it needs a
PAM service. This can be achieved by adding the following service to your
@file{config.scm}:

@lisp
(screen-locker-service slock)
@end lisp

If you manually lock your screen, e.g. by directly calling slock when you
want to lock your screen but not suspend it, it's a good idea to notify
xss-lock about this so no confusion occurs. This can be done by executing
@code{xset s activate} immediately before you execute slock.

@node Spúšťanie Guixu na serveri Linode
@section Spúšťanie Guixu na serveri Linode
@cindex linode, Linode

To run Guix on a server hosted by @uref{https://www.linode.com, Linode},
start with a recommended Debian server.  We recommend using the default
distro as a way to bootstrap Guix. Create your SSH keys.

@example
ssh-keygen
@end example

Be sure to add your SSH key for easy login to the remote server.  This is
trivially done via Linode's graphical interface for adding SSH keys.  Go to
your profile and click add SSH Key.  Copy into it the output of:

@example
cat ~/.ssh/<username>_rsa.pub
@end example

Power the Linode down.

In the Linode's Storage tab, resize the Debian disk to be smaller.  30 GB
free space is recommended.  Then click "Add a disk", and fill out the form
with the following:

@itemize @bullet
@item
Label: "Guix"

@item
Filesystem: ext4

@item
Set it to the remaining size
@end itemize

In the Configurations tab, press "Edit" on the default Debian profile.
Under "Block Device Assignment" click "Add a Device". It should be
@file{/dev/sdc} and you can select the "Guix" disk. Save Changes.

Now "Add a Configuration", with the following:
@itemize @bullet
@item
Label: Guix

@item
Kernel:GRUB 2 (it's at the bottom! This step is @b{IMPORTANT!})

@item
Block device assignment:

@item
@file{/dev/sda}: Guix

@item
@file{/dev/sdb}: swap

@item
Root device: @file{/dev/sda}

@item
Turn off all the filesystem/boot helpers
@end itemize

Now power it back up, booting with the Debian configuration.  Once it's
running, ssh to your server via @code{ssh
root@@@var{<your-server-IP-here>}}. (You can find your server IP address in
your Linode Summary section.) Now you can run the "install guix from
@pxref{Binary Installation,,, guix, GNU Guix}" steps:

@example
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
@end example

Now it's time to write out a config for the server.  The key information is
below. Save the resulting file as @file{guix-config.scm}.

@lisp
(use-modules (gnu)
             (guix modules))
(use-service-modules networking
                     ssh)
(use-package-modules admin
                     certs
                     package-management
                     ssh
                     tls)

(operating-system
  (host-name "my-server")
  (timezone "America/New_York")
  (locale "en_US.UTF-8")
  ;; This goofy code will generate the grub.cfg
  ;; without installing the grub bootloader on disk.
  (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"    ; Needed to find the disk
                        %base-initrd-modules))

  (users (cons (user-account
                (name "janedoe")
                (group "users")
                ;; Adding the account to the "wheel" group
                ;; makes it a sudoer.
                (supplementary-groups '("wheel"))
                (home-directory "/home/janedoe"))
               %base-user-accounts))

  (packages (cons* nss-certs            ;for HTTPS access
                   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)))
@end lisp

Replace the following fields in the above configuration:
@lisp
(host-name "my-server")       ; replace with your server name
; if you chose a linode server outside the U.S., then
; use tzselect to find a correct timezone string
(timezone "America/New_York") ; if needed replace timezone
(name "janedoe")              ; replace with your username
("janedoe" ,(local-file "janedoe_rsa.pub")) ; replace with your ssh key
("root" ,(local-file "janedoe_rsa.pub")) ; replace with your ssh key
@end lisp

The last line in the above example lets you log into the server as root and
set the initial root password (see the note at the end of this recipe about
root login).  After you have done this, you may delete that line from your
configuration and reconfigure to prevent root login.

Copy your ssh public key (eg: @file{~/.ssh/id_rsa.pub}) as
@file{@var{<your-username-here>}_rsa.pub} and put @file{guix-config.scm} in
the same directory.  In a new terminal run these commands.

@example
sftp root@@<remote server ip address>
put /path/to/files/<username>_rsa.pub .
put /path/to/files/guix-config.scm .
@end example

In your first terminal, mount the guix drive:

@example
mkdir /mnt/guix
mount /dev/sdc /mnt/guix
@end example

Due to the way we set up the bootloader section of the guix-config.scm, only
the grub configuration file will be installed.  So, we need to copy over
some of the other GRUB stuff already installed on the Debian system:

@example
mkdir -p /mnt/guix/boot/grub
cp -r /boot/grub/* /mnt/guix/boot/grub/
@end example

Now initialize the Guix installation:

@example
guix system init guix-config.scm /mnt/guix
@end example

Ok, power it down! Now from the Linode console, select boot and select
"Guix".

Once it boots, you should be able to log in via SSH! (The server config will
have changed though.)  You may encounter an error like:

@example
$ ssh root@@<server ip address>
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@    WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED!     @
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
IT IS POSSIBLE THAT SOMEONE IS DOING SOMETHING NASTY!
Someone could be eavesdropping on you right now (man-in-the-middle attack)!
It is also possible that a host key has just been changed.
The fingerprint for the ECDSA key sent by the remote host is
SHA256:0B+wp33w57AnKQuHCvQP0+ZdKaqYrI/kyU7CfVbS7R4.
Please contact your system administrator.
Add correct host key in /home/joshua/.ssh/known_hosts to get rid of this message.
Offending ECDSA key in /home/joshua/.ssh/known_hosts:3
ECDSA host key for 198.58.98.76 has changed and you have requested strict checking.
Host key verification failed.
@end example

Either delete @file{~/.ssh/known_hosts} file, or delete the offending line
starting with your server IP address.

Be sure to set your password and root's password.

@example
ssh root@@<remote ip address>
passwd  ; for the root password
passwd <username> ; for the user password
@end example

You may not be able to run the above commands at this point.  If you have
issues remotely logging into your linode box via SSH, then you may still
need to set your root and user password initially by clicking on the
``Launch Console'' option in your linode.  Choose the ``Glish'' instead of
``Weblish''.  Now you should be able to ssh into the machine.

Hooray! At this point you can shut down the server, delete the Debian disk,
and resize the Guix to the rest of the size.  Congratulations!

By the way, if you save it as a disk image right at this point, you'll have
an easy time spinning up new Guix images! You may need to down-size the Guix
image to 6144MB, to save it as an image.  Then you can resize it again to
the max size.

@node Nastavenie podvojného pripojenia
@section Nastavenie podvojného pripojenia

To bind mount a file system, one must first set up some definitions before
the @code{operating-system} section of the system definition.  In this
example we will bind mount a folder from a spinning disk drive to
@file{/tmp}, to save wear and tear on the primary SSD, without dedicating an
entire partition to be mounted as @file{/tmp}.

First, the source drive that hosts the folder we wish to bind mount should
be defined, so that the bind mount can depend on it.

@lisp
(define source-drive ;; "source-drive" can be named anything you want.
   (file-system
    (device (uuid "UUID goes here"))
    (mount-point "/path-to-spinning-disk-goes-here")
    (type "ext4"))) ;; Make sure to set this to the appropriate type for your drive.
@end lisp

The source folder must also be defined, so that guix will know it's not a
regular block device, but a folder.
@lisp
(define (%source-directory) "/path-to-spinning-disk-goes-here/tmp") ;; "source-directory" can be named any valid variable name.
@end lisp

Finally, inside the @code{file-systems} definition, we must add the mount
itself.

@lisp
(file-systems (cons*

                ...<other drives omitted for clarity>...

                source-drive ;; Must match the name you gave the source drive in the earlier definition.

                (file-system
                 (device (%source-directory)) ;; Make sure "source-directory" matches your earlier definition.
                 (mount-point "/tmp")
                 (type "none") ;; We are mounting a folder, not a partition, so this type needs to be "none"
                 (flags '(bind-mount))
                 (dependencies (list source-drive)) ;; Ensure "source-drive" matches what you've named the variable for the drive.
                 )

                 ...<other drives omitted for clarity>...

                ))
@end lisp

@node Získavanie náhrad prostredníctvom Tor
@section Získavanie náhrad prostredníctvom Tor

Guix daemon can use a HTTP proxy to get substitutes, here we are configuring
it to get them via Tor.

@quotation Upozornenie
@emph{Not all} Guix daemon's traffic will go through Tor! Only HTTP/HTTPS
will get proxied; FTP, Git protocol, SSH, etc connections will still go
through the clearnet.  Again, this configuration isn't foolproof some of
your traffic won't get routed by Tor at all.  Use it at your own risk.

Also note that the procedure described here applies only to package
substitution. When you update your guix distribution with @command{guix
pull}, you still need to use @command{torsocks} if you want to route the
connection to guix's git repository servers through Tor.
@end quotation

Guix's substitute server is available as a Onion service, if you want to use
it to get your substitutes through Tor configure your system as follow:

@lisp
(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)
                      ;; ci.guix.gnu.org's Onion service
                      (substitute-urls
                       "@value{SUBSTITUTE-TOR-URL}")
                      (http-proxy "http://localhost:9250")))))))
@end lisp

This will keep a tor process running that provides a HTTP CONNECT tunnel
which will be used by @command{guix-daemon}.  The daemon can use other
protocols than HTTP(S) to get remote resources, request using those
protocols won't go through Tor since we are only setting a HTTP tunnel
here.  Note that @code{substitutes-urls} is using HTTPS and not HTTP or it
won't work, that's a limitation of Tor's tunnel; you may want to use
@command{privoxy} instead to avoid such limitations.

If you don't want to always get substitutes through Tor but using it just
some of the times, then skip the @code{guix-configuration}.  When you want
to get a substitute from the Tor tunnel run:

@example
sudo herd set-http-proxy guix-daemon http://localhost:9250
guix build \
  --substitute-urls=@value{SUBSTITUTE-TOR-URL} @dots{}
@end example

@node Nastavenia NGINX a Lua
@section Nastavenia NGINX a Lua
@cindex nginx, lua, openresty, resty

NGINX could be extended with Lua scripts.

Guix provides NGINX service with ability to load Lua module and specific Lua
packages, and reply to requests by evaluating Lua scripts.

The following example demonstrates system definition with configuration to
evaluate @file{index.lua} Lua script on HTTP request to
@uref{http://localhost/hello} endpoint:

@example
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)
@end example

@lisp
(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"))))))))))))))
@end lisp

@node Music Server with Bluetooth Audio
@section Music Server with Bluetooth Audio
@cindex mpd
@cindex music server, headless
@cindex bluetooth, ALSA configuration

MPD, the Music Player Daemon, is a flexible server-side application for
playing music.  Client programs on different machines on the network --- a
mobile phone, a laptop, a desktop workstation --- can connect to it to
control the playback of audio files from your local music collection.  MPD
decodes the audio files and plays them back on one or many outputs.

By default MPD will play to the default audio device.  In the example below
we make things a little more interesting by setting up a headless music
server.  There will be no graphical user interface, no Pulseaudio daemon,
and no local audio output.  Instead we will configure MPD with two outputs:
a bluetooth speaker and a web server to serve audio streams to any streaming
media player.

Bluetooth is often rather frustrating to set up.  You will have to pair your
Bluetooth device and make sure that the device is automatically connected as
soon as it powers on.  The Bluetooth system service returned by the
@code{bluetooth-service} procedure provides the infrastructure needed to set
this up.

Reconfigure your system with at least the following services and packages:

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

Start the @code{bluetooth} service and then use @command{bluetoothctl} to
scan for Bluetooth devices.  Try to identify your Bluetooth speaker and pick
out its device ID from the resulting list of devices that is indubitably
dominated by a baffling smorgasbord of your neighbors' home automation
gizmos.  This only needs to be done once:

@example
$ 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]# Agent registered

[bluetooth]# default-agent
[bluetooth]# Default agent request successful

[bluetooth]# scan on
[bluetooth]# Discovery started
[CHG] Controller 00:11:22:33:95:7F Discovering: yes
[NEW] Device AA:BB:CC:A4:AA:CD My Bluetooth Speaker
[NEW] Device 44:44:FF:2A:20:DC My Neighbor's TV
@dots{}

[bluetooth]# pair AA:BB:CC:A4:AA:CD
Attempting to pair with AA:BB:CC:A4:AA:CD
[CHG] Device AA:BB:CC:A4:AA:CD Connected: yes

[My Bluetooth Speaker]# [CHG] Device AA:BB:CC:A4:AA:CD UUIDs: 0000110b-0000-1000-8000-00xxxxxxxxxx
[CHG] Device AA:BB:CC:A4:AA:CD UUIDs: 0000110c-0000-1000-8000-00xxxxxxxxxx
[CHG] Device AA:BB:CC:A4:AA:CD UUIDs: 0000110e-0000-1000-8000-00xxxxxxxxxx
[CHG] Device AA:BB:CC:A4:AA:CD Paired: yes
Pairing successful

[CHG] Device AA:BB:CC:A4:AA:CD Connected: no

[bluetooth]# 
[bluetooth]# trust AA:BB:CC:A4:AA:CD
[bluetooth]# [CHG] Device AA:BB:CC:A4:AA:CD Trusted: yes
Changing AA:BB:CC:A4:AA:CD trust succeeded

[bluetooth]# 
[bluetooth]# connect AA:BB:CC:A4:AA:CD
Attempting to connect to AA:BB:CC:A4:AA:CD
[bluetooth]# [CHG] Device AA:BB:CC:A4:AA:CD RSSI: -63
[CHG] Device AA:BB:CC:A4:AA:CD Connected: yes
Connection successful

[My Bluetooth Speaker]# scan off
[CHG] Device AA:BB:CC:A4:AA:CD RSSI is nil
Discovery stopped
[CHG] Controller 00:11:22:33:95:7F Discovering: no
@end example

Congratulations, you can now automatically connect to your Bluetooth
speaker!

It is now time to configure ALSA to use the @emph{bluealsa} Bluetooth
module, so that you can define an ALSA pcm device corresponding to your
Bluetooth speaker.  For a headless server using @emph{bluealsa} with a fixed
Bluetooth device is likely simpler than configuring Pulseaudio and its
stream switching behavior.  We configure ALSA by crafting a custom
@code{alsa-configuration} for the @code{alsa-service-type}.  The
configuration will declare a @code{pcm} type @code{bluealsa} from the
@code{bluealsa} module provided by the @code{bluez-alsa} package, and then
define a @code{pcm} device of that type for your Bluetooth speaker.

All that is left then is to make MPD send audio data to this ALSA device.
We also add a secondary MPD output that makes the currently played audio
files available as a stream through a web server on port 8080.  When enabled
a device on the network could listen to the audio stream by connecting any
capable media player to the HTTP server on port 8080, independent of the
status of the Bluetooth speaker.

What follows is the outline of an @code{operating-system} declaration that
should accomplish the above-mentioned tasks:

@lisp
(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 "your-username")
             (music-dir "/path/to/your/music")
             (address "192.168.178.20")
             (outputs (list (mpd-output
                             (type "alsa")
                             (name "MPD")
                             (extra-options
                              ;; Use the same name as in the ALSA
                              ;; configuration below.
                              '((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") ;no limit
                                (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) ;we don't need it
             (extra-options
              #~(string-append "\
# Declare Bluetooth audio device type \"bluealsa\" from bluealsa module
pcm_type.bluealsa @{
    lib \"" #$(file-append bluez-alsa "/lib/alsa-lib/libasound_module_pcm_bluealsa.so") "\"
@}

# Declare control device type \"bluealsa\" from the same module
ctl_type.bluealsa @{
    lib \"" #$(file-append bluez-alsa "/lib/alsa-lib/libasound_module_ctl_bluealsa.so") "\"
@}

# Define the actual Bluetooth audio device.
pcm.btspeaker @{
    type bluealsa
    device \"AA:BB:CC:A4:AA:CD\" # unique device identifier
    profile \"a2dp\"
@}

# Define an associated controller.
ctl.btspeaker @{
    type bluealsa
@}
"))))))
@end lisp

Enjoy the music with the MPD client of your choice or a media player capable
of streaming via HTTP!


@c *********************************************************************
@node Containers
@chapter Containers

The kernel Linux provides a number of shared facilities that are available
to processes in the system.  These facilities include a shared view on the
file system, other processes, network devices, user and group identities,
and a few others.  Since Linux 3.19 a user can choose to @emph{unshare} some
of these shared facilities for selected processes, providing them (and their
child processes) with a different view on the system.

A process with an unshared @code{mount} namespace, for example, has its own
view on the file system --- it will only be able to see directories that
have been explicitly bound in its mount namespace.  A process with its own
@code{proc} namespace will consider itself to be the only process running on
the system, running as PID 1.

Guix uses these kernel features to provide fully isolated environments and
even complete Guix System containers, lightweight virtual machines that
share the host system's kernel.  This feature comes in especially handy when
using Guix on a foreign distribution to prevent interference from foreign
libraries or configuration files that are available system-wide.

@menu
* Guix Containers::          Perfectly isolated environments
* Guix System Containers::   A system inside your system
@end menu

@node Guix Containers
@section Guix Containers

The easiest way to get started is to use @command{guix shell} with the
@option{--container} option.  @xref{Invoking guix shell,,, guix, GNU Guix
Reference Manual} for a reference of valid options.

The following snippet spawns a minimal shell process with most namespaces
unshared from the system.  The current working directory is visible to the
process, but anything else on the file system is unavailable.  This extreme
isolation can be very useful when you want to rule out any sort of
interference from environment variables, globally installed libraries, or
configuration files.

@example
guix shell --container
@end example

It is a bleak environment, barren, desolate.  You will find that not even
the GNU coreutils are available here, so to explore this deserted wasteland
you need to use built-in shell commands.  Even the usually gigantic
@file{/gnu/store} directory is reduced to a faint shadow of itself.

@example sh
$ echo /gnu/store/*
/gnu/store/@dots{}-gcc-10.3.0-lib
/gnu/store/@dots{}-glibc-2.33
/gnu/store/@dots{}-bash-static-5.1.8
/gnu/store/@dots{}-ncurses-6.2.20210619
/gnu/store/@dots{}-bash-5.1.8
/gnu/store/@dots{}-profile
/gnu/store/@dots{}-readline-8.1.1
@end example

@cindex exiting a container
There isn't much you can do in an environment like this other than exiting
it.  You can use @key{^D} or @command{exit} to terminate this limited shell
environment.

@cindex exposing directories, container
@cindex sharing directories, container
@cindex mapping locations, container
You can make other directories available inside of the container
environment; use @option{--expose=DIRECTORY} to bind-mount the given
directory as a read-only location inside the container, or use
@option{--share=DIRECTORY} to make the location writable.  With an
additional mapping argument after the directory name you can control the
name of the directory inside the container.  In the following example we map
@file{/etc} on the host system to @file{/the/host/etc} inside a container in
which the GNU coreutils are installed.

@example sh
$ guix shell --container --share=/etc=/the/host/etc coreutils
$ ls /the/host/etc
@end example

Similarly, you can prevent the current working directory from being mapped
into the container with the @option{--no-cwd} option.  Another good idea is
to create a dedicated directory that will serve as the container's home
directory, and spawn the container shell from that directory.

@cindex hide system libraries, container
@cindex avoid ABI mismatch, container
On a foreign system a container environment can be used to compile software
that cannot possibly be linked with system libraries or with the system's
compiler toolchain.  A common use-case in a research context is to install
packages from within an R session.  Outside of a container environment there
is a good chance that the foreign compiler toolchain and incompatible system
libraries are found first, resulting in incompatible binaries that cannot be
used by R.  In a container shell this problem disappears, as system
libraries and executables simply aren't available due to the unshared
@code{mount} namespace.

Let's take a comprehensive manifest providing a comfortable development
environment for use with R:

@lisp
(specifications->manifest
  (list "r-minimal"

        ;; base packages
        "bash-minimal"
        "glibc-locales"
        "nss-certs"

        ;; Common command line tools lest the container is too empty.
        "coreutils"
        "grep"
        "which"
        "wget"
        "sed"

        ;; R markdown tools
        "pandoc"

        ;; Toolchain and common libraries for "install.packages"
        "gcc-toolchain@@10"
        "gfortran-toolchain"
        "gawk"
        "tar"
        "gzip"
        "unzip"
        "make"
        "cmake"
        "pkg-config"
        "cairo"
        "libxt"
        "openssl"
        "curl"
        "zlib"))
@end lisp

Let's use this to run R inside a container environment.  For convenience we
share the @code{net} namespace to use the host system's network interfaces.
Now we can build R packages from source the traditional way without having
to worry about ABI mismatch or incompatibilities.

@example sh
$ 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
@dots{}
> 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()))
@dots{}
* installing *source* package 'Cairo' ...
@dots{}
* DONE (Cairo)

The downloaded source packages are in
	'/tmp/RtmpCuwdwM/downloaded_packages'
> library("Cairo", lib=getwd())
> # success!
@end example

Using container shells is fun, but they can become a little cumbersome when
you want to go beyond just a single interactive process.  Some tasks become
a lot easier when they sit on the rock solid foundation of a proper Guix
System and its rich set of system services.  The next section shows you how
to launch a complete Guix System inside of a container.


@node Guix System Containers
@section Guix System Containers

The Guix System provides a wide array of interconnected system services that
are configured declaratively to form a dependable stateless GNU System
foundation for whatever tasks you throw at it.  Even when using Guix on a
foreign distribution you can benefit from the design of Guix System by
running a system instance as a container.  Using the same kernel features of
unshared namespaces mentioned in the previous section, the resulting Guix
System instance is isolated from the host system and only shares file system
locations that you explicitly declare.

A Guix System container differs from the shell process created by
@command{guix shell --container} in a number of important ways.  While in a
container shell the containerized process is a Bash shell process, a Guix
System container runs the Shepherd as PID 1.  In a system container all
system services (@pxref{Services,,, guix, GNU Guix Reference Manual}) are
set up just as they would be on a Guix System in a virtual machine or on
bare metal---this includes daemons managed by the GNU@tie{}Shepherd
(@pxref{Shepherd Services,,, guix, GNU Guix Reference Manual}) as well as
other kinds of extensions to the operating system (@pxref{Service Composition,,, guix, GNU Guix Reference Manual}).

The perceived increase in complexity of running a Guix System container is
easily justified when dealing with more complex applications that have
higher or just more rigid requirements on their execution
contexts---configuration files, dedicated user accounts, directories for
caches or log files, etc.  In Guix System the demands of this kind of
software are satisfied through the deployment of system services.


@node A Database Container
@subsection A Database Container

A good example might be a PostgreSQL database server.  Much of the
complexity of setting up such a database server is encapsulated in this
deceptively short service declaration:

@lisp
(service postgresql-service-type
         (postgresql-configuration
          (postgresql postgresql-14)))
@end lisp

A complete operating system declaration for use with a Guix System container
would look something like this:

@lisp
(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 "does-not-matter"))
                        (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)))
@end lisp

With @code{postgresql-role-service-type} we define a role ``test'' and
create a matching database, so that we can test right away without any
further manual setup.  The @code{postgresql-config-file} settings allow a
client from IP address 10.0.0.1 to connect without requiring
authentication---a bad idea in production systems, but convenient for this
example.

Let's build a script that will launch an instance of this Guix System as a
container.  Write the @code{operating-system} declaration above to a file
@file{os.scm} and then use @command{guix system container} to build the
launcher.  (@pxref{Invoking guix system,,, guix, GNU Guix Reference
Manual}).

@example
$ guix system container os.scm
The following derivations will be built:
  /gnu/store/@dots{}-run-container.drv
  @dots{}
building /gnu/store/@dots{}-run-container.drv...
/gnu/store/@dots{}-run-container
@end example

Now that we have a launcher script we can run it to spawn the new system
with a running PostgreSQL service.  Note that due to some as yet unresolved
limitations we need to run the launcher as the root user, for example with
@command{sudo}.

@example
$ sudo /gnu/store/@dots{}-run-container
system container is running as PID 5983
@dots{}
@end example

Background the process with @key{Ctrl-z} followed by @command{bg}.  Note the
process ID in the output; we will need it to connect to the container
later.  You know what? Let's try attaching to the container right now.  We
will use @command{nsenter}, a tool provided by the @code{util-linux}
package:

@example
$ guix shell util-linux
$ sudo nsenter -a -t 5983
root@@container /# pgrep -a postgres
49 /gnu/store/@dots{}-postgresql-14.4/bin/postgres -D /var/lib/postgresql/data --config-file=/gnu/store/@dots{}-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
@end example

The PostgreSQL service is running in the container!


@node Container Networking
@subsection Container Networking
@cindex container networking

What good is a Guix System running a PostgreSQL database service as a
container when we can only talk to it with processes originating in the
container? It would be much better if we could talk to the database over the
network.

The easiest way to do this is to create a pair of connected virtual Ethernet
devices (known as @code{veth}).  We move one of the devices
(@code{ceth-test}) into the @code{net} namespace of the container and leave
the other end (@code{veth-test}) of the connection on the host system.

@example
pid=5983
ns="guix-test"
host="veth-test"
client="ceth-test"

# Attach the new net namespace "guix-test" to the container PID.
sudo ip netns attach $ns $pid

# Create the pair of devices
sudo ip link add $host type veth peer name $client

# Move the client device into the container's net namespace
sudo ip link set $client netns $ns
@end example

Then we configure the host side:

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

@dots{}and then we configure the client side:

@example
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
@end example

At this point the host can reach the container at IP address 10.0.0.2, and
the container can reach the host at IP 10.0.0.1.  This is all we need to
talk to the database server inside the container from the host system on the
outside.

@example
$ psql -h 10.0.0.2 -U test
psql (14.4)
Type "help" for help.

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 row)
@end example

Now that we're done with this little demonstration let's clean up:

@example
sudo kill $pid
sudo ip netns del $ns
sudo ip link del $host
@end example


@c *********************************************************************
@node Pokročilá správa balíkov
@chapter Pokročilá správa balíkov

Guix is a functional package manager that offers many features beyond what
more traditional package managers can do.  To the uninitiated, those
features might not have obvious use cases at first.  The purpose of this
chapter is to demonstrate some advanced package management concepts.

@pxref{Package Management,,, guix, GNU Guix Reference Manual} for a complete
reference.

@menu
* Guix Profiles in Practice::  Strategies for multiple profiles and 
                                 manifests.
@end menu

@node Guix Profiles in Practice
@section Guix Profiles in Practice

Guix provides a very useful feature that may be quite foreign to newcomers:
@emph{profiles}.  They are a way to group package installations together and
all users on the same system are free to use as many profiles as they want.

Whether you're a developer or not, you may find that multiple profiles bring
you great power and flexibility.  While they shift the paradigm somewhat
compared to @emph{traditional package managers}, they are very convenient to
use once you've understood how to set them up.

If you are familiar with Python's @samp{virtualenv}, you can think of a
profile as a kind of universal @samp{virtualenv} that can hold any kind of
software whatsoever, not just Python software.  Furthermore, profiles are
self-sufficient: they capture all the runtime dependencies which guarantees
that all programs within a profile will always work at any point in time.

Multiple profiles have many benefits:

@itemize
@item
Clean semantic separation of the various packages a user needs for different
contexts.

@item
Multiple profiles can be made available into the environment either on login
or within a dedicated shell.

@item
Profiles can be loaded on demand.  For instance, the user can use multiple
shells, each of them running different profiles.

@item
Isolation: Programs from one profile will not use programs from the other,
and the user can even install different versions of the same programs to the
two profiles without conflict.

@item
Deduplication: Profiles share dependencies that happens to be the exact
same.  This makes multiple profiles storage-efficient.

@item
Reproducible: when used with declarative manifests, a profile can be fully
specified by the Guix commit that was active when it was set up.  This means
that the exact same profile can be
@uref{https://guix.gnu.org/blog/2018/multi-dimensional-transactions-and-rollbacks-oh-my/,
set up anywhere and anytime}, with just the commit information.  See the
section on @ref{Reproducible profiles}.

@item
Easier upgrades and maintenance: Multiple profiles make it easy to keep
package listings at hand and make upgrades completely frictionless.
@end itemize

Concretely, here follows some typical profiles:

@itemize
@item
The dependencies of a project you are working on.

@item
Your favourite programming language libraries.

@item
Laptop-specific programs (like @samp{powertop}) that you don't need on a
desktop.

@item
@TeX{}live (this one can be really useful when you need to install just one
package for this one document you've just received over email).

@item
Hry.
@end itemize

Let's dive in the set up!

@node Basic setup with manifests
@subsection Basic setup with manifests

A Guix profile can be set up @i{via} a @dfn{manifest}.  A manifest is a
snippet of Scheme code that specifies the set of packages you want to have
in your profile; it looks like this:

@lisp
(specifications->manifest
  '("package-1"
    ;; Version 1.3 of package-2.
    "package-2@@1.3"
    ;; The "lib" output of package-3.
    "package-3:lib"
    ; ...
    "package-N"))
@end lisp

@xref{Writing Manifests,,, guix, GNU Guix Reference Manual}, for more
information about the syntax.

We can create a manifest specification per profile and install them this
way:

@example
GUIX_EXTRA_PROFILES=$HOME/.guix-extra-profiles
mkdir -p "$GUIX_EXTRA_PROFILES"/my-project # if it does not exist yet
guix package --manifest=/path/to/guix-my-project-manifest.scm --profile="$GUIX_EXTRA_PROFILES"/my-project/my-project
@end example

Here we set an arbitrary variable @samp{GUIX_EXTRA_PROFILES} to point to the
directory where we will store our profiles in the rest of this article.

Placing all your profiles in a single directory, with each profile getting
its own sub-directory, is somewhat cleaner.  This way, each sub-directory
will contain all the symlinks for precisely one profile.  Besides, ``looping
over profiles'' becomes obvious from any programming language (e.g.@: a
shell script) by simply looping over the sub-directories of
@samp{$GUIX_EXTRA_PROFILES}.

Note that it's also possible to loop over the output of

@example
guix package --list-profiles
@end example

although you'll probably have to filter out @file{~/.config/guix/current}.

To enable all profiles on login, add this to your @file{~/.bash_profile} (or
similar):

@example
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
@end example

Note to Guix System users: the above reflects how your default profile
@file{~/.guix-profile} is activated from @file{/etc/profile}, that latter
being loaded by @file{~/.bashrc} by default.

You can obviously choose to only enable a subset of them:

@example
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
@end example

When a profile is off, it's straightforward to enable it for an individual
shell without "polluting" the rest of the user session:

@example
GUIX_PROFILE="path/to/my-project" ; . "$GUIX_PROFILE"/etc/profile
@end example

The key to enabling a profile is to @emph{source} its @samp{etc/profile}
file.  This file contains shell code that exports the right environment
variables necessary to activate the software contained in the profile.  It
is built automatically by Guix and meant to be sourced.  It contains the
same variables you would get if you ran:

@example
guix package --search-paths=prefix --profile=$my_profile"
@end example

Once again, see (@pxref{Invoking guix package,,, guix, GNU Guix Reference
Manual})  for the command line options.

To upgrade a profile, simply install the manifest again:

@example
guix package -m /path/to/guix-my-project-manifest.scm -p "$GUIX_EXTRA_PROFILES"/my-project/my-project
@end example

To upgrade all profiles, it's easy enough to loop over them.  For instance,
assuming your manifest specifications are stored in
@file{~/.guix-manifests/guix-$profile-manifest.scm}, with @samp{$profile}
being the name of the profile (e.g.@: "project1"), you could do the
following in Bourne shell:

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

Each profile has its own generations:

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

You can roll-back to any generation of a given profile:

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

Finally, if you want to switch to a profile without inheriting from the
current environment, you can activate it from an empty shell:

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

@node Požadované balíky
@subsection Požadované balíky

Activating a profile essentially boils down to exporting a bunch of
environmental variables.  This is the role of the @samp{etc/profile} within
the profile.

@emph{Note: Only the environmental variables of the packages that consume them
will be set.}

For instance, @samp{MANPATH} won't be set if there is no consumer
application for man pages within the profile.  So if you need to
transparently access man pages once the profile is loaded, you've got two
options:

@itemize
@item
Either export the variable manually, e.g.
@example
export MANPATH=/path/to/profile$@{MANPATH:+:@}$MANPATH
@end example

@item
Or include @samp{man-db} to the profile manifest.
@end itemize

The same is true for @samp{INFOPATH} (you can install @samp{info-reader}),
@samp{PKG_CONFIG_PATH} (install @samp{pkg-config}), etc.

@node Default profile
@subsection Default profile

What about the default profile that Guix keeps in @file{~/.guix-profile}?

You can assign it the role you want.  Typically you would install the
manifest of the packages you want to use all the time.

Alternatively, you could keep it ``manifest-less'' for throw-away packages
that you would just use for a couple of days.  This way makes it convenient
to run

@example
guix install package-foo
guix upgrade package-bar
@end example

without having to specify the path to a profile.

@node The benefits of manifests
@subsection The benefits of manifests

Manifests are a convenient way to keep your package lists around and, say,
to synchronize them across multiple machines using a version control system.

A common complaint about manifests is that they can be slow to install when
they contain large number of packages.  This is especially cumbersome when
you just want get an upgrade for one package within a big manifest.

This is one more reason to use multiple profiles, which happen to be just
perfect to break down manifests into multiple sets of semantically connected
packages.  Using multiple, small profiles provides more flexibility and
usability.

Manifests come with multiple benefits.  In particular, they ease
maintenance:

@itemize
@item
When a profile is set up from a manifest, the manifest itself is
self-sufficient to keep a ``package listing'' around and reinstall the
profile later or on a different system.  For ad-hoc profiles, we would need
to generate a manifest specification manually and maintain the package
versions for the packages that don't use the default version.

@item
@code{guix package --upgrade} always tries to update the packages that have
propagated inputs, even if there is nothing to do.  Guix manifests remove
this problem.

@item
When partially upgrading a profile, conflicts may arise (due to diverging
dependencies between the updated and the non-updated packages) and they can
be annoying to resolve manually.  Manifests remove this problem altogether
since all packages are always upgraded at once.

@item
As mentioned above, manifests allow for reproducible profiles, while the
imperative @code{guix install}, @code{guix upgrade}, etc. do not, since they
produce different profiles every time even when they hold the same
packages.  See @uref{https://issues.guix.gnu.org/issue/33285, the related
discussion on the matter}.

@item
Manifest specifications are usable by other @samp{guix} commands.  For
example, you can run @code{guix weather -m manifest.scm} to see how many
substitutes are available, which can help you decide whether you want to try
upgrading today or wait a while.  Another example: you can run @code{guix
pack -m manifest.scm} to create a pack containing all the packages in the
manifest (and their transitive references).

@item
Finally, manifests have a Scheme representation, the @samp{<manifest>}
record type.  They can be manipulated in Scheme and passed to the various
Guix @uref{https://en.wikipedia.org/wiki/Api, APIs}.
@end itemize

It's important to understand that while manifests can be used to declare
profiles, they are not strictly equivalent: profiles have the side effect
that they ``pin'' packages in the store, which prevents them from being
garbage-collected (@pxref{Invoking guix gc,,, guix, GNU Guix Reference
Manual})  and ensures that they will still be available at any point in the
future.

Let's take an example:

@enumerate
@item
We have an environment for hacking on a project for which there isn't a Guix
package yet.  We build the environment using a manifest, and then run
@code{guix environment -m manifest.scm}.  So far so good.

@item
Many weeks pass and we have run a couple of @code{guix pull} in the mean
time.  Maybe a dependency from our manifest has been updated; or we may have
run @code{guix gc} and some packages needed by our manifest have been
garbage-collected.

@item
Eventually, we set to work on that project again, so we run @code{guix shell
-m manifest.scm}.  But now we have to wait for Guix to build and install
stuff!
@end enumerate

Ideally, we could spare the rebuild time.  And indeed we can, all we need is
to install the manifest to a profile and use
@code{GUIX_PROFILE=/the/profile; . "$GUIX_PROFILE"/etc/profile} as explained
above: this guarantees that our hacking environment will be available at all
times.

@emph{Security warning:} While keeping old profiles around can be
convenient, keep in mind that outdated packages may not have received the
latest security fixes.

@node Reproducible profiles
@subsection Reproducible profiles

To reproduce a profile bit-for-bit, we need two pieces of information:

@itemize
@item
a manifest,
@item
a Guix channel specification.
@end itemize

Indeed, manifests alone might not be enough: different Guix versions (or
different channels) can produce different outputs for a given manifest.

You can output the Guix channel specification with @samp{guix describe
--format=channels}.  Save this to a file, say @samp{channel-specs.scm}.

On another computer, you can use the channel specification file and the
manifest to reproduce the exact same profile:

@example
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=/path/to/guix-my-project-manifest.scm --profile="$GUIX_EXTRA_PROFILES"/my-project/my-project
@end example

It's safe to delete the Guix channel profile you've just installed with the
channel specification, the project profile does not depend on it.

@c *********************************************************************
@node Správa prostredí
@chapter Správa prostredí

Guix provides multiple tools to manage environment.  This chapter
demonstrate such utilities.

@menu
* Guix environment via direnv::  Setup Guix environment with direnv
@end menu

@node Guix environment via direnv
@section Guix environment via direnv

Guix provides a @samp{direnv} package, which could extend shell after
directory change.  This tool could be used to prepare a pure Guix
environment.

The following example provides a shell function for @file{~/.direnvrc} file,
which could be used from Guix Git repository in @file{~/src/guix/.envrc}
file to setup a build environment similar to described in @pxref{Building from Git,,, guix, GNU Guix Reference Manual}.

Create a @file{~/.direnvrc} with a Bash code:

@example
# Thanks <https://github.com/direnv/direnv/issues/73#issuecomment-152284914>
export_function()
@{
  local name=$1
  local alias_dir=$PWD/.direnv/aliases
  mkdir -p "$alias_dir"
  PATH_add "$alias_dir"
  local target="$alias_dir/$name"
  if declare -f "$name" >/dev/null; then
    echo "#!$SHELL" > "$target"
    declare -f "$name" >> "$target" 2>/dev/null
    # Notice that we add shell variables to the function trigger.
    echo "$name \$*" >> "$target"
    chmod +x "$target"
  fi
@}

use_guix()
@{
    # Set GitHub token.
    export GUIX_GITHUB_TOKEN="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

    # Unset 'GUIX_PACKAGE_PATH'.
    export GUIX_PACKAGE_PATH=""

    # Recreate a garbage collector root.
    gcroots="$HOME/.config/guix/gcroots"
    mkdir -p "$gcroots"
    gcroot="$gcroots/guix"
    if [ -L "$gcroot" ]
    then
        rm -v "$gcroot"
    fi

    # Miscellaneous packages.
    PACKAGES_MAINTENANCE=(
        direnv
        git
        git:send-email
        git-cal
        gnupg
        guile-colorized
        guile-readline
        less
        ncurses
        openssh
        xdot
    )

    # Environment packages.
    PACKAGES=(help2man guile-sqlite3 guile-gcrypt)

    # Thanks <https://lists.gnu.org/archive/html/guix-devel/2016-09/msg00859.html>
    eval "$(guix environment --search-paths --root="$gcroot" --pure guix --ad-hoc $@{PACKAGES[@@]@} $@{PACKAGES_MAINTENANCE[@@]@} "$@@")"

    # Predefine configure flags.
    configure()
    @{
        ./configure --localstatedir=/var --prefix=
    @}
    export_function configure

    # Run make and optionally build something.
    build()
    @{
        make -j 2
        if [ $# -gt 0 ]
        then
            ./pre-inst-env guix build "$@@"
        fi
    @}
    export_function build

    # Predefine push Git command.
    push()
    @{
        git push --set-upstream origin
    @}
    export_function push

    clear                        # Clean up the screen.
    git-cal --author='Your Name' # Show contributions calendar.

    # Show commands help.
    echo "
build          build a package or just a project if no argument provided
configure      run ./configure with predefined parameters
push           push to upstream Git repository
"
@}
@end example

Every project containing @file{.envrc} with a string @code{use guix} will
have predefined environment variables and procedures.

Run @command{direnv allow} to setup the environment for the first time.

@c *********************************************************************
@node Poďakovanie
@chapter Poďakovanie

Guix is based on the @uref{https://nixos.org/nix/, Nix package manager},
which was designed and implemented by Eelco Dolstra, with contributions from
other people (see the @file{nix/AUTHORS} file in Guix.)  Nix pioneered
functional package management, and promoted unprecedented features, such as
transactional package upgrades and rollbacks, per-user profiles, and
referentially transparent build processes.  Without this work, Guix would
not exist.

The Nix-based software distributions, Nixpkgs and NixOS, have also been an
inspiration for Guix.

GNU@tie{}Guix itself is a collective work with contributions from a number
of people.  See the @file{AUTHORS} file in Guix for more information on
these fine people.  The @file{THANKS} file lists people who have helped by
reporting bugs, taking care of the infrastructure, providing artwork and
themes, making suggestions, and more---thank you!

This document includes adapted sections from articles that have previously
been published on the Guix blog at @uref{https://guix.gnu.org/blog}.


@c *********************************************************************
@node Licencia GNU Free Documentation
@appendix Licencia GNU Free Documentation
@cindex license, GNU Free Documentation License
@include fdl-1.3.texi

@c *********************************************************************
@node Zoznam pojmov
@unnumbered Zoznam pojmov
@printindex cp

@bye

@c Local Variables:
@c ispell-local-dictionary: "american";
@c End:
