Discovery

La decouverte (discovery) est le processus automatique par lequel les Participants et endpoints DDS se trouvent mutuellement sur le reseau.

Vue d'ensemble

DDS utilise deux protocoles de decouverte :

Protocole	Fonction	Trafic
SPDP	Trouver les Participants	Multicast
SEDP	Echanger les endpoints	Unicast

+---------------------------------------------------------+
|                   Flux de decouverte                     |
+---------------------------------------------------------+
|                                                          |
|  Participant A                    Participant B           |
|       |                                |                  |
|       | ---- SPDP (multicast) -------> |  Phase 1 :      |
|       | <--- SPDP (multicast) -------- |  Trouver les    |
|       |                                |  Participants   |
|       |                                |                  |
|       | ---- SEDP (unicast) ---------> |  Phase 2 :      |
|       | <--- SEDP (unicast) ---------- |  Echanger les   |
|       |                                |  endpoints      |
|       |                                |                  |
|       | ---- Donnees utilisateur ----->|  Phase 3 :      |
|       |                                |  Les donnees    |
|       |                                |  circulent      |
+---------------------------------------------------------+

SPDP (Simple Participant Discovery Protocol)

SPDP decouvre les autres DomainParticipants dans le meme Domain.

Fonctionnement

1. Chaque Participant envoie des annonces periodiques via multicast
2. Les annonces contiennent le GUID du Participant, les locators, la duree du bail
3. Les Participants maintiennent une liste des Participants decouverts

Messages SPDP

Annonce SPDP :
+----------------------------------------+
| GUID Prefix: [01, 0f, aa, ...]         |
| Vendor ID: HDDS (0x01aa)               |
| Unicast Locator: 192.168.1.100:7411    |
| Multicast Locator: 239.255.0.1:7400    |
| Lease Duration: 30s                    |
| User Data: "app=sensor"                |
+----------------------------------------+

Configuration reseau

Parametres multicast par defaut :

Parametre	Defaut	Domain N
Adresse multicast	239.255.0.1	239.255.0.1
Port Discovery	7400	7400 + N*10
Offset Participant	+0, +1	+0 a +9

// Customize discovery
let config = DomainParticipantConfig::default()
    .discovery_multicast("239.255.0.1:7400")
    .lease_duration(Duration::from_secs(30));

Timing SPDP

Annonces initiales :     Rafale rapide (0.5s, 1s, 2s)
Etat stable :            Toutes les lease_duration/3
Expiration du bail :     Suppression apres lease_duration

SEDP (Simple Endpoint Discovery Protocol)

SEDP echange les informations sur les DataWriters et DataReaders.

Fonctionnement

1. Apres que SPDP a decouvert un Participant, SEDP commence
2. Les Participants echangent les informations d'endpoints via unicast
3. Chaque cote apprend les Writers et Readers distants

Messages SEDP

SEDP Publication (Info Writer) :
+----------------------------------------+
| Endpoint GUID: [01, 0f, aa, ..., c2]   |
| Topic Name: "SensorTopic"              |
| Type Name: "sensors::SensorData"       |
| Reliability: Reliable                  |
| Durability: TransientLocal             |
| Ownership: Shared                      |
| Type Object: (XTypes info)             |
+----------------------------------------+

SEDP Subscription (Info Reader) :
+----------------------------------------+
| Endpoint GUID: [02, 1a, bb, ..., c7]   |
| Topic Name: "SensorTopic"              |
| Type Name: "sensors::SensorData"       |
| Reliability: Reliable                  |
| Durability: Volatile                   |
+----------------------------------------+

Endpoints integres

Chaque Participant possede des endpoints integres pour la decouverte :

Entity ID	Fonction
0x000100c2	SPDP Writer
0x000100c7	SPDP Reader
0x000003c2	Publications Writer
0x000003c7	Publications Reader
0x000004c2	Subscriptions Writer
0x000004c7	Subscriptions Reader

Processus d'appariement

Apres l'echange SEDP, les endpoints sont apparies :

Criteres d'appariement :
1. Meme nom de Topic       (correspondance exacte)
2. Type compatible          (nom de type + XTypes)
3. QoS compatibles          (voir les regles QoS)
4. Meme Domain              (implicite par la decouverte)
5. Chevauchement de Partition (si configure)

Verification de compatibilite QoS

Politique	Exigence
Reliability	Writer >= Reader
Durability	Writer >= Reader
Deadline	Writer <= Reader
Liveliness	Writer kind >= Reader kind
Ownership	Writer = Reader

Evenements de decouverte

Evenements Participant

impl DomainParticipantListener for MyListener {
    fn on_participant_discovered(&mut self, participant: &DomainParticipant, info: DiscoveredParticipantInfo) {
        println!("Found participant: {:?}", info.guid);
        println!("  Vendor: {:?}", info.vendor_id);
        println!("  User data: {:?}", info.user_data);
    }

    fn on_participant_lost(&mut self, participant: &DomainParticipant, guid: GUID) {
        println!("Participant left: {:?}", guid);
    }
}

