Installer HDDS sur Windows

Ce guide couvre l'installation de HDDS depuis les sources sur Windows 10 et Windows 11.

Prérequis

Windows 10 1903+ ou Windows 11
Rust 1.75+ : rustup.rs
Git

Vous avez deux options pour la toolchain Rust :

Option A : Cible MSVC (recommandée pour le développement GUI/C++)

Nécessite Visual Studio 2019+ avec la charge de travail C++.

# Install Rust via winget
winget install Rustlang.Rust.MSVC

# Or via rustup
Invoke-WebRequest -Uri https://win.rustup.rs -OutFile rustup-init.exe
.\rustup-init.exe

# Verify Rust version
rustc --version  # Should be 1.75.0 or higher

Option B : Cible GNU (pas de Visual Studio requis)

Idéal pour les environnements headless/CI, les builds via SSH, ou quand Visual Studio n'est pas disponible (ex. éditions Windows LTSC).

# Install Rust via rustup
Invoke-WebRequest -Uri https://win.rustup.rs -OutFile rustup-init.exe
.\rustup-init.exe

# Switch to GNU target
rustup default stable-x86_64-pc-windows-gnu

# Install mingw-w64 (provides the GNU linker)
# Download from https://github.com/niXman/mingw-builds-binaries/releases
# Extract to C:\mingw64 and add to PATH:
$env:PATH += ";C:\mingw64\bin"

# Verify
rustc --version
gcc --version

Cible GNU pour SSH/CI

La cible GNU fonctionne directement dans les sessions SSH où l'environnement MSVC vcvarsall.bat n'est pas chargé. C'est le choix préféré pour les builds automatisés et les pipelines CI sous Windows.

Cloner et compiler

# Clone the repository
git clone https://git.hdds.io/hdds/hdds.git
cd hdds

# Build in release mode
cargo build --release

# Run tests to verify
cargo test

Utiliser HDDS dans votre projet

Ajoutez HDDS comme dépendance locale dans le Cargo.toml de votre projet :

[dependencies]
hdds = { path = "C:/path/to/hdds/crates/hdds" }

Avec des features optionnelles :

[dependencies]
hdds = { path = "C:/path/to/hdds/crates/hdds", features = ["xtypes", "security"] }

Features disponibles

Feature	Description
`xtypes`	Système de types XTypes (par défaut)
`security`	Support DDS Security 1.1
`tcp-tls`	Chiffrement TLS pour le transport TCP
`cloud-discovery`	Discovery AWS/Azure/Consul
`k8s`	Discovery Kubernetes
`rpc`	DDS-RPC Request/Reply
`telemetry`	Collecte de métriques

Générateur de code (hddsgen)

# Clone hdds_gen
git clone https://git.hdds.io/hdds/hdds_gen.git
cd hdds_gen

# Build
cargo build --release

# Add to PATH (optional)
$env:PATH += ";$(Get-Location)\target\release"

# Verify
.\target\release\hddsgen.exe --version

Démarrage rapide avec hddsgen

Générez un projet pub/sub complet depuis un fichier IDL :

