Merge pull request #32 from FxQnLr/0.4.0

0.4.0

3 files changed, 54 insertions, 188 deletions

diff --git a/src/routes/device.rs b/src/routes/device.rs
index 40b5cd8..49361f2 100644
--- a/src/routes/device.rs
+++ b/src/routes/device.rs
@@ -1,49 +1,17 @@
-use crate::db::Device;
 use crate::error::Error;
-use axum::extract::{Path, State};
+use crate::storage::Device;
+use axum::extract::Path;
 use axum::Json;
+use ipnetwork::IpNetwork;
 use mac_address::MacAddress;
 use serde::Deserialize;
 use serde_json::{json, Value};
-use sqlx::types::ipnetwork::IpNetwork;
-use std::{str::FromStr, sync::Arc};
+use std::str::FromStr;
 use tracing::{debug, info};
 use utoipa::ToSchema;
 
 #[utoipa::path(
     get,
-    path = "/device",
-    request_body = GetDevicePayload,
-    responses(
-        (status = 200, description = "Get `Device` information", body = [Device])
-    ),
-    security(("api_key" = []))
-)]
-#[deprecated]
-pub async fn get_payload(
-    State(state): State<Arc<crate::AppState>>,
-    Json(payload): Json<GetDevicePayload>,
-) -> Result<Json<Value>, Error> {
-    info!("get device {}", payload.id);
-    let device = sqlx::query_as!(
-        Device,
-        r#"
-        SELECT id, mac, broadcast_addr, ip, times
-        FROM devices
-        WHERE id = $1;
-        "#,
-        payload.id
-    )
-    .fetch_one(&state.db)
-    .await?;
-
-    debug!("got device {:?}", device);
-
-    Ok(Json(json!(device)))
-}
-
-#[utoipa::path(
-    get,
     path = "/device/{id}",
     responses(
         (status = 200, description = "Get `Device` information", body = [Device])
@@ -53,22 +21,10 @@ pub async fn get_payload(
     ),
     security((), ("api_key" = []))
 )]
