Nixos

Aggiornamento delle branch

1. Fetching all branches git fetch --all Ora il tuo PC "sa" che ci sono aggiornamenti, ma non ha ancora cambiato i tuoi file.
2. Aggiorna la branch che ti serve:

git checkout nome-branch
git pull

NOTE: è meglio non aggiornarle tutte tramite uno script, per sicurezza

Eliminizzione di una branch/controlo branch remote

1. controllare se il remoto (github) ha aggiunto/rimosso branch: git fetch --prune
2. ora la branch è eliminata dalla lista, ma non da locale, quindi eliminarla:

# Move to another branch if needed
git checkout main
git branch -d deadbranch

Developing main->host:

La procedura passo-passo

1. Scarica le novità da GitHub (senza applicarle ancora): Questo aggiorna la tua conoscenza di come è fatto main ora.

git fetch origin

2. Assicurati di essere sul branch dell'host:

git checkout host/lenovo

3. Unisci il main dentro il tuo host: Qui usiamo l'opzione --no-commit per fermarci un attimo prima di salvare, così possiamo controllare il famoso flake.lock.

git merge --no-commit --no-ff origin/main

(Nota: usiamo origin/main perché abbiamo fatto fetch. Se avevi fatto git pull origin main su un altro branch locale, puoi usare git merge main).

🛑 IL PASSAGGIO CRUCIALE: Salva il tuo Lockfile 🛑

