version 0.1.2

Author: kwheelans

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Unreleased
 
+# v0.1.2
+## Changes
+- When setting qBittorrent port value check the expected port matches the actual set port value
+
+## Fixes
+- Fix qBittorrent port update request json value
+
 # v0.1.1
 ## Changes
 - use local time for timestamps

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "vpn-port-forward-manager"
-version = "0.1.1"
+version = "0.1.2"
 edition = "2024"
 authors = ["Kevin Wheelans <kevin.wheelans@proton.me>"]
 description = "Updates the listen port for the supported applications to the port forward by the VPN provider"

Cargo.toml

@@ -4,12 +4,13 @@ mod qbittorrent;
 use crate::LINE_FEED;
 use anyhow::Context;
 use reqwest::blocking::Client;
+use std::fmt::Debug;
 use std::path::Path;
 use std::str::FromStr;
 use std::thread::sleep;
 use std::time::Duration;
 use strum::{Display, EnumString};
-use tracing::{debug, warn};
+use tracing::{debug, trace, warn};
 
 // Environment Variables
 const APPLICATION: &str = "APPLICATION";
@@ -45,7 +46,7 @@ pub trait App {
             warn!("Path to port forward value does not exist");
         }
         let value = std::fs::read_to_string(self.port_forward_path())?;
-        debug!("{:?}", value);
+        trace!("Found port value {}", value);
         let value = value.trim_matches(LINE_FEED);
         Ok(value.parse::<u16>()?)
     }
@@ -103,6 +104,15 @@ pub fn app_init() -> anyhow::Result<Box<dyn App>> {
         .unwrap_or(PORT_FORWARD_PATH_DEFAULT.into())
         .into();
 
+    // Print selected values
+    debug!("application: {}", application);
+    debug!("protocol: {}", protocol);
+    debug!("port: {}", application);
+    debug!("interval: {:?}", interval);
+    debug!("hostname: {}", hostname);
+    debug!("username: {}", username);
+    debug!("port_forward_path: {:?}", port_forward_path);
+
     Ok(match application {
         Application::QBittorrent => Box::new(qbittorrent::Qbittorrent {
             client,

src/apps.rs

@@ -1,5 +1,6 @@
 use crate::apps::{App, Protocol, endpoint};
 use reqwest::blocking::Client;
+use serde_json::Value;
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 use std::time::Duration;
@@ -8,6 +9,7 @@ use tracing::{debug, error, info, warn};
 // API Endpoints
 const QB_LOGIN_ENDPOINT: &str = "/api/v2/auth/login";
 const QB_SET_PREFERENCES_ENDPOINT: &str = "/api/v2/app/setPreferences";
+const QB_GET_PREFERENCES_ENDPOINT: &str = "/api/v2/app/preferences";
 
 pub struct Qbittorrent {
     pub client: Client,
@@ -51,18 +53,35 @@ impl App for Qbittorrent {
 
     fn set_port(&self, port: u16) -> bool {
         let client = &self.client;
-        let json = HashMap::from([("json".to_string(), format!("{{listen_port:{} }}", port))]);
+        let json = HashMap::from([("json".to_string(), format!("{{\"listen_port\":{} }}", port))]);
         let response = client
             .post(self.set_preference_endpoint())
             .form(&json)
             .send();
-
         match response {
             Ok(r) => {
                 let status = r.status();
                 if status.is_success() {
-                    info!("Port updated to {}", port);
-                    true
+                    let actual_port = self.get_current_listen_port();
+                    debug!("actual_port: {:?}", actual_port);
+                    match actual_port {
+                        None => {
+                            error!("unable to get actual port value");
+                            false
+                        }
+                        Some(actual) => {
+                            if port == actual {
+                                info!("Port updated to {}", port);
+                                true
+                            } else {
+                                warn!(
+                                    "Actual port {} does not match expected port number {}",
+                                    actual, port
+                                );
+                                false
+                            }
+                        }
+                    }
                 } else {
                     warn!("Port update request failed with status code: {}", status);
                     false
@@ -109,4 +128,38 @@ impl Qbittorrent {
             QB_SET_PREFERENCES_ENDPOINT,
         )
     }
+
+    fn get_preference_endpoint(&self) -> String {
+        endpoint(
+            self.protocol,
+            self.hostname.as_str(),
+            self.port,
+            QB_GET_PREFERENCES_ENDPOINT,
+        )
+    }
+
+    fn get_current_listen_port(&self) -> Option<u16> {
+        let client = &self.client;
+        let response = client.get(self.get_preference_endpoint()).send();
+
+        match response {
+            Ok(r) => {
+                let status = r.status();
+                if status.is_success() {
+                    let json: Value = r.json().expect("cannot get preference json");
+                    let current_port = json.as_object().unwrap().get("listen_port").unwrap();
+                    current_port
+                        .as_number()
+                        .map(|p| p.as_u64().unwrap_or_default() as u16)
+                } else {
+                    warn!("get preference request failed with status code: {}", status);
+                    None
+                }
+            }
+            Err(e) => {
+                error!("{}", e);
+                None
+            }
+        }
+    }
 }

src/apps/qbittorrent.rs

@@ -1,6 +1,6 @@
 use crate::apps::app_init;
 use std::str::FromStr;
-use tracing::{debug, error};
+use tracing::{error, trace};
 use tracing_subscriber::filter::LevelFilter;
 use tracing_subscriber::fmt::time::LocalTime;
 
@@ -37,7 +37,7 @@ fn run() -> anyhow::Result<()> {
                             last_port = port;
                         }
                     } else {
-                        debug!("Current and previous port match. No update required.")
+                        trace!("Current and previous port match. No update required.")
                     }
                 }
                 Err(error) => {