Merge pull request #10 from tsirysndr/xmlerrors-to-anyhow

Xmlerrors to anyhow

Cargo.toml

···
 [package]
 name = "upnp-client"
-version = "0.1.8"
+version = "0.1.9"
 edition = "2021"
 repository = "https://github.com/tsirysndr/upnp-client-rs"
 license = "MIT"

README.md

···
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let devices = discover_pnp_locations();
+    let devices = discover_pnp_locations().await?;
     tokio::pin!(devices);
 
     while let Some(device) = devices.next().await {
···
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let devices = discover_pnp_locations();
+    let devices = discover_pnp_locations().await?;
     tokio::pin!(devices);
 
     let mut kodi_device: Option<Device> = None;
···
     }
 
     let kodi_device = kodi_device.unwrap();
-    let device_client = DeviceClient::new(&kodi_device.location).connect().await?;
+    let device_client = DeviceClient::new(&kodi_device.location)?.connect().await?;
     let media_renderer = MediaRendererClient::new(device_client);
 
     let options = LoadOptions {
···
 - [UPnP AV ContentDirectory v3 Service](http://upnp.org/specs/av/UPnP-av-ContentDirectory-v3-Service.pdf)
 
 ### License
-MIT
+MIT

src/device_client.rs

···
-use std::{
-    collections::HashMap,
-    env,
-    net::TcpListener,
-    sync::{
-        Arc,
-    },
-    time::Duration,
-};
+use std::{collections::HashMap, env, net::TcpListener, sync::Arc, time::Duration};
 
 use crate::{
     parser::{
···
 
         for (name, value) in params {
             let mut param = XMLElement::new(name.as_str());
-            param.add_text(value)?;
-            action.add_child(param)?;
+            param.add_text(value).map_err(|e| anyhow!("{:?}", e))?;
+            action.add_child(param).map_err(|e| anyhow!("{:?}", e))?;
         }
 
-        body.add_child(action)?;
-        envelope.add_child(body)?;
+        body.add_child(action).map_err(|e| anyhow!("{:?}", e))?;
+        envelope.add_child(body).map_err(|e| anyhow!("{:?}", e))?;
 
         xml.set_root_element(envelope);
 
         let mut writer: Vec<u8> = Vec::new();
-        xml.generate(&mut writer)?;
+        xml.generate(&mut writer).map_err(|e| anyhow!("{:?}", e))?;
         let xml = String::from_utf8(writer)?;
 
         let soap_action = format!("\"{}#{}\"", service.service_type, action_name);
···
             .send()
             .await
             .map_err(|e| anyhow!(e.to_string()))?;
-        res
-            .body_string()
-            .await
-            .map_err(|e| anyhow!(e.to_string()))
+        res.body_string().await.map_err(|e| anyhow!(e.to_string()))
     }
 
     async fn get_service_description(&self, service_id: &str) -> Result<Service> {
···
                 .services
                 .iter()
                 .find(|s| s.service_id == service_id)
-                .ok_or_else(|| anyhow!("Service with requested service_id {} does not exist", service_id))?;
+                .ok_or_else(|| {
+                    anyhow!(
+                        "Service with requested service_id {} does not exist",
+                        service_id
+                    )
+                })?;
             return Ok(service.clone());
         }
         Err(anyhow!("Device not connected"))

src/parser.rs

···
                 Some(element) => {
                     return Ok(element.text().to_string());
                 }
-                None => {
-                    Ok("".to_string())
-                }
+                None => Ok("".to_string()),
             }
         }
         None => Ok("".to_string()),
···
     let parser = EventReader::from_str(xml_root);
     let mut current_play_mode: Option<String> = None;
     for e in parser.into_iter().flatten() {
-        if let XmlEvent::StartElement { name, attributes, .. } = e {
+        if let XmlEvent::StartElement {
+            name, attributes, ..
+        } = e
+        {
             if name.local_name == "CurrentPlayMode" {
                 for attr in attributes {
                     if attr.name.local_name == "val" {
···
     let parser = EventReader::from_str(xml_root);
     let mut transport_state: Option<String> = None;
     for e in parser.into_iter().flatten() {
-        if let XmlEvent::StartElement { name, attributes, .. } = e {
+        if let XmlEvent::StartElement {
+            name, attributes, ..
+        } = e
+        {
             if name.local_name == "TransportState" {
                 for attr in attributes {
                     if attr.name.local_name == "val" {
···
     let parser = EventReader::from_str(xml_root);
     let mut av_transport_uri_metadata: Option<String> = None;
     for e in parser.into_iter().flatten() {
-        if let XmlEvent::StartElement { name, attributes, .. } = e {
+        if let XmlEvent::StartElement {
+            name, attributes, ..
+        } = e
+        {
             if name.local_name == "AVTransportURIMetaData" {
                 for attr in attributes {
                     if attr.name.local_name == "val" {
···
     let parser = EventReader::from_str(xml_root);
     let mut current_track_metadata: Option<String> = None;
     for e in parser.into_iter().flatten() {
-        if let XmlEvent::StartElement { name, attributes, .. } = e {
+        if let XmlEvent::StartElement {
+            name, attributes, ..
+        } = e
+        {
             if name.local_name == "CurrentTrackMetaData" {
                 for attr in attributes {
                     if attr.name.local_name == "val" {
···
             </device>
         </root>"#;
 
-        let result = parse_services("http://xxxxxx:1337/", XML_ROOT).await;
+        let result = parse_services("http://xxxxxx:1337/", XML_ROOT)
+            .await
+            .unwrap();
         assert_eq!(result.len(), 0);
     }
 }