Merge pull request #14 from FxQnLr/axum7

Axum7 & config changes

10 files changed, 172 insertions, 153 deletions

diff --git a/src/auth.rs b/src/auth.rs
index e4b1c2f..feca652 100644
--- a/src/auth.rs
+++ b/src/auth.rs
@@ -1,18 +1,15 @@
-use axum::headers::HeaderValue;
-use axum::http::StatusCode;
+use axum::http::{StatusCode, HeaderValue};
 use axum::http::header::ToStrError;
 use tracing::{debug, error, trace};
-use crate::auth::AuthError::{MissingSecret, WrongSecret};
-use crate::config::SETTINGS;
+use crate::auth::Error::{MissingSecret, WrongSecret};
+use crate::config::Config;
 
-pub fn auth(secret: Option<&HeaderValue>) -> Result<bool, AuthError> {
+pub fn auth(config: &Config, secret: Option<&HeaderValue>) -> Result<bool, Error> {
     debug!("auth request with secret {:?}", secret);
     if let Some(value) = secret {
         trace!("value exists");
-        let key = SETTINGS
-            .get_string("apikey")
-            .map_err(AuthError::Config)?;
-        if value.to_str().map_err(AuthError::HeaderToStr)? == key.as_str() {
+        let key = &config.apikey;
+        if value.to_str().map_err(Error::HeaderToStr)? == key.as_str() {
             debug!("successful auth");
             Ok(true)
         } else {
@@ -26,22 +23,17 @@ pub fn auth(secret: Option<&HeaderValue>) -> Result<bool, AuthError> {
 }
 
 #[derive(Debug)]
-pub enum AuthError {
+pub enum Error {
     WrongSecret,
     MissingSecret,
-    Config(config::ConfigError),
     HeaderToStr(ToStrError)
 }
 
-impl AuthError {
+impl Error {
     pub fn get(self) -> (StatusCode, &'static str) {
         match self {
             Self::WrongSecret => (StatusCode::UNAUTHORIZED, "Wrong credentials"),
             Self::MissingSecret => (StatusCode::BAD_REQUEST, "Missing credentials"),
-            Self::Config(err) => {
-                error!("server error: {}", err.to_string());
-                (StatusCode::INTERNAL_SERVER_ERROR, "Server Error")
-            },
             Self::HeaderToStr(err) => {
                 error!("server error: {}", err.to_string());
                 (StatusCode::INTERNAL_SERVER_ERROR, "Server Error")
diff --git a/src/config.rs b/src/config.rs
index 4c79810..4319ffc 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -1,11 +1,25 @@
-use config::Config;
-use once_cell::sync::Lazy;
+use config::File;
+use serde::Deserialize;
 
-pub static SETTINGS: Lazy<Config> = Lazy::new(setup);
+#[derive(Debug, Clone, Deserialize)]
+pub struct Config {
+    pub database_url: String,
+    pub apikey: String,
+    pub serveraddr: String,
+    pub pingtimeout: i64,
+}
+
+impl Config {
+    pub fn load() -> Result<Self, config::ConfigError> {
+        let config = config::Config::builder()
+            .set_default("serveraddr", "0.0.0.0:7229")?
+            .set_default("pingtimeout", 10)?
+            .add_source(File::with_name("config.toml").required(false))
+            .add_source(File::with_name("config.dev.toml").required(false))
+            .add_source(config::Environment::with_prefix("WEBOL").prefix_separator("_"))
+            .build()?;
+
+        config.try_deserialize()
+    }
+}
 
-fn setup() -> Config {
-    Config::builder()
-        .add_source(config::Environment::with_prefix("WEBOL").separator("_"))
-        .build()
-        .unwrap()
-}
\ No newline at end of file
diff --git a/src/db.rs b/src/db.rs
index 8a6b16e..489a000 100644
--- a/src/db.rs
+++ b/src/db.rs
@@ -1,13 +1,7 @@
-#[cfg(debug_assertions)]
-use std::env;
-
 use serde::Serialize;
 use sqlx::{PgPool, postgres::PgPoolOptions};
 use tracing::{debug, info};
 
-#[cfg(not(debug_assertions))]
-use crate::config::SETTINGS;
-
 #[derive(Serialize, Debug)]
 pub struct Device {
     pub id: String,
@@ -17,18 +11,12 @@ pub struct Device {
     pub times: Option<Vec<i64>>
 }
 
-pub async fn init_db_pool() -> PgPool {
-    #[cfg(not(debug_assertions))]
-    let db_url = SETTINGS.get_string("database.url").unwrap();
-
-    #[cfg(debug_assertions)]
-    let db_url = env::var("DATABASE_URL").unwrap();
-
+pub async fn init_db_pool(db_url: &str) -> PgPool {
     debug!("attempt to connect dbPool to '{}'", db_url);
 
     let pool = PgPoolOptions::new()
         .max_connections(5)
-        .connect(&db_url)
+        .connect(db_url)
         .await
         .unwrap();
 
diff --git a/src/error.rs b/src/error.rs
index 5b82534..56d6c52 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -4,10 +4,10 @@ use axum::Json;
 use axum::response::{IntoResponse, Response};
 use serde_json::json;
 use tracing::error;
-use crate::auth::AuthError;
+use crate::auth::Error as AuthError;
 
 #[derive(Debug)]
-pub enum WebolError {
+pub enum Error {
     Generic,
     Auth(AuthError),
     DB(sqlx::Error),
@@ -16,7 +16,7 @@ pub enum WebolError {
     Broadcast(io::Error),
 }
 
-impl IntoResponse for WebolError {
+impl IntoResponse for Error {
     fn into_response(self) -> Response {
         let (status, error_message) = match self {
             Self::Auth(err) => {
@@ -45,4 +45,4 @@ impl IntoResponse for WebolError {
         }));
         (status, body).into_response()
     }
-}
\ No newline at end of file
+}
diff --git a/src/main.rs b/src/main.rs
index e96b736..4ef129b 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -8,12 +8,12 @@ use time::util::local_offset;
 use tokio::sync::broadcast::{channel, Sender};
 use tracing::{info, level_filters::LevelFilter};
 use tracing_subscriber::{EnvFilter, fmt::{self, time::LocalTime}, prelude::*};
-use crate::config::SETTINGS;
+use crate::config::Config;
 use crate::db::init_db_pool;
-use crate::routes::device::{get_device, post_device, put_device};
+use crate::routes::device;
 use crate::routes::start::start;
 use crate::routes::status::status;
-use crate::services::ping::{BroadcastCommands, PingMap};
+use crate::services::ping::{BroadcastCommands, StatusMap};
 
 mod auth;
 mod config;
@@ -24,7 +24,10 @@ mod error;
 mod services;
 
 #[tokio::main]
-async fn main() {
+async fn main() -> color_eyre::eyre::Result<()> {
+
+    color_eyre::install()?;
+
     unsafe { local_offset::set_soundness(local_offset::Soundness::Unsound); }
     let time_format =
         time::macros::format_description!("[year]-[month]-[day] [hour]:[minute]:[second]");
@@ -43,35 +46,39 @@ async fn main() {
 
     let version = env!("CARGO_PKG_VERSION");
 
+    let config = Config::load()?;
+
     info!("start webol v{}", version);
 
-    let db = init_db_pool().await;
+    let db = init_db_pool(&config.database_url).await;
     sqlx::migrate!().run(&db).await.unwrap();
 
     let (tx, _) = channel(32);
 
-    let ping_map: PingMap = DashMap::new();
+    let ping_map: StatusMap = DashMap::new();
     
-    let shared_state = Arc::new(AppState { db, ping_send: tx, ping_map });
+    let shared_state = Arc::new(AppState { db, config: config.clone(), ping_send: tx, ping_map });
 
     let app = Router::new()
         .route("/start", post(start))
-        .route("/device", get(get_device))
-        .route("/device", put(put_device))
-        .route("/device", post(post_device))
+        .route("/device", get(device::get))
+        .route("/device", put(device::put))
+        .route("/device", post(device::post))
         .route("/status", get(status))
         .with_state(shared_state);
 
-    let addr = SETTINGS.get_string("serveraddr").unwrap_or("0.0.0.0:7229".to_string());
+    let addr = config.serveraddr;
     info!("start server on {}", addr);
-    axum::Server::bind(&addr.parse().unwrap())
-        .serve(app.into_make_service())
-        .await
-        .unwrap();
+    let listener = tokio::net::TcpListener::bind(addr)
+        .await?;
+    axum::serve(listener, app).await?;
+
+    Ok(())
 }
 
 pub struct AppState {
     db: PgPool,
+    config: Config,
     ping_send: Sender<BroadcastCommands>,
-    ping_map: PingMap,
-}
\ No newline at end of file
+    ping_map: StatusMap,
+}
diff --git a/src/routes/device.rs b/src/routes/device.rs
index 678d117..c85df1b 100644
--- a/src/routes/device.rs
+++ b/src/routes/device.rs
@@ -1,18 +1,18 @@
 use std::sync::Arc;
 use axum::extract::State;
-use axum::headers::HeaderMap;
 use axum::Json;
+use axum::http::HeaderMap;
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
 use tracing::{debug, info};
 use crate::auth::auth;
 use crate::db::Device;
-use crate::error::WebolError;
+use crate::error::Error;
 
-pub async fn get_device(State(state): State<Arc<crate::AppState>>, headers: HeaderMap, Json(payload): Json<GetDevicePayload>) -> Result<Json<Value>, WebolError> {
+pub async fn get(State(state): State<Arc<crate::AppState>>, headers: HeaderMap, Json(payload): Json<GetDevicePayload>) -> Result<Json<Value>, Error> {
     info!("add device {}", payload.id);
     let secret = headers.get("authorization");
-    if auth(secret).map_err(WebolError::Auth)? {
+    if auth(&state.config, secret).map_err(Error::Auth)? {
         let device = sqlx::query_as!(
             Device,
             r#"
@@ -21,13 +21,13 @@ pub async fn get_device(State(state): State<Arc<crate::AppState>>, headers: Head
             WHERE id = $1;
             "#,
             payload.id
-        ).fetch_one(&state.db).await.map_err(WebolError::DB)?;
+        ).fetch_one(&state.db).await.map_err(Error::DB)?;
 
         debug!("got device {:?}", device);
 
         Ok(Json(json!(device)))
     } else {
-        Err(WebolError::Generic)
+        Err(Error::Generic)
     }
 }
 
@@ -36,10 +36,10 @@ pub struct GetDevicePayload {
     id: String,
 }
 
-pub async fn put_device(State(state): State<Arc<crate::AppState>>, headers: HeaderMap, Json(payload): Json<PutDevicePayload>) -> Result<Json<Value>, WebolError> {
+pub async fn put(State(state): State<Arc<crate::AppState>>, headers: HeaderMap, Json(payload): Json<PutDevicePayload>) -> Result<Json<Value>, Error> {
     info!("add device {} ({}, {}, {})", payload.id, payload.mac, payload.broadcast_addr, payload.ip);
     let secret = headers.get("authorization");
-    if auth(secret).map_err(WebolError::Auth)? {
+    if auth(&state.config, secret).map_err(Error::Auth)? {
         sqlx::query!(
             r#"
             INSERT INTO devices (id, mac, broadcast_addr, ip)
@@ -49,11 +49,11 @@ pub async fn put_device(State(state): State<Arc<crate::AppState>>, headers: Head
             payload.mac,
             payload.broadcast_addr,
             payload.ip
-        ).execute(&state.db).await.map_err(WebolError::DB)?;
+        ).execute(&state.db).await.map_err(Error::DB)?;
 
         Ok(Json(json!(PutDeviceResponse { success: true })))
     } else {
-        Err(WebolError::Generic)
+        Err(Error::Generic)
     }
 }
 
@@ -70,10 +70,10 @@ pub struct PutDeviceResponse {
     success: bool
 }
 
-pub async fn post_device(State(state): State<Arc<crate::AppState>>, headers: HeaderMap, Json(payload): Json<PostDevicePayload>) -> Result<Json<Value>, WebolError> {
+pub async fn post(State(state): State<Arc<crate::AppState>>, headers: HeaderMap, Json(payload): Json<PostDevicePayload>) -> Result<Json<Value>, Error> {
     info!("edit device {} ({}, {}, {})", payload.id, payload.mac, payload.broadcast_addr, payload.ip);
     let secret = headers.get("authorization");
-    if auth(secret).map_err(WebolError::Auth)? {
+    if auth(&state.config, secret).map_err(Error::Auth)? {
         let device = sqlx::query_as!(
             Device,
             r#"
@@ -85,11 +85,11 @@ pub async fn post_device(State(state): State<Arc<crate::AppState>>, headers: Hea
             payload.broadcast_addr,
             payload.ip,
             payload.id
-        ).fetch_one(&state.db).await.map_err(WebolError::DB)?;
+        ).fetch_one(&state.db).await.map_err(Error::DB)?;
 
         Ok(Json(json!(device)))
     } else {
-        Err(WebolError::Generic)
+        Err(Error::Generic)
     }
 }
 
diff --git a/src/routes/start.rs b/src/routes/start.rs
index 1555db3..ce95bf3 100644
--- a/src/routes/start.rs
+++ b/src/routes/start.rs
@@ -1,23 +1,26 @@
-use axum::headers::HeaderMap;
+use crate::auth::auth;
+use crate::db::Device;
+use crate::error::Error;
+use crate::services::ping::Value as PingValue;
+use crate::wol::{create_buffer, send_packet};
+use axum::extract::State;
+use axum::http::HeaderMap;
 use axum::Json;
 use serde::{Deserialize, Serialize};
-use std::sync::Arc;
-use axum::extract::State;
 use serde_json::{json, Value};
+use std::sync::Arc;
 use tracing::{debug, info};
 use uuid::Uuid;
-use crate::auth::auth;
-use crate::config::SETTINGS;
-use crate::wol::{create_buffer, send_packet};
-use crate::db::Device;
-use crate::error::WebolError;
-use crate::services::ping::PingValue;
 
 #[axum_macros::debug_handler]
-pub async fn start(State(state): State<Arc<crate::AppState>>, headers: HeaderMap, Json(payload): Json<StartPayload>) -> Result<Json<Value>, WebolError> {
+pub async fn start(
+    State(state): State<Arc<crate::AppState>>,
+    headers: HeaderMap,
+    Json(payload): Json<Payload>,
+) -> Result<Json<Value>, Error> {
     info!("POST request");
     let secret = headers.get("authorization");
-    let authorized = auth(secret).map_err(WebolError::Auth)?;
+    let authorized = auth(&state.config, secret).map_err(Error::Auth)?;
     if authorized {
         let device = sqlx::query_as!(
             Device,
@@ -27,18 +30,19 @@ pub async fn start(State(state): State<Arc<crate::AppState>>, headers: HeaderMap
             WHERE id = $1;
             "#,
             payload.id
-        ).fetch_one(&state.db).await.map_err(WebolError::DB)?;
+        )
+        .fetch_one(&state.db)
+        .await
+        .map_err(Error::DB)?;
 
         info!("starting {}", device.id);
 
-        let bind_addr = SETTINGS
-            .get_string("bindaddr")
-            .unwrap_or("0.0.0.0:1111".to_string());
+        let bind_addr = "0.0.0.0:0";
 
         let _ = send_packet(
-            &bind_addr.parse().map_err(WebolError::IpParse)?,
-            &device.broadcast_addr.parse().map_err(WebolError::IpParse)?,
-            create_buffer(&device.mac)?
+            &bind_addr.parse().map_err(Error::IpParse)?,
+            &device.broadcast_addr.parse().map_err(Error::IpParse)?,
+            &create_buffer(&device.mac)?,
         )?;
         let dev_id = device.id.clone();
         let uuid = if payload.ping.is_some_and(|ping| ping) {
@@ -49,7 +53,7 @@ pub async fn start(State(state): State<Arc<crate::AppState>>, headers: HeaderMap
                     uuid = Some(key);
                     break;
                 }
-            };
+            }
             let uuid_gen = match uuid {
                 Some(u) => u,
                 None => Uuid::new_v4().to_string(),
@@ -58,26 +62,46 @@ pub async fn start(State(state): State<Arc<crate::AppState>>, headers: HeaderMap
 
             tokio::spawn(async move {
                 debug!("init ping service");
-                state.ping_map.insert(uuid_gen.clone(), PingValue { ip: device.ip.clone(), online: false });
+                state.ping_map.insert(
+                    uuid_gen.clone(),
+                    PingValue {
+                        ip: device.ip.clone(),
+                        online: false,
+                    },
+                );
 
-                crate::services::ping::spawn(state.ping_send.clone(), device, uuid_gen.clone(), &state.ping_map, &state.db).await
+                crate::services::ping::spawn(
+                    state.ping_send.clone(),
+                    &state.config,
+                    device,
+                    uuid_gen.clone(),
+                    &state.ping_map,
+                    &state.db,
+                )
+                .await;
             });
             Some(uuid_genc)
-        } else { None };
-        Ok(Json(json!(StartResponse { id: dev_id, boot: true, uuid })))
+        } else {
+            None
+        };
+        Ok(Json(json!(Response {
+            id: dev_id,
+            boot: true,
+            uuid
+        })))
     } else {
-        Err(WebolError::Generic)
+        Err(Error::Generic)
     }
 }
 
 #[derive(Deserialize)]
-pub struct StartPayload {
+pub struct Payload {
     id: String,
     ping: Option<bool>,
 }
 
 #[derive(Serialize)]
-struct StartResponse {
+struct Response {
     id: String,
     boot: bool,
     uuid: Option<String>,
diff --git a/src/routes/status.rs b/src/routes/status.rs
index 45f3e51..31ef996 100644
--- a/src/routes/status.rs
+++ b/src/routes/status.rs
@@ -7,4 +7,4 @@ use crate::services::ping::status_websocket;
 #[axum_macros::debug_handler]
 pub async fn status(State(state): State<Arc<AppState>>, ws: WebSocketUpgrade) -> Response {
     ws.on_upgrade(move |socket| status_websocket(socket, state))
-}
\ No newline at end of file
+}
diff --git a/src/services/ping.rs b/src/services/ping.rs
index c3bdced..9b164c8 100644
--- a/src/services/ping.rs
+++ b/src/services/ping.rs
@@ -2,26 +2,26 @@ use std::str::FromStr;
 use std::net::IpAddr;
 use std::sync::Arc;
 
-use axum::extract::{ws::WebSocket};
+use axum::extract::ws::WebSocket;
 use axum::extract::ws::Message;
 use dashmap::DashMap;
 use sqlx::PgPool;
 use time::{Duration, Instant};
-use tokio::sync::broadcast::{Sender};
+use tokio::sync::broadcast::Sender;
 use tracing::{debug, error, trace};
 use crate::AppState;
-use crate::config::SETTINGS;
+use crate::config::Config;
 use crate::db::Device;
 
-pub type PingMap = DashMap<String, PingValue>;
+pub type StatusMap = DashMap<String, Value>;
 
 #[derive(Debug, Clone)]
-pub struct PingValue {
+pub struct Value {
     pub ip: String,
     pub online: bool
 }
 
-pub async fn spawn(tx: Sender<BroadcastCommands>, device: Device, uuid: String, ping_map: &PingMap, db: &PgPool) {
+pub async fn spawn(tx: Sender<BroadcastCommands>, config: &Config, device: Device, uuid: String, ping_map: &StatusMap, db: &PgPool) {
     let timer = Instant::now();
     let payload = [0; 8];
 
@@ -40,7 +40,7 @@ pub async fn spawn(tx: Sender<BroadcastCommands>, device: Device, uuid: String,
                 error!("{}", ping.to_string());
                 msg = Some(BroadcastCommands::Error(uuid.clone()));
             }
-            if timer.elapsed() >= Duration::minutes(SETTINGS.get_int("pingtimeout").unwrap_or(10)) {
+            if timer.elapsed() >= Duration::minutes(config.pingtimeout) {
                 msg = Some(BroadcastCommands::Timeout(uuid.clone()));
             }
         } else {
@@ -63,7 +63,7 @@ pub async fn spawn(tx: Sender<BroadcastCommands>, device: Device, uuid: String,
             timer.elapsed().whole_seconds(),
             device.id
         ).execute(db).await.unwrap();
-        ping_map.insert(uuid.clone(), PingValue { ip: device.ip.clone(), online: true });
+        ping_map.insert(uuid.clone(), Value { ip: device.ip.clone(), online: true });
         tokio::time::sleep(tokio::time::Duration::from_secs(60)).await;
     }
     trace!("remove {} from ping_map", uuid);
@@ -85,17 +85,14 @@ pub async fn status_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 _ = socket.send(Message::Text(format!("eta_{eta}_{uuid}"))).await;
 
     let device_exists = state.ping_map.contains_key(&uuid);
-    match device_exists {
-        true => {
-            let _ = socket.send(process_device(state.clone(), uuid).await).await;
-        },
-        false => {
-            debug!("didn't find any device");
-            let _ = socket.send(Message::Text(format!("notfound_{}", uuid))).await;
-        },
+    if device_exists {
+        let _ = socket.send(process_device(state.clone(), uuid).await).await;
+    } else {
+        debug!("didn't find any device");
+        let _ = socket.send(Message::Text(format!("notfound_{uuid}"))).await;
     };
 
     let _ = socket.close().await;
@@ -110,7 +107,7 @@ async fn get_eta(db: &PgPool) -> i64 {
         None => { vec![0] },
         Some(t) => t,
     };
-    times.iter().sum::<i64>() / times.len() as i64
+    times.iter().sum::<i64>() / i64::try_from(times.len()).unwrap()
 
 }
 
@@ -118,34 +115,31 @@ async fn process_device(state: Arc<AppState>, uuid: String) -> Message {
     let pm = state.ping_map.clone().into_read_only();
     let device = pm.get(&uuid).expect("fatal error");
     debug!("got device: {} (online: {})", device.ip, device.online);
-    match device.online {
-        true => {
-            debug!("already started");
-            Message::Text(format!("start_{}", uuid))
-        },
-        false => {
-            loop{
-                trace!("wait for tx message");
-                let message = state.ping_send.subscribe().recv().await.expect("fatal error");
-                trace!("got message {:?}", message);
-                return match message {
-                    BroadcastCommands::Success(msg_uuid) => {
-                        if msg_uuid != uuid { continue; }
-                        trace!("message == uuid success");
-                        Message::Text(format!("start_{}", uuid))
-                    },
-                    BroadcastCommands::Timeout(msg_uuid) => {
-                        if msg_uuid != uuid { continue; }
-                        trace!("message == uuid timeout");
-                        Message::Text(format!("timeout_{}", uuid))
-                    },
-                    BroadcastCommands::Error(msg_uuid) => {
-                        if msg_uuid != uuid { continue; }
-                        trace!("message == uuid error");
-                        Message::Text(format!("error_{}", uuid))
-                    }
+    if device.online {
+        debug!("already started");
+        Message::Text(format!("start_{uuid}"))
+    } else {
+        loop {
+            trace!("wait for tx message");
+            let message = state.ping_send.subscribe().recv().await.expect("fatal error");
+            trace!("got message {:?}", message);
+            return match message {
+                BroadcastCommands::Success(msg_uuid) => {
+                    if msg_uuid != uuid { continue; }
+                    trace!("message == uuid success");
+                    Message::Text(format!("start_{uuid}"))
+                },
+                BroadcastCommands::Timeout(msg_uuid) => {
+                    if msg_uuid != uuid { continue; }
+                    trace!("message == uuid timeout");
+                    Message::Text(format!("timeout_{uuid}"))
+                },
+                BroadcastCommands::Error(msg_uuid) => {
+                    if msg_uuid != uuid { continue; }
+                    trace!("message == uuid error");
+                    Message::Text(format!("error_{uuid}"))
                 }
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/wol.rs b/src/wol.rs
index 0cdcae3..83c0ee6 100644
--- a/src/wol.rs
+++ b/src/wol.rs
@@ -1,17 +1,17 @@
 use std::net::{SocketAddr, UdpSocket};
 
-use crate::error::WebolError;
+use crate::error::Error;
 
 /// Creates the magic packet from a mac address
 ///
 /// # Panics
 ///
 /// Panics if `mac_addr` is an invalid mac
-pub fn create_buffer(mac_addr: &str) -> Result<Vec<u8>, WebolError> {
+pub fn create_buffer(mac_addr: &str) -> Result<Vec<u8>, Error> {
     let mut mac = Vec::new();
     let sp = mac_addr.split(':');
     for f in sp {
-        mac.push(u8::from_str_radix(f, 16).map_err(WebolError::BufferParse)?)
+        mac.push(u8::from_str_radix(f, 16).map_err(Error::BufferParse)?);
     };
     let mut buf = vec![255; 6];
     for _ in 0..16 {
@@ -23,8 +23,8 @@ pub fn create_buffer(mac_addr: &str) -> Result<Vec<u8>, WebolError> {
 }
 
 /// Sends a buffer on UDP broadcast
-pub fn send_packet(bind_addr: &SocketAddr, broadcast_addr: &SocketAddr, buffer: Vec<u8>) -> Result<usize, WebolError> {
-    let socket = UdpSocket::bind(bind_addr).map_err(WebolError::Broadcast)?;
-    socket.set_broadcast(true).map_err(WebolError::Broadcast)?;
-    socket.send_to(&buffer, broadcast_addr).map_err(WebolError::Broadcast)
+pub fn send_packet(bind_addr: &SocketAddr, broadcast_addr: &SocketAddr, buffer: &[u8]) -> Result<usize, Error> {
+    let socket = UdpSocket::bind(bind_addr).map_err(Error::Broadcast)?;
+    socket.set_broadcast(true).map_err(Error::Broadcast)?;
+    socket.send_to(buffer, broadcast_addr).map_err(Error::Broadcast)
 }