ovsdb-client

A Rust implementation of the OVSDB protocol client based on RFC7047.

Overview

This crate provides a client implementation for the Open vSwitch Database Management Protocol (OVSDB), allowing Rust applications to:

• Connect to OVSDB servers over TCP or Unix sockets
• Query database schemas
• Monitor tables for changes in real-time
• Execute transactions against OVSDB databases

Features

• Multiple Transport Options: Connect via TCP or Unix socket
• Schema Handling: Retrieve and parse database schemas
• Monitoring: Subscribe to changes in database tables
• JSON-RPC: Built on top of jsonrpsee for reliable RPC communication
• Async API: Fully async API designed for use with Tokio

Quick Start

use ovsdb_client::{
    rpc::{self, RpcClient},
    schema::{MonitorRequest, UpdateNotification},
};
use std::collections::HashMap;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Connect to an OVSDB server on localhost
    let client = rpc::connect_tcp("127.0.0.1:6641").await?;

    // List available databases
    let databases = client.list_databases().await?;
    println!("Available databases: {:?}", databases);

    // Get schema for a specific database
    let schema = client.get_schema("OVN_Northbound").await?;

    // Set up monitoring for a table
    let mut requests = HashMap::new();
    requests.insert(
        "NB_Global".to_owned(),
        MonitorRequest {
            columns: Some(vec!["name".to_owned(), "nb_cfg".to_owned()]),
            ..Default::default()
        },
    );

    // Start monitoring and get initial state
    let initial = client.monitor("OVN_Northbound", None, requests).await?;
    println!("Initial state: {:?}", initial);

    // Subscribe to updates
    let mut stream = client.subscribe_to_method("update").await?;
    while let Some(update) = stream.next().await {
        match update {
            Ok(update) => println!("Received update: {:?}", update),
            Err(e) => eprintln!("Error: {:?}", e),
        }
    }

    Ok(())
}

API Overview

Connections

// Connect via TCP
let client = rpc::connect_tcp("127.0.0.1:6641").await?;

// Connect via Unix socket
let client = rpc::connect_unix("/var/run/openvswitch/db.sock").await?;

Basic Operations

// List databases
let databases = client.list_databases().await?;

// Get schema
let schema = client.get_schema("OVN_Northbound").await?;

Monitoring

// Create monitor request
let mut requests = HashMap::new();
requests.insert(
    "Table_Name".to_owned(),
    MonitorRequest {
        columns: Some(vec!["column1".to_owned(), "column2".to_owned()]),
        ..Default::default()
    },
);

// Start monitoring
let initial_state = client.monitor("Database_Name", None, requests).await?;

// Subscribe to updates
let mut stream = client.subscribe_to_method("update").await?;
while let Some(update) = stream.next().await {
    // Process updates
}

Development Setup

To develop or test with this crate, you'll need an OVSDB server. You can use Docker to run one:

docker run -it --rm -p 6641:6641 registry.atmosphere.dev/library/ovn-central:main /bin/bash -c "mkdir /etc/ovn; /root/ovnkube.sh nb-ovsdb"

This starts an OVN Northbound OVSDB server that listens on port 6641.

OVSDB Protocol Support

This implementation supports the following OVSDB operations as defined in RFC7047:

• List Databases (Section 4.1.1)
• Get Schema (Section 4.1.2)
• Monitor (Section 4.1.5)
• Update Notifications (Section 4.1.6)

Future versions will add support for additional operations such as Transact (Section 4.1.3) and Monitor Cancellation (Section 4.1.7).

Related Crates

• ovsdb-schema: Core OVSDB data types and serialization
• ovsdb-derive: Derive macros for OVSDB struct generation

License

This project is licensed under the Apache License, Version 2.0.