rupnp 3.0.0

An asynchronous library for finding UPnP control points, performing actions on them and reading their service descriptions.
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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use futures::prelude::*;
use rupnp::{
    http::Uri,
    ssdp::{SearchTarget, URN},
    DeviceSpec, Error, Service,
};
use std::{
    fs,
    path::{Path, PathBuf},
    time::Duration,
};
use tokio::task::{spawn, JoinHandle};

#[tokio::main]
async fn main() -> Result<(), Error> {
    let mut devices: Vec<_> =
        rupnp::discover(&SearchTarget::RootDevice, Duration::from_secs(1), None)
            .await?
            .filter_map(|result| async { result.map_err(|e| println!("{e}")).ok() })
            .collect()
            .await;

    devices.sort_by_key(|d| d.device_type().clone());
    devices.dedup_by_key(|d| d.device_type().clone());

    let path = PathBuf::from("descriptions");
    if path.exists() {
        fs::remove_dir_all(&path)?;
    }

    let mut handles = Vec::new();

    for device in devices {
        print(&device, device.url(), 0, &path, &mut handles)?;
        println!();
    }

    for handle in handles {
        handle.await.unwrap()?;
    }

    Ok(())
}

fn print(
    device: &DeviceSpec,
    url: &Uri,
    indentation: usize,
    path: &Path,
    handles: &mut Vec<JoinHandle<Result<(), rupnp::Error>>>,
) -> Result<(), Error> {
    let path = path.join(urn_to_str(device.device_type()));
    fs::create_dir_all(&path)?;

    let i = "  ".repeat(indentation);

    println!("{}{}", i, urn_to_str(device.device_type()));

    for service in device.services() {
        let svc = urn_to_str(service.service_type());

        println!("{i}  - {svc}");

        let url = url.clone();
        let path = path.clone();
        let service = service.clone();

        handles.push(spawn(async move {
            use std::io::Write;

            // let mut svc_file = tokio::fs::File::create(path.join(&svc)).await?;
            let mut svc_file = std::fs::File::create(path.join(&svc))?;

            let mut buf = Vec::with_capacity(128);
            write_service(&mut buf, service, url).await?;

            svc_file.write_all(&buf)?;
            // svc_file.write_all(&buf).await?;
            Ok(())
        }));
    }

    for device in device.devices() {
        print(device, url, indentation + 1, &path, handles)?;
    }

    Ok(())
}

async fn write_service(
    mut w: impl std::io::Write,
    service: Service,
    url: Uri,
) -> Result<(), Error> {
    let scpd = service.scpd(&url).await?;

    writeln!(w, "StateVars {{")?;
    for state_var in scpd.state_variables() {
        if state_var.sends_events() {
            writeln!(w, "  {state_var} (sends events)")?;
        } else {
            writeln!(w, "  {state_var}")?;
        }
    }
    writeln!(w, "}}\n\nActions {{")?;
    for action in scpd.actions() {
        writeln!(w, "  {action}")?;
    }
    writeln!(w, "}}")?;

    Ok(())
}

fn urn_to_str(urn: &URN) -> String {
    urn.typ().to_string().to_lowercase()
}