A questo punto Git cercherà di fondere i file. I file .nix verranno aggiornati (BENE). Il flake.lock potrebbe essere cancellato (se su main non c'è) o sovrascritto. Devi dire a Git: "Ignora quello che dice Main sul lockfile, tieni quello che avevo io qui sul Lenovo". Esegui questo comando:

git checkout HEAD flake.lock

(Se il file risultava cancellato o modificato dal merge, questo comando lo ripristina esattamente com'era prima di iniziare il merge).

4. Concludi l'aggiornamento: Ora che il lockfile è al sicuro, salva il tutto.

git commit -m "Merge aggiornamenti da main (mantenuto lockfile locale)"

5. Applica le modifiche al sistema: Ora hai il codice nuovo ma i pacchetti vecchi (stabili). Ricostruisci il sistema.

sudo nixos-rebuild switch --flake .

6. Invia il risultato su GitHub: Aggiorna il branch del tuo host online.

git push

Riassunto veloce per il futuro

Ogni volta che vuoi portare novità dal main al tuo computer:

git fetch origin
git checkout host/tuo-host
git merge --no-commit origin/main
(git rm flake.lock ?????)
git checkout HEAD flake.lock  # <--- Salva la vita
git commit -m "Update from main"
sudo nixos-rebuild switch --flake .

Developing host->main:

La Tecnica del "Merge Selettivo" (senza lockfile) Mettiamo che tu abbia aggiunto un modulo e testato tutto su host/lenovo. Ora vuoi portare quel modulo su main ma vuoi che il flake.lock di main rimanga quello vecchio.

Esegui questa sequenza di comandi:

1. Spostati su Main:

git checkout main

2. Avvia il merge ma FERMATI prima di confermare: L'opzione --no-commit dice a Git: "Prepara tutti i file del merge, ma non creare ancora il commit finale, lasciami controllare".

git merge --no-commit --no-ff host/lenovo

3. Rimuovi il flake.lock dalla lista dei file da salvare: Dato che host/lenovo ha il file e main no, Git avrà messo il flake.lock nell'area di staging come "new file". Dobbiamo dirgli di lasciar perdere. Esegui questo comando:

git reset HEAD flake.lock

(Questo dice a Git: "Togli il flake.lock dall'area di staging, non voglio aggiungerlo al commit"). 5. (se necessario) Cancella il file fisico (Opzionale ma consigliato): Ora il file è sparito dal commit, ma fisicamente te lo ritroverai nella cartella (come file "untracked"). Se vuoi lasciare main pulito senza quel file:

rm flake.lock

4. Concludi il commit: Ora puoi salvare.

git commit -m "Merge modulo da lenovo (escluso lockfile)"

5. Invia su GitHub:

git push origin main

For developer

• Activate git in configuration.nix
• Create a ssh key with: sudo ssh-keygen -t ed25519 -C "nixos-root-config" -f /root/.ssh/id_nixos_github
• Configura the ssh for Root: sudo nvim /root/.ssh/config with:

Host github.com
IdentityFile /root/.ssh/id_nixos_github
User git

• Add permission: sudo chmod 600 /root/.ssh/config sudo chmod 600 /root/.ssh/id_nixos_github
• Add the key to github deploy:
  1. Take the key: sudo cat /root/.ssh/id_nixos_github.pub

2. Go on Github -> create the repository (if necessary) or go to the repository wanted -> Settings -> Deploy Key -> Add DeployKey (Allow write acces)
   • Then do as usual, but with sudo always before git

Installazione su nuovo host

1. Preparazione dell'ambiente (nella Live ISO)

Avvia il nuovo computer con la chiavetta di NixOS. Nel terminale:

1. Formatta e monta i dischi: (Fallo come fai di solito, montando tutto in /mnt).
2. Clona la tua repo: Dato che devi clonare in /mnt/etc/nixos (o dove preferisci), assicurati di avere git:

nix-shell -p git

# Clona la tua repo dentro la directory di installazione
git clone https://github.com/tuo-user/tua-repo /mnt/etc/nixos

2. Creazione della nuova cartella host

Sì, la struttura corretta è creare una nuova cartella per il nuovo host. Mettiamo che il nuovo PC si chiami asus-laptop.

1. Crea la cartella:

mkdir -p /mnt/etc/nixos/hosts/asus-laptop

2. Genera l'Hardware Config: NixOS ha un comando per analizzare l'hardware attuale e generare il file giusto. Esegui:

nixos-generate-config --root /mnt --dir /mnt/etc/nixos/hosts/asus-laptop

Ora dentro hosts/asus-laptop avrai hardware-configuration.nix e un configuration.nix generico. 3. Sistema il configuration.nix del nuovo host: Il configuration.nix generato automaticamente è troppo vuoto. Ti conviene copiare quello del tuo vecchio PC (adattandolo) oppure crearne uno minimale che importa i tuoi moduli comuni. Esempio di file /mnt/etc/nixos/hosts/asus-laptop/configuration.nix:

{ pkgs, ... }:
{
  imports = [
    ./hardware-configuration.nix  # Importa l'hardware generato
    ../../modules/common.nix      # (Se hai un file comune per tutti i pc)
  ];

  networking.hostName = "asus-laptop"; # <--- IMPORTANTE: Il nome nuovo

  # Assicurati di cambiare questo se il PC è nuovo!
  system.stateVersion = "24.05"; 
}

3. Modifica del flake.nix

Ora devi dire al Flake che esiste questo nuovo computer. Modifica /mnt/etc/nixos/flake.nix (puoi usare nano o vim dalla live):

{
  # ... inputs ...

  outputs = { self, nixpkgs, ... }@inputs: {
    nixosConfigurations = {
      
      # Il tuo vecchio PC
      lenovo-100-15ibd = nixpkgs.lib.nixosSystem {
         # ... config vecchia ...
      };

      # AGGIUNGI IL NUOVO PC QUI
      asus-laptop = nixpkgs.lib.nixosSystem {
        system = "x86_64-linux";
        specialArgs = { inherit inputs; };
        modules = [
          ./hosts/asus-laptop/configuration.nix
          
          # Se usi Home Manager, aggiungi qui il blocco come nell'altro pc
          # cambiando solo l'utente o il file importato se necessario
        ];
      };

    };
  };
}

4. Installazione (Il momento della verità)

Ora che i file sono al posto giusto, lanci l'installazione specificando il nome del flake che hai appena creato.

# Entra nella cartella
cd /mnt/etc/nixos

# Lancia l'installazione
# Nota: Dato che manca flake.lock, Nix lo creerà ora scaricando tutto.
nixos-install --flake .#asus-laptop

Se tutto va a buon fine, ti chiederà la password di root e poi potrai riavviare.

5. Post-Installazione: Creare la Branch (Fondamentale)

Una volta riavviato ed entrato nel nuovo sistema asus-laptop:

1. Apri il terminale nella cartella della configurazione (/etc/nixos o ~/dotfiles a seconda di dove la tieni).
2. Noterai che c'è un file flake.lock nuovo di zecca (creato durante l'installazione) e il flake.nix modificato.
3. Crea la branch per questo PC:

git checkout -b host/asus-laptop

4. Salva tutto:

git add .
git commit -m "Initial install asus-laptop"
git push -u origin host/asus-laptop

Riassunto procedura

1. Clona main (senza lockfile).
2. Genera hardware-configuration.nix nella nuova cartella.
3. Aggiungi la voce in flake.nix.
4. nixos-install --flake .#nuovo-nome.
5. Al riavvio: crea branch host/nuovo-nome, committa il nuovo lockfile e pusha.

In questo modo hai due PC indipendenti, che condividono il codice dal branch main, ma ognuno ha la sua "storia" di aggiornamenti e il suo lockfile.