Evenements Endpoint

impl DataWriterListener for MyListener {
    fn on_publication_matched(&mut self, writer: &DataWriter<T>, status: PublicationMatchedStatus) {
        println!("Writer matched {} readers (total: {})",
            status.current_count_change,
            status.current_count);
    }
}

impl DataReaderListener for MyListener {
    fn on_subscription_matched(&mut self, reader: &DataReader<T>, status: SubscriptionMatchedStatus) {
        println!("Reader matched {} writers (total: {})",
            status.current_count_change,
            status.current_count);
    }
}

Requetes de decouverte

Lister les Participants decouverts

for info in participant.discovered_participants() {
    println!("Participant: {:?}", info.guid);
    println!("  Unicast: {:?}", info.unicast_locators);
}

Lister les Topics decouverts

for info in participant.discovered_topics() {
    println!("Topic: {} (type: {})", info.name, info.type_name);
}

Verifier les endpoints apparies

// Writer side
let matched_readers = writer.matched_subscriptions();
for reader_guid in matched_readers {
    println!("Matched reader: {:?}", reader_guid);
}

// Reader side
let matched_writers = reader.matched_publications();
for writer_guid in matched_writers {
    println!("Matched writer: {:?}", writer_guid);
}

Discovery statique

Pour les reseaux sans multicast :

let config = DomainParticipantConfig::default()
    // Disable multicast discovery
    .enable_multicast_discovery(false)

    // Manually specify peer addresses
    .initial_peers(vec![
        "192.168.1.100:7400".parse()?,
        "192.168.1.101:7400".parse()?,
    ]);

Timing de la decouverte

Temps de decouverte typiques

Scenario	Temps
Meme hote	50-100 ms
Meme LAN	100-500 ms
Cross-subnet (statique)	100-200 ms

Accelerer la decouverte

let config = DomainParticipantConfig::default()
    // Faster initial announcements
    .initial_announcement_period(Duration::from_millis(100))

    // Shorter lease (faster detection of failures)
    .lease_duration(Duration::from_secs(10));

Depannage de la decouverte

Aucun Participant trouve

# Check multicast connectivity
ping -c 3 239.255.0.1

# Verify SPDP traffic
tcpdump -i any -n udp port 7400

# Enable discovery debug
export RUST_LOG=hdds::discovery=debug

Endpoints non apparies

Causes frequentes :

Probleme	Solution
Domain ID different	Utiliser le meme Domain
Nom de Topic different	Verifier l'orthographe, la casse
Nom de type different	Utiliser le meme IDL
QoS incompatibles	Verifier Reliability, Durability
Partition differente	Verifier les chaines de Partition

Configuration du pare-feu

Ports requis :

UDP 7400-7500    (discovery + donnees, par Domain)
UDP 239.255.0.0/16  (multicast, si active)

Interoperabilite entre vendeurs

La decouverte fonctionne entre les vendeurs DDS :

Vendeur	SPDP	SEDP	Notes
FastDDS	Oui	Oui	Les parametres par defaut fonctionnent
RTI Connext	Oui	Oui	Peut necessiter le mode interop
CycloneDDS	Oui	Oui	Excellente conformite
OpenDDS	Oui	Oui	Fonctionne avec RTPS

Detection du vendeur

for info in participant.discovered_participants() {
    match info.vendor_id {
        VendorId::HDDS => println!("HDDS participant"),
        VendorId::RTI => println!("RTI Connext participant"),
        VendorId::EPROSIMA => println!("FastDDS participant"),
        VendorId::CYCLONE => println!("CycloneDDS participant"),
        _ => println!("Unknown vendor: {:?}", info.vendor_id),
    }
}

Architecture de la decouverte

+---------------------------------------------------------+
|               Sous-systeme de decouverte                 |
+---------------------------------------------------------+
|                                                          |
|  +-------------+    +-------------+    +-------------+   |
|  | SPDP Writer |    | SEDP Pubs   |    | SEDP Subs   |   |
|  |  (builtin)  |    |   Writer    |    |   Writer    |   |
|  +-------------+    +-------------+    +-------------+   |
|        |                  |                  |            |
|        v                  v                  v            |
|  +------------------------------------------------------+|
|  |             Base de donnees de decouverte             ||
|  |  - Participants decouverts                           ||
|  |  - Endpoints decouverts                              ||
|  |  - Etat d'appariement                               ||
|  +------------------------------------------------------+|
|        ^                  ^                  ^            |
|  +-------------+    +-------------+    +-------------+   |
|  | SPDP Reader |    | SEDP Pubs   |    | SEDP Subs   |   |
|  |  (builtin)  |    |   Reader    |    |   Reader    |   |
|  +-------------+    +-------------+    +-------------+   |
|                                                          |
+---------------------------------------------------------+

Prochaines etapes

• Architecture - Vue d'ensemble du systeme
• Exemple cross-vendor - Demo d'interoperabilite
• Compatibilite filaire - Details du protocole