Le contrat de module

Le SDK définit le contrat qu’un module respecte. Il tient en trois crates : sdk/traits (les types Rust), sdk/proto (les définitions Protobuf) et sdk/grpc-adapter (le pont gRPC).

Le trait Module

Défini dans sdk/traits, c’est le contrat de cycle de vie d’un module :

#[async_trait]
pub trait Module: Send + Sync {
    fn info(&self) -> ModuleInfo;
    async fn on_start(&self) -> Result<(), ModuleError>;
    async fn on_event(&self, event: SfuEvent) -> Result<(), ModuleError>;
    async fn health_check(&self) -> Result<HealthStatus, ModuleError>;
    async fn on_stop(&self) -> Result<(), ModuleError>;
}

info() renvoie un ModuleInfo { name, version, capabilities }.

Les capacités

Un module déclare ce qu’il sait faire avec l’enum Capability :

pub enum Capability {
    Recording,
    Analytics,
    Stun,
    Custom(String),
}

C’est sur cette base que l’orchestrateur décide quels hooks lui relier.

Les événements du SFU

Un module peut s’abonner au flux d’événements du SFU (SfuEvent) :

pub enum SfuEvent {
    RoomCreated { room_id: String },
    RoomDestroyed { room_id: String },
    ParticipantJoined { room_id: String, participant_id: String, display_name: String },
    ParticipantLeft { room_id: String, participant_id: String },
    TrackPublished { room_id: String, participant_id: String, track_info: TrackInfo },
    TrackUnpublished { room_id: String, participant_id: String, track_id: String },
}

Un TrackInfo porte track_id, kind (Audio ou Video), codec et is_screen_share. La santé d’un module s’exprime par HealthStatus (Healthy, Degraded(String), Unhealthy(String)).

Les services gRPC

sdk/proto est la source unique de vérité. Trois services concernent tout module :

service ModuleRegistry {
  rpc Register(RegisterRequest) returns (RegisterResponse);
  rpc Heartbeat(HeartbeatRequest) returns (HeartbeatResponse);
  rpc Deregister(DeregisterRequest) returns (DeregisterResponse);
  rpc LookupModule(LookupModuleRequest) returns (LookupModuleResponse);
}

service EventStream {
  rpc Subscribe(SubscribeRequest) returns (stream SfuEvent);
}

service RoomManagement {
  rpc CreateRoom(...) returns (...);
  rpc EndRoom(...) returns (...);
  rpc IsRoomRunning(...) returns (...);
  rpc GetRoomInfo(...) returns (...);
  rpc ListRooms(...) returns (...);
  rpc SendChatMessage(...) returns (...);
  rpc NotifyWhiteboardActive(...) returns (...);
  rpc GetSessionData(...) returns (...);
}

L’enregistrement déclare l’essentiel :

message RegisterRequest {
  string name = 1;
  string version = 2;
  repeated string capabilities = 3;
  string grpc_addr = 4;
  repeated string depends_on = 5;
}

Un module qui a besoin de ses propres appels distants définit son service dans sdk/proto.

Le pont gRPC

sdk/grpc-adapter fournit les briques d’intégration utilisées par l’orchestrateur : le serveur de registre (ModuleRegistryService, ModuleStore, RegisteredModule), le bus d’événements (EventBus, EventStreamService), et un point de relai média (ForwardHandle).