Guide d'utilisation - HardlinkAnalyzer

Installation

Prérequis

.NET 10.0 SDK ou superieur
Acces en lecture/ecriture aux repertoires a analyser
Les repertoires doivent etre sur le meme systeme de fichiers pour les hard links

Compilation

                        # Cloner le projet
git clone https://github.com/votre-repo/HardlinkAnalyzer.git
cd HardlinkAnalyzer

# Compiler en mode Release
dotnet build -c Release

# Ou executer directement
dotnet run -- [commande] [arguments]
                    

Publication

                        # Publier un executable autonome pour Linux
dotnet publish -c Release -r linux-x64 --self-contained

# Publier pour Windows
dotnet publish -c Release -r win-x64 --self-contained

# Publier pour macOS
dotnet publish -c Release -r osx-x64 --self-contained
                    

Workflow complet

Voici le workflow typique pour utiliser HardlinkAnalyzer :

Etape 1 : Analyser les repertoires

                        # Analyse standard
dotnet run -- analyze "/chemin/vers/A" "/chemin/vers/B"

# Ou analyse optimisee pour gros fichiers
dotnet run -- analyze-fast "/chemin/vers/A" "/chemin/vers/B"
                    

Cette commande genere un fichier hardlink_fix_plan.txt contenant les operations a effectuer.

Etape 2 : Verifier le plan

Examinez le fichier genere pour valider les operations :

                        # Afficher le plan
cat hardlink_fix_plan.txt

# Format de chaque ligne :
# [chemin_source] [chemin_destination]
                    

Etape 3 : Appliquer les corrections

                        # Appliquer le plan de hard links
dotnet run -- apply
                    

Etape 4 : Verifier les resultats

                        # Verifier qu'un hard link a ete cree
dotnet run -- verify "/chemin/vers/A/fichier.txt" "/chemin/vers/B/fichier.txt"
                    

Analyse de repertoires

Analyse standard

L'analyse standard parcourt tous les fichiers et calcule leur hash SHA256 complet :

dotnet run -- analyze "/data/original" "/data/backup"

Analyse optimisee (fast)

Pour les gros fichiers (>100 MB), le mode rapide effectue d'abord un hash partiel :

dotnet run -- analyze-fast "/data/original" "/data/backup"

Avantages du mode fast :

Hash partiel (debut + milieu + fin) pour pre-filtrage
Hash complet uniquement si le hash partiel correspond
Cache persistant des hashes calcules
Progression detaillee en temps reel

Fichiers generes

hardlink_fix_plan.txt - Plan des hard links a creer
.hardlink_cache.json - Cache des hashes (mode fast)

Fichiers uniques Nouveau

Detection des fichiers uniques

Identifiez les fichiers presents uniquement dans A ou B :

                        # Generer un rapport des fichiers uniques
dotnet run -- unique "/data/A" "/data/B"

# Resultat dans unique_files_report.txt
                    

Creation de hard links pour fichiers uniques

Creez des hard links des fichiers uniques de A vers B :

                        # 1. Simulation (recommandee en premier)
dotnet run -- copy-unique "/data/A" "/data/B" --dry-run

# 2. Execution avec confirmation
dotnet run -- copy-unique "/data/A" "/data/B"

# 3. Execution automatique (sans confirmation)
dotnet run -- copy-unique "/data/A" "/data/B" --yes
                    

Conservation de l'arborescence

La commande preserve la structure des dossiers :

                        # Structure source
A/
  +-- sous-dossier/
  |   +-- fichier_unique.txt
  +-- autre/
      +-- document.pdf

# Apres copy-unique, dans B :
B/
  +-- sous-dossier/
  |   +-- fichier_unique.txt  (hard link vers A)
  +-- autre/
      +-- document.pdf        (hard link vers A)
                    

Optimisation des performances

Cache des hashes

Le cache persistant evite de recalculer les hashes :

                        # Afficher les statistiques du cache
dotnet run -- cache-stats

# Nettoyer le cache
dotnet run -- clean
                    

Parallelisme intelligent

L'application ajuste automatiquement le parallelisme :

Petits fichiers : Traitement parallele sur tous les coeurs
Gros fichiers : Traitement sequentiel pour eviter la saturation I/O

Recommandations

Utilisez analyze-fast pour les repertoires avec de gros fichiers
Le cache est invalide automatiquement si un fichier est modifie
Nettoyez le cache periodiquement pour les analyses ponctuelles

Filtrage de fichiers

Exclusions predefinies

Certaines extensions et dossiers sont exclus par défaut :

Dossiers de developpement

.git, node_modules, .vs
bin, obj, __pycache__

Fichiers media (optionnel)

.mp4, .mkv, .avi
.mp3, .flac, .wav

Filtrage personnalise

                        # Exclure des extensions specifiques
dotnet run -- analyze "/A" "/B" --exclude ".log,.tmp,.bak"

# Exclure les fichiers media
dotnet run -- analyze "/A" "/B" --exclude-media
                    

Verification des hard links

Verifier deux fichiers

                        dotnet run -- verify "/chemin/fichier1.txt" "/chemin/fichier2.txt"

# Sortie possible :
# Les fichiers sont lies par hard link (meme inode: 12345678)
# ou
# Les fichiers ne sont PAS lies par hard link
                    

Fonctionnement

La verification compare les inodes des fichiers :

Linux/Unix : Utilise l'appel systeme stat()
Windows : Utilise les APIs Windows pour obtenir l'identifiant de fichier