-pub async fn get(
-    State(state): State<Arc<crate::AppState>>,
-    Path(path): Path<String>,
-) -> Result<Json<Value>, Error> {
-    info!("get device from path {}", path);
-    let device = sqlx::query_as!(
-        Device,
-        r#"
-        SELECT id, mac, broadcast_addr, ip, times
-        FROM devices
-        WHERE id = $1;
-        "#,
-        path
-    )
-    .fetch_one(&state.db)
-    .await?;
+pub async fn get(Path(id): Path<String>) -> Result<Json<Value>, Error> {
+    info!("get device from path {}", id);
+
+    let device = Device::read(&id)?;
 
     debug!("got device {:?}", device);
 
@@ -76,13 +32,7 @@ pub async fn get(
 }
 
 #[derive(Deserialize, ToSchema)]
-#[deprecated]
-pub struct GetDevicePayload {
-    id: String,
-}
-
-#[derive(Deserialize, ToSchema)]
-pub struct DevicePayload {
+pub struct DPayload {
     id: String,
     mac: String,
     broadcast_addr: String,
@@ -92,15 +42,14 @@ pub struct DevicePayload {
 #[utoipa::path(
     put,
     path = "/device",
-    request_body = DevicePayload,
+    request_body = DPayload,
     responses(
         (status = 200, description = "add device to storage", body = [DeviceSchema])
     ),
     security((), ("api_key" = []))
 )]
 pub async fn put(
-    State(state): State<Arc<crate::AppState>>,
-    Json(payload): Json<DevicePayload>,
+    Json(payload): Json<DPayload>,
 ) -> Result<Json<Value>, Error> {
     info!(
         "add device {} ({}, {}, {})",
@@ -109,20 +58,14 @@ pub async fn put(
 
     let ip = IpNetwork::from_str(&payload.ip)?;
     let mac = MacAddress::from_str(&payload.mac)?;
-    let device = sqlx::query_as!(
-        Device,
-        r#"
-        INSERT INTO devices (id, mac, broadcast_addr, ip)
-        VALUES ($1, $2, $3, $4)
-        RETURNING id, mac, broadcast_addr, ip, times;
-        "#,
-        payload.id,
+    let device = Device {
+        id: payload.id,
         mac,
-        payload.broadcast_addr,
-        ip
-    )
-    .fetch_one(&state.db)
-    .await?;
+        broadcast_addr: payload.broadcast_addr,
+        ip,
+        times: None,
+    };
+    device.write()?;
 
     Ok(Json(json!(device)))
 }
@@ -130,15 +73,14 @@ pub async fn put(
 #[utoipa::path(
     post,
     path = "/device",
-    request_body = DevicePayload,
+    request_body = DPayload,
     responses(
         (status = 200, description = "update device in storage", body = [DeviceSchema])
     ),
     security((), ("api_key" = []))
 )]
 pub async fn post(
-    State(state): State<Arc<crate::AppState>>,
-    Json(payload): Json<DevicePayload>,
+    Json(payload): Json<DPayload>,
 ) -> Result<Json<Value>, Error> {
     info!(
         "edit device {} ({}, {}, {})",
@@ -146,20 +88,16 @@ pub async fn post(
     );
     let ip = IpNetwork::from_str(&payload.ip)?;
     let mac = MacAddress::from_str(&payload.mac)?;
-    let device = sqlx::query_as!(
-        Device,
-        r#"
-        UPDATE devices
-        SET mac = $1, broadcast_addr = $2, ip = $3 WHERE id = $4
-        RETURNING id, mac, broadcast_addr, ip, times;
-        "#,
+    let times = Device::read(&payload.id)?.times;
+
+    let device = Device {
+        id: payload.id,
         mac,
-        payload.broadcast_addr,
+        broadcast_addr: payload.broadcast_addr,
         ip,
-        payload.id
-    )
-    .fetch_one(&state.db)
-    .await?;
+        times,
+    };
+    device.write()?;
 
     Ok(Json(json!(device)))
 }
diff --git a/src/routes/start.rs b/src/routes/start.rs
index ff3d1be..ae2b384 100644
--- a/src/routes/start.rs
+++ b/src/routes/start.rs
@@ -1,7 +1,7 @@
-use crate::db::Device;
+use crate::storage::Device;
 use crate::error::Error;
 use crate::services::ping::Value as PingValue;
-use crate::wol::{create_buffer, send_packet};
+use crate::wol::send_packet;
 use axum::extract::{Path, State};
 use axum::Json;
 use serde::{Deserialize, Serialize};
@@ -13,57 +13,8 @@ use uuid::Uuid;
 
 #[utoipa::path(
     post,
-    path = "/start",
-    request_body = PayloadOld,
-    responses(
-        (status = 200, description = "DEP", body = [Response])
-    ),
-    security((), ("api_key" = []))
-)]
-#[deprecated]
-pub async fn start_payload(
-    State(state): State<Arc<crate::AppState>>,
-    Json(payload): Json<PayloadOld>,
-) -> Result<Json<Value>, Error> {
-    info!("POST request");
-    let device = sqlx::query_as!(
-        Device,
-        r#"
-        SELECT id, mac, broadcast_addr, ip, times
-        FROM devices
-        WHERE id = $1;
-        "#,
-        payload.id
-    )
-    .fetch_one(&state.db)
-    .await?;
-
-    info!("starting {}", device.id);
-
-    let bind_addr = "0.0.0.0:0";
-
-    let _ = send_packet(
-        bind_addr,
-        &device.broadcast_addr,
-        &create_buffer(&device.mac.to_string())?,
-    )?;
-    let dev_id = device.id.clone();
-    let uuid = if payload.ping.is_some_and(|ping| ping) {
-        Some(setup_ping(state, device))
-    } else {
-        None
-    };
-    Ok(Json(json!(Response {
-        id: dev_id,
-        boot: true,
-        uuid
-    })))
-}
-
-#[utoipa::path(
-    post,
     path = "/start/{id}",
-    request_body = Option<Payload>,
+    request_body = Option<SPayload>,
     responses(
         (status = 200, description = "start the device with the given id", body = [Response])
     ),
@@ -75,9 +26,9 @@ pub async fn start_payload(
 pub async fn post(
     State(state): State<Arc<crate::AppState>>,
     Path(id): Path<String>,
-    payload: Option<Json<Payload>>,
+    payload: Option<Json<SPayload>>,
 ) -> Result<Json<Value>, Error> {
-    send_wol(state, &id, payload).await
+    send_wol(state, &id, payload)
 }
 
 #[utoipa::path(
@@ -95,26 +46,16 @@ pub async fn get(
     State(state): State<Arc<crate::AppState>>,
     Path(id): Path<String>,
 ) -> Result<Json<Value>, Error> {
-    send_wol(state, &id, None).await
+    send_wol(state, &id, None)
 }
 
-async fn send_wol(
+fn send_wol(
     state: Arc<crate::AppState>,
     id: &str,
-    payload: Option<Json<Payload>>,
+    payload: Option<Json<SPayload>>,
 ) -> Result<Json<Value>, Error> {
-    info!("Start request for {id}");
-    let device = sqlx::query_as!(
-        Device,
-        r#"
-        SELECT id, mac, broadcast_addr, ip, times
-        FROM devices
-        WHERE id = $1;
-        "#,
-        id
-    )
-    .fetch_one(&state.db)
-    .await?;
+    info!("start request for {id}");
+    let device = Device::read(id)?;
 
     info!("starting {}", device.id);
 
@@ -122,8 +63,8 @@ async fn send_wol(
 
     let _ = send_packet(
         bind_addr,
-        &device.broadcast_addr,
-        &create_buffer(&device.mac.to_string())?,
+        &device.broadcast_addr.to_string(),
+        &device.mac.bytes()
     )?;
     let dev_id = device.id.clone();
     let uuid = if let Some(pl) = payload {
@@ -163,6 +104,7 @@ fn setup_ping(state: Arc<crate::AppState>, device: Device) -> String {
         uuid_gen.clone(),
         PingValue {
             ip: device.ip,
+            eta: get_eta(device.clone().times),
             online: false,
         },
     );
@@ -174,7 +116,6 @@ fn setup_ping(state: Arc<crate::AppState>, device: Device) -> String {
             device,
             uuid_gen,
             &state.ping_map,
-            &state.db,
         )
         .await;
     });
@@ -182,15 +123,18 @@ fn setup_ping(state: Arc<crate::AppState>, device: Device) -> String {
     uuid_ret
 }
 
-#[derive(Deserialize, ToSchema)]
-#[deprecated]
-pub struct PayloadOld {
-    id: String,
-    ping: Option<bool>,
+fn get_eta(times: Option<Vec<i64>>) -> i64 {
+    let times = if let Some(times) = times {
+        times
+    } else {
+        vec![0]
+    };
+
+    times.iter().sum::<i64>() / i64::try_from(times.len()).unwrap()
 }
 
 #[derive(Deserialize, ToSchema)]
-pub struct Payload {
+pub struct SPayload {
     ping: Option<bool>,
 }
 
diff --git a/src/routes/status.rs b/src/routes/status.rs
index 0e25f7d..b38202b 100644
--- a/src/routes/status.rs
+++ b/src/routes/status.rs
@@ -3,7 +3,6 @@ use crate::AppState;
 use axum::extract::ws::{Message, WebSocket};
 use axum::extract::{State, WebSocketUpgrade};
 use axum::response::Response;
-use sqlx::PgPool;
 use std::sync::Arc;
 use tracing::{debug, trace};
 
@@ -18,13 +17,13 @@ pub async fn websocket(mut socket: WebSocket, state: Arc<AppState>) {
 
     trace!("Search for uuid: {}", uuid);
 
-    let eta = get_eta(&state.db).await;
-    let _ = socket
-        .send(Message::Text(format!("eta_{eta}_{uuid}")))
-        .await;
 
     let device_exists = state.ping_map.contains_key(&uuid);
     if device_exists {
+        let eta = state.ping_map.get(&uuid).unwrap().eta;
+        let _ = socket
+            .send(Message::Text(format!("eta_{eta}_{uuid}")))
+            .await;
         let _ = socket
             .send(receive_ping_broadcast(state.clone(), uuid).await)
             .await;
@@ -62,18 +61,3 @@ async fn receive_ping_broadcast(state: Arc<AppState>, uuid: String) -> Message {
         }
     }
 }
-
-async fn get_eta(db: &PgPool) -> i64 {
-    let query = sqlx::query!(r#"SELECT times FROM devices;"#)
-        .fetch_one(db)
-        .await
-        .unwrap();
-
-    let times = if let Some(times) = query.times {
-        times
-    } else {
-        vec![0]
-    };
-
-    times.iter().sum::<i64>() / i64::try_from(times.len()).unwrap()
-}