route_manager 0.2.11

Cross-platform route management interface
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

# route_manager


[![Crates.io](https://img.shields.io/crates/v/route_manager.svg)](https://crates.io/crates/route_manager)
[![route_manager](https://docs.rs/route_manager/badge.svg)](https://docs.rs/route_manager)

Used for adding, deleting, and querying routes,
with support for asynchronous or synchronous monitoring of route changes.

## Supported Platforms


| Platform |   |
|----------|---|
| Windows  | ✅ |
| Linux    | ✅ |
| macOS    | ✅ |
| FreeBSD  | ✅ |
| OpenBSD  | ✅ |
| NetBSD   | ✅ |

## Features:


1. Supporting Synchronous and Asynchronous API
2. Supports choosing between Tokio and async-io for asynchronous I/O operations.

## Example:

Asynchronous API
```rust
use route_manager::{AsyncRouteManager, Route};
use std::time::Duration;
#[tokio::main]

pub async fn main() {
    let mut route_listener = AsyncRouteManager::listener().unwrap();
    tokio::spawn(async move {
        while let Ok(route) = route_listener.listen().await {
            println!("listen {route}");
        }
    });
    // Need to set up the correct gateway
    let route = Route::new("192.168.2.0".parse().unwrap(), 24).with_if_index(1);
    let mut manager = AsyncRouteManager::new().unwrap();
    let result = manager.add(&route).await;
    println!("route add {route} {result:?}");
    tokio::time::sleep(Duration::from_secs(1)).await;
    let result = manager.delete(&route).await;
    println!("route delete {route} {result:?}");
    tokio::time::sleep(Duration::from_secs(1)).await;
}
```
Synchronous API
```rust
use route_manager::{Route, RouteManager};
use std::thread;
use std::time::Duration;

pub fn main() {
    let mut route_listener = RouteManager::listener().unwrap();
    #[cfg(feature = "shutdown")]
    let shutdown_handle = route_listener.shutdown_handle().unwrap();
    thread::spawn(move || {
        while let Ok(route) = route_listener.listen() {
            println!("listen {route}");
        }
        println!("========= end =========");
    });
    // Need to set up the correct gateway
    let route = Route::new("192.168.2.0".parse().unwrap(), 24).with_if_index(1);
    let mut manager = RouteManager::new().unwrap();

    let result = manager.add(&route);
    println!("route add {route} {result:?}");
    thread::sleep(Duration::from_secs(1));
    let result = manager.delete(&route);
    println!("route delete {route} {result:?}");
    thread::sleep(Duration::from_secs(1));
    #[cfg(feature = "shutdown")]
    shutdown_handle.shutdown().unwrap();
    thread::sleep(Duration::from_secs(100));
}
```
## Reference project


- [net-route](https://github.com/johnyburd/net-route)