Crate rvoip_dialog_core

Expand description

§RVOIP Dialog-Core

RFC 3261 SIP Dialog Management Layer for RVOIP.

This crate implements the SIP dialog layer as defined in RFC 3261, providing clean separation between session coordination (handled by session-core) and SIP protocol operations. It manages dialog state, handles in-dialog requests, and coordinates with transaction-core for reliable SIP message delivery.

§Architecture Position

session-core (Session Coordination)
     ↓
dialog-core (SIP Protocol)  ← THIS CRATE
     ↓  
transaction-core (Reliability)
     ↓
sip-transport (Network)

§What This Crate Does

Dialog State Management: Tracks dialog lifecycle (Initial → Early → Confirmed → Terminated)
CSeq Management: Handles sequence number generation and validation
Route Set Management: Maintains dialog route sets from Record-Route headers
In-Dialog Requests: Creates properly formatted requests within established dialogs
Recovery Handling: Manages dialog recovery from network failures
Session Integration: Coordinates with session-core for high-level call management

§Quick Start - Server

use rvoip_dialog_core::api::{DialogServer, DialogApi};
use rvoip_transaction_core::{TransactionManager};
use rvoip_transaction_core::transport::{TransportManager, TransportManagerConfig};
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Set up transport layer
    let config = TransportManagerConfig {
        enable_udp: true,
        bind_addresses: vec!["0.0.0.0:5060".parse()?],
        ..Default::default()
    };
     
    let (transport, transport_rx) = TransportManager::new(config).await?;
    let (transaction_manager, global_rx) = TransactionManager::with_transport_manager(
        transport, transport_rx, Some(100)
    ).await?;
     
    // Create server using recommended global events pattern
    let server_config = rvoip_dialog_core::api::config::ServerConfig::default();
    let server = DialogServer::with_global_events(
        Arc::new(transaction_manager),
        global_rx,
        server_config
    ).await?;
     
    // Set up session coordination (connects to session-core)
    let (session_tx, _session_rx) = tokio::sync::mpsc::channel(100);
    server.set_session_coordinator(session_tx).await?;
     
    // Start processing
    server.start().await?;
     
    Ok(())
}

§Quick Start - Client

use rvoip_dialog_core::api::{DialogClient, DialogApi};
use rvoip_transaction_core::{TransactionManager};
use rvoip_transaction_core::transport::{TransportManager, TransportManagerConfig};
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Set up transport and transaction layers
    let config = TransportManagerConfig::default();
    let (transport, transport_rx) = TransportManager::new(config).await?;
    let (transaction_manager, global_rx) = TransactionManager::with_transport_manager(
        transport, transport_rx, Some(100)
    ).await?;
     
    // Create client using recommended global events pattern
    let client_config = rvoip_dialog_core::api::config::ClientConfig::default();
    let client = DialogClient::with_global_events(
        Arc::new(transaction_manager),
        global_rx,
        client_config
    ).await?;
     
    // Start the client
    client.start().await?;
     
    // Create an outgoing dialog and make a call
    let local_uri = "sip:alice@example.com";
    let remote_uri = "sip:bob@example.com";
    let dialog = client.create_dialog(local_uri, remote_uri).await?;
    let dialog_id = dialog.id().clone();
     
    // Send in-dialog requests using Phase 3 one-liner functions
    let _info_tx = client.send_info(&dialog_id, "Application data".to_string()).await?;
    let _bye_tx = client.send_bye(&dialog_id).await?;
     
    Ok(())
}

§Key Features

Phase 3 Integration: Uses transaction-core helper functions for simplified SIP operations
Global Events Pattern: Recommended architecture for event-driven operation
RFC 3261 Compliance: Full compliance with SIP dialog specifications
Recovery Support: Built-in dialog recovery from network failures
Clean API: High-level DialogClient and DialogServer for easy integration

Re-exports§

pub use manager::DialogManager;
pub use manager::UnifiedDialogManager;
pub use dialog::DialogId;
pub use dialog::Dialog;
pub use dialog::DialogState;
pub use errors::DialogError;
pub use errors::DialogResult;
pub use events::SessionCoordinationEvent;
pub use events::DialogEvent;
pub use config::DialogManagerConfig;
pub use config::ClientBehavior;
pub use config::ServerBehavior;
pub use config::HybridBehavior;
pub use api::DialogClient;
pub use api::DialogServer;
pub use api::UnifiedDialogApi;
pub use api::config::ClientConfig;
pub use api::config::ServerConfig;
pub use api::ApiResult;
pub use api::ApiError;
pub use api::DialogStats;

Modules§

api: Dialog-Core API Module
config: Configuration module for dialog-core
dialog: Core dialog types and functionality
errors: Error types for dialog-core
events: Event types for dialog-core
manager: Dialog Manager Module
protocol: SIP Protocol Handlers
recovery: Dialog recovery and failure handling
routing: Request and response routing
sdp: SDP negotiation and media tracking

Structs§

Request: A SIP request message
Response: A SIP response message
TransactionKey: Uniquely identifies a SIP transaction.
Uri: SIP URI components as defined in RFC 3261

Enums§

Method: SIP request methods as defined in RFC 3261 and extensions
StatusCode: SIP status codes as defined in RFC 3261 and extensions

Crate rvoip_dialog_coreCopy item path