# Generate a Rust project with publisher/subscriber examples
hddsgen gen rust --input my_types.idl --output C:\my_dds_project `
    --example --build-system cargo

cd C:\my_dds_project

# Build
cargo build

# Run publisher in one terminal
cargo run --bin publisher

# Run subscriber in another terminal
cargo run --bin subscriber

Séparateurs de chemins dans le Cargo.toml généré

Si HDDS est référencé comme dépendance locale, assurez-vous que le Cargo.toml généré utilise des barres obliques (C:/path/to/hdds) plutôt que des anti-barres. Cargo sous Windows accepte les barres obliques et elles évitent les problèmes d'échappement.

Développement C/C++

Visual Studio

Après avoir compilé HDDS :

# Build the C bindings
cd C:\path\to\hdds
cargo build --release -p hdds-c

# The library will be at target\release\hdds.dll

Configurez les propriétés du projet :

Répertoires d'inclusion :

C:\path\to\hdds\sdk\c\include

Répertoires de bibliothèques :

C:\path\to\hdds\target\release

Entrées de l'éditeur de liens :

hdds.dll.lib

CMake

# Point to your HDDS build
set(HDDS_ROOT "C:/path/to/hdds")

add_executable(myapp main.cpp)
target_include_directories(myapp PRIVATE ${HDDS_ROOT}/sdk/c/include)
target_link_directories(myapp PRIVATE ${HDDS_ROOT}/target/release)
target_link_libraries(myapp PRIVATE hdds)

Configuration :

cmake -B build
cmake --build build --config Release

Vérifier l'installation

# Run tests
cargo test -p hdds --lib

# Build and check hddsctl
cargo build --release -p hddsctl
.\target\release\hddsctl.exe --help

Configuration du pare-feu Windows

DDS utilise le multicast UDP. Configurez le pare-feu Windows :

Via PowerShell (Administrateur)

# Allow HDDS through firewall
New-NetFirewallRule -DisplayName "HDDS DDS" `
    -Direction Inbound `
    -Protocol UDP `
    -LocalPort 7400-7500 `
    -Action Allow

# Or for your specific application
New-NetFirewallRule -DisplayName "My DDS App" `
    -Program "C:\path\to\your\app.exe" `
    -Action Allow

Via l'interface graphique

Ouvrez Sécurité Windows -> Pare-feu et protection du réseau
Cliquez sur Autoriser une application à travers le pare-feu
Cliquez sur Modifier les paramètres -> Autoriser une autre application
Ajoutez votre application ou autorisez les ports 7400-7500 UDP

Configuration du multicast

Windows supporte le multicast par défaut sur la plupart des réseaux. Vérification :

# Check route table
route print | findstr 239

# If multicast isn't working, try:
route add 239.255.0.0 mask 255.255.0.0 192.168.1.1

VPN et adaptateurs virtuels

Les VPN et adaptateurs réseau virtuels (VMware, VirtualBox, Docker) peuvent interférer avec le multicast. Essayez de les désactiver pour les tests.

Transport Shared Memory (Windows)

HDDS supporte le transport zero-copy en mémoire partagée (SHM) sur Windows via CreateFileMappingW/MapViewOfFile pour les segments mémoire et WaitOnAddress/WakeByAddressAll pour la synchronisation (Windows 8+).

SHM est automatiquement utilisé quand deux Participants sont sur le même hôte. Aucune configuration requise.

use hdds::{Participant, TransportMode};
use hdds::transport::shm::ShmPolicy;

let participant = Participant::builder("my_app")
    .with_transport(TransportMode::UdpMulticast)
    .shm_policy(ShmPolicy::Prefer)  // default: use SHM when available
    .build()?;

Nettoyage des segments SHM

Sous Windows, les segments de mémoire partagée sont automatiquement nettoyés par l'OS quand tous les processus qui les ont mappés se terminent. Contrairement à Linux (/dev/shm), il n'y a pas de fichiers persistants à gérer.

Considérations WSL2

WSL2 s'exécute dans un réseau virtuel séparé. Le multicast UDP entre WSL2 et l'hôte Windows ne fonctionne pas directement. Pour le développement DDS sous Windows, préférez les builds Windows natifs à WSL2.

Si vous devez utiliser WSL2, configurez networkingMode=mirrored dans .wslconfig (Windows 11 22H2+) pour des interfaces réseau partagées.

Lecteurs réseau/partages (VirtualBox, SMB)

Quand vous compilez HDDS depuis un partage réseau ou un dossier partagé VirtualBox (ex. X:\), le répertoire cible Cargo se résout en chemin UNC (\\VBoxSvr\share\...) que l'éditeur de liens GNU ne peut pas gérer. Forcez le répertoire cible vers un chemin local :

# Set a local target directory
$env:CARGO_TARGET_DIR = "C:\hdds-target"

# Now build normally from the shared folder
cd X:\hdds
cargo build --release

Chemins UNC

Cela n'est nécessaire que lorsque le code source est sur un partage réseau. Les chemins locaux (ex. C:\hdds) fonctionnent sans solution de contournement.

Dépannage

Erreur "DLL not found"

# Add HDDS to PATH
$env:PATH += ";C:\Program Files\HDDS\bin"

# Or copy DLLs to application directory
copy "C:\Program Files\HDDS\bin\hdds.dll" .\

"Access Denied" sur les ports

Exécutez en tant qu'Administrateur ou utilisez des ports supérieurs à 1024.

Multicast ne fonctionne pas

# Check if multicast is enabled on your adapter
Get-NetAdapter | Get-NetIPInterface | Select-Object InterfaceAlias, InterfaceMetric

# Disable firewall temporarily for testing
Set-NetFirewallProfile -Profile Domain,Public,Private -Enabled False

"dlltool.exe not found" (cible GNU)

La cible GNU nécessite mingw-w64. Installez-le et ajoutez-le au PATH :

# Verify mingw is in PATH
gcc --version

# If not found, add it:
$env:PATH += ";C:\mingw64\bin"

Erreurs de l'éditeur de liens Visual Studio

Assurez-vous que l'architecture de votre projet correspond à la cible de compilation Rust :

Projet x64 -> compilez avec cargo build --release (par défaut sur Windows 64 bits)
Projet x86 -> compilez avec cargo build --release --target i686-pc-windows-msvc

La bibliothèque d'importation (hdds.dll.lib) et la DLL sont toutes deux dans target/release/.

Prochaines étapes

Compilation depuis les sources - Compilez HDDS vous-même
Hello World Rust - Votre première application HDDS

Prérequis​

Option A : Cible MSVC (recommandée pour le développement GUI/C++)​

Option B : Cible GNU (pas de Visual Studio requis)​

Cloner et compiler​

Utiliser HDDS dans votre projet​

Features disponibles​

Générateur de code (hddsgen)​

Démarrage rapide avec hddsgen​

Développement C/C++​

Visual Studio​

CMake​

Vérifier l'installation​

Configuration du pare-feu Windows​

Via PowerShell (Administrateur)​

Via l'interface graphique​

Configuration du multicast​

Transport Shared Memory (Windows)​

Considérations WSL2​

Lecteurs réseau/partages (VirtualBox, SMB)​

Dépannage​

Erreur "DLL not found"​

"Access Denied" sur les ports​

Multicast ne fonctionne pas​

"dlltool.exe not found" (cible GNU)​

Erreurs de l'éditeur de liens Visual Studio​

Prochaines étapes​