valmojr/armatak
1
0
Fork 0
mirror of https://github.com/valmojr/armatak.git synced 2026-06-13 15:33:29 +00:00
Code Issues Packages Projects Releases Wiki Activity

formatted some rust files for linting porpuses

Browse Source
This commit is contained in:
Valmo
2026-03-24 16:44:22 -03:00
parent 5ffc08e6f1
commit f88c02a7aa
17 changed files with 317 additions and 303 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/cot/cot.rs
View File

@@ -1,5 +1,5 @@
use uuid::Uuid;
use chrono::{Duration, SecondsFormat, Utc}; use chrono::{Duration, SecondsFormat, Utc};
use uuid::Uuid;
pub struct CursorOverTime { pub struct CursorOverTime {
pub uuid: Option<String>, pub uuid: Option<String>,

70
src/cot/digital_pointer.rs
View File

@@ -1,45 +1,45 @@
use arma_rs::{FromArma, FromArmaError};
use super::cot::CursorOverTime; use super::cot::CursorOverTime;
use arma_rs::{FromArma, FromArmaError};
pub struct DigitalPointerPayload { pub struct DigitalPointerPayload {
pub link_uid: String, pub link_uid: String,
pub contact_callsign: String, pub contact_callsign: String,
pub point_lat: f64, pub point_lat: f64,
pub point_lon: f64, pub point_lon: f64,
pub point_hae: f32, pub point_hae: f32,
} }
impl FromArma for DigitalPointerPayload { impl FromArma for DigitalPointerPayload {
fn from_arma(data: String) -> Result<DigitalPointerPayload, FromArmaError> { fn from_arma(data: String) -> Result<DigitalPointerPayload, FromArmaError> {
let (link_uid, contact_callsign, point_lat, point_lon, point_hae) = let (link_uid, contact_callsign, point_lat, point_lon, point_hae) =
<(String, String, f64, f64, f32)>::from_arma(data)?; <(String, String, f64, f64, f32)>::from_arma(data)?;
Ok(Self { Ok(Self {
link_uid, link_uid,
contact_callsign, contact_callsign,
point_lat, point_lat,
point_lon, point_lon,
point_hae, point_hae,
}) })
} }
} }
impl DigitalPointerPayload { impl DigitalPointerPayload {
pub fn to_cot(&self) -> CursorOverTime { pub fn to_cot(&self) -> CursorOverTime {
CursorOverTime { CursorOverTime {
uuid: Some(format!("{}{}", self.link_uid.clone(), ".SPI1")), uuid: Some(format!("{}{}", self.link_uid.clone(), ".SPI1")),
r#type: Some("b-m-p-s-p-i".to_string()), r#type: Some("b-m-p-s-p-i".to_string()),
point_lat: self.point_lat, point_lat: self.point_lat,
point_lon: self.point_lon, point_lon: self.point_lon,
point_hae: self.point_hae, point_hae: self.point_hae,
point_ce: None, point_ce: None,
point_le: None, point_le: None,
contact_callsign: self.contact_callsign.clone(), contact_callsign: self.contact_callsign.clone(),
group_name: None, group_name: None,
group_role: None, group_role: None,
track_course: None, track_course: None,
track_speed: None, track_speed: None,
link_uid: Some(self.link_uid.clone()), link_uid: Some(self.link_uid.clone()),
remarker: None, remarker: None,
} }
} }
} }

104
src/cot/eud.rs
View File

@@ -1,62 +1,62 @@
use arma_rs::{FromArma, FromArmaError};
use super::cot::CursorOverTime; use super::cot::CursorOverTime;
use arma_rs::{FromArma, FromArmaError};
pub struct EudCoTPayload { pub struct EudCoTPayload {
pub uuid: String, pub uuid: String,
pub point_lat: f64, pub point_lat: f64,
pub point_lon: f64, pub point_lon: f64,
pub point_hae: f32, pub point_hae: f32,
pub contact_callsign: String, pub contact_callsign: String,
pub group_name: String, pub group_name: String,
pub group_role: String, pub group_role: String,
pub track_course: i32, pub track_course: i32,
pub track_speed: f32, pub track_speed: f32,
} }
impl FromArma for EudCoTPayload { impl FromArma for EudCoTPayload {
fn from_arma(data: String) -> Result<EudCoTPayload, FromArmaError> { fn from_arma(data: String) -> Result<EudCoTPayload, FromArmaError> {
let ( let (
uuid, uuid,
point_lat, point_lat,
point_lon, point_lon,
point_hae, point_hae,
contact_callsign, contact_callsign,
group_name, group_name,
group_role, group_role,
track_course, track_course,
track_speed, track_speed,
) = <(String, f64, f64, f32, String, String, String, i32, f32)>::from_arma(data)?; ) = <(String, f64, f64, f32, String, String, String, i32, f32)>::from_arma(data)?;
Ok(Self { Ok(Self {
uuid, uuid,
point_lat, point_lat,
point_lon, point_lon,
point_hae, point_hae,
contact_callsign, contact_callsign,
group_name, group_name,
group_role, group_role,
track_course, track_course,
track_speed, track_speed,
}) })
} }
} }
impl EudCoTPayload { impl EudCoTPayload {
pub fn to_cot(&self) -> CursorOverTime { pub fn to_cot(&self) -> CursorOverTime {
CursorOverTime { CursorOverTime {
uuid: Some(self.uuid.clone()), uuid: Some(self.uuid.clone()),
r#type: None, r#type: None,
point_lat: self.point_lat, point_lat: self.point_lat,
point_lon: self.point_lon, point_lon: self.point_lon,
point_hae: self.point_hae, point_hae: self.point_hae,
point_ce: None, point_ce: None,
point_le: None, point_le: None,
contact_callsign: self.contact_callsign.clone(), contact_callsign: self.contact_callsign.clone(),
group_name: Some(self.group_name.clone()), group_name: Some(self.group_name.clone()),
group_role: Some(self.group_role.clone()), group_role: Some(self.group_role.clone()),
track_course: Some(self.track_course), track_course: Some(self.track_course),
track_speed: Some(self.track_speed), track_speed: Some(self.track_speed),
link_uid: None, link_uid: None,
remarker: None, remarker: None,
} }
} }
} }

82
src/cot/gps.rs
View File

@@ -1,5 +1,5 @@
use arma_rs::{FromArma, FromArmaError};
use super::cot::CursorOverTime; use super::cot::CursorOverTime;
use arma_rs::{FromArma, FromArmaError};
pub struct ExternalPositionPayload { pub struct ExternalPositionPayload {
pub uuid: String, pub uuid: String,
@@ -13,47 +13,47 @@ pub struct ExternalPositionPayload {
} }
impl FromArma for ExternalPositionPayload { impl FromArma for ExternalPositionPayload {
fn from_arma(data: String) -> Result<ExternalPositionPayload, FromArmaError> { fn from_arma(data: String) -> Result<ExternalPositionPayload, FromArmaError> {
let ( let (
uuid, uuid,
point_lat, point_lat,
point_lon, point_lon,
point_hae, point_hae,
contact_callsign, contact_callsign,
track_course, track_course,
track_speed, track_speed,
remarker, remarker,
) = <(String, f64, f64, f32, String, i32, f32, String)>::from_arma(data)?; ) = <(String, f64, f64, f32, String, i32, f32, String)>::from_arma(data)?;
Ok(Self { Ok(Self {
uuid, uuid,
point_lat, point_lat,
point_lon, point_lon,
point_hae, point_hae,
contact_callsign, contact_callsign,
track_course, track_course,
track_speed, track_speed,
remarker, remarker,
}) })
} }
} }
impl ExternalPositionPayload { impl ExternalPositionPayload {
pub fn to_cot(&self) -> CursorOverTime { pub fn to_cot(&self) -> CursorOverTime {
CursorOverTime { CursorOverTime {
uuid: Some(self.uuid.clone()), uuid: Some(self.uuid.clone()),
r#type: None, r#type: None,
point_lat: self.point_lat, point_lat: self.point_lat,
point_lon: self.point_lon, point_lon: self.point_lon,
point_hae: self.point_hae, point_hae: self.point_hae,
point_ce: None, point_ce: None,
point_le: None, point_le: None,
contact_callsign: self.contact_callsign.clone(), contact_callsign: self.contact_callsign.clone(),
group_name: None, group_name: None,
group_role: None, group_role: None,
track_course: Some(self.track_course), track_course: Some(self.track_course),
track_speed: Some(self.track_speed), track_speed: Some(self.track_speed),
link_uid: None, link_uid: None,
remarker: Some(self.remarker.clone()), remarker: Some(self.remarker.clone()),
} }
} }
} }

18
src/cot/message.rs
View File

@@ -1,5 +1,5 @@
use arma_rs::{FromArma, FromArmaError}; use arma_rs::{FromArma, FromArmaError};
use chrono::{Utc, Duration, SecondsFormat}; use chrono::{Duration, SecondsFormat, Utc};
use uuid::Uuid; use uuid::Uuid;
pub struct MessagePayload { pub struct MessagePayload {
@@ -14,8 +14,7 @@ pub struct MessagePayload {
impl FromArma for MessagePayload { impl FromArma for MessagePayload {
fn from_arma(data: String) -> Result<Self, FromArmaError> { fn from_arma(data: String) -> Result<Self, FromArmaError> {
let (sender_callsign, chatroom, message_text, let (sender_callsign, chatroom, message_text, point_lat, point_lon, point_hae, sender_uid) =
point_lat, point_lon, point_hae, sender_uid) =
<(String, String, String, f64, f64, f32, String)>::from_arma(data)?; <(String, String, String, f64, f64, f32, String)>::from_arma(data)?;
Ok(Self { Ok(Self {
@@ -55,8 +54,8 @@ impl MessageCot {
pub fn to_xml(&self) -> String { pub fn to_xml(&self) -> String {
let created_time = Utc::now().to_rfc3339_opts(SecondsFormat::Millis, true); let created_time = Utc::now().to_rfc3339_opts(SecondsFormat::Millis, true);
let stale_time = (Utc::now() + Duration::days(1)) let stale_time =
.to_rfc3339_opts(SecondsFormat::Millis, true); (Utc::now() + Duration::days(1)).to_rfc3339_opts(SecondsFormat::Millis, true);
// MESSAGE ID (random UUID) // MESSAGE ID (random UUID)
let message_uuid = Uuid::new_v4().to_string(); let message_uuid = Uuid::new_v4().to_string();
@@ -98,10 +97,7 @@ impl MessageCot {
format!( format!(
"<__chat parent=\"RootContactGroup\" groupOwner=\"false\" \ "<__chat parent=\"RootContactGroup\" groupOwner=\"false\" \
messageId=\"{}\" chatroom=\"{}\" id=\"{}\" senderCallsign=\"{}\">", messageId=\"{}\" chatroom=\"{}\" id=\"{}\" senderCallsign=\"{}\">",
message_uuid, message_uuid, self.chatroom, self.chatroom, self.sender_callsign,
self.chatroom,
self.chatroom,
self.sender_callsign,
) )
.as_str(), .as_str(),
); );
@@ -109,9 +105,7 @@ impl MessageCot {
xml.push_str( xml.push_str(
format!( format!(
"<chatgrp uid0=\"{}\" uid1=\"{}\" id=\"{}\" />", "<chatgrp uid0=\"{}\" uid1=\"{}\" id=\"{}\" />",
self.sender_uid, self.sender_uid, self.chatroom, self.chatroom
self.chatroom,
self.chatroom
) )
.as_str(), .as_str(),
); );

2
src/cot/mod.rs
View File

@@ -1,6 +1,6 @@
pub mod draws;
pub mod cot; pub mod cot;
pub mod digital_pointer; pub mod digital_pointer;
pub mod draws;
pub mod eud; pub mod eud;
pub mod gps; pub mod gps;
pub mod message; pub mod message;

5
src/structs.rs
View File

@@ -10,9 +10,6 @@ pub struct LogPayload {
impl FromArma for LogPayload { impl FromArma for LogPayload {
fn from_arma(data: String) -> Result<LogPayload, FromArmaError> { fn from_arma(data: String) -> Result<LogPayload, FromArmaError> {
let (status, message) = <(String, String)>::from_arma(data)?; let (status, message) = <(String, String)>::from_arma(data)?;
Ok(Self { Ok(Self { status, message })
status,
message
})
} }
} }

15
src/tcp/cot.rs
View File

@@ -9,21 +9,30 @@ pub fn send_eud_cot(ctx: Context, cursor_over_time: cot::eud::EudCoTPayload) ->
"Sending End User Device Cursor Over Time to TCP server" "Sending End User Device Cursor Over Time to TCP server"
} }
pub fn send_marker_cot(ctx: Context, cursor_over_time: cot::nato::MarkerCoTPayload) -> &'static str { pub fn send_marker_cot(
ctx: Context,
cursor_over_time: cot::nato::MarkerCoTPayload,
) -> &'static str {
let payload = cursor_over_time.to_cot().convert_to_xml(); let payload = cursor_over_time.to_cot().convert_to_xml();
send_payload(ctx, payload); send_payload(ctx, payload);
"Sending Marker Cursor Over Time to TCP server" "Sending Marker Cursor Over Time to TCP server"
} }
pub fn send_digital_pointer_cot(ctx: Context, cursor_over_time: cot::digital_pointer::DigitalPointerPayload) -> &'static str { pub fn send_digital_pointer_cot(
ctx: Context,
cursor_over_time: cot::digital_pointer::DigitalPointerPayload,
) -> &'static str {
let payload = cursor_over_time.to_cot().convert_to_xml(); let payload = cursor_over_time.to_cot().convert_to_xml();
send_payload(ctx, payload); send_payload(ctx, payload);
"Sending Digital Pointer Cursor Over Time to TCP server" "Sending Digital Pointer Cursor Over Time to TCP server"
} }
pub fn send_message_cot(ctx: Context, message_payload: cot::message::MessagePayload) -> &'static str { pub fn send_message_cot(
ctx: Context,
message_payload: cot::message::MessagePayload,
) -> &'static str {
let message_cot = cot::message::MessageCot::from_payload(message_payload); let message_cot = cot::message::MessageCot::from_payload(message_payload);
let payload = message_cot.to_xml(); let payload = message_cot.to_xml();
send_payload(ctx, payload); send_payload(ctx, payload);

21
src/tcp/draw.rs
View File

@@ -2,7 +2,10 @@ use arma_rs::Context;
use crate::{cot, tcp::send_payload}; use crate::{cot, tcp::send_payload};
pub fn send_circle_cot(ctx: Context, circle_payload: cot::draws::circle::CircleCoTPayload) -> &'static str { pub fn send_circle_cot(
ctx: Context,
circle_payload: cot::draws::circle::CircleCoTPayload,
) -> &'static str {
let shape_circle_cot = circle_payload.to_cot(); let shape_circle_cot = circle_payload.to_cot();
let now = chrono::Utc::now().to_rfc3339_opts(chrono::SecondsFormat::Millis, true); let now = chrono::Utc::now().to_rfc3339_opts(chrono::SecondsFormat::Millis, true);
let stale = (chrono::Utc::now() + chrono::Duration::days(1)) let stale = (chrono::Utc::now() + chrono::Duration::days(1))
@@ -14,21 +17,21 @@ pub fn send_circle_cot(ctx: Context, circle_payload: cot::draws::circle::CircleC
} }
pub fn send_ellipse_cot(ctx: Context) -> &'static str { pub fn send_ellipse_cot(ctx: Context) -> &'static str {
let _ = ctx; let _ = ctx;
"Not implemented: send_ellipse_cot" "Not implemented: send_ellipse_cot"
} }
pub fn send_rectangle_cot(ctx: Context) -> &'static str { pub fn send_rectangle_cot(ctx: Context) -> &'static str {
let _ = ctx; let _ = ctx;
"Not implemented: send_ellipse_cot" "Not implemented: send_ellipse_cot"
} }
pub fn send_freedraw_cot(ctx: Context) -> &'static str { pub fn send_freedraw_cot(ctx: Context) -> &'static str {
let _ = ctx; let _ = ctx;
"Not implemented: send_ellipse_cot" "Not implemented: send_ellipse_cot"
} }
pub fn send_vectordraw_cot(ctx: Context) -> &'static str { pub fn send_vectordraw_cot(ctx: Context) -> &'static str {
let _ = ctx; let _ = ctx;
"Not implemented: send_ellipse_cot" "Not implemented: send_ellipse_cot"
} }

34
src/tests.rs
View File

@@ -1,25 +1,25 @@
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use crate::init; use crate::init;
use uuid::Uuid; use std::vec;
use std::vec; use uuid::Uuid;
#[test] #[test]
fn uuid_output_is_uuid4_identifier() { fn uuid_output_is_uuid4_identifier() {
let extension = init().testing(); let extension = init().testing();
let (output, _) = extension.call("uuid", None); let (output, _) = extension.call("uuid", None);
let validation = Uuid::parse_str(&output); let validation = Uuid::parse_str(&output);
assert!(validation.is_ok()) assert!(validation.is_ok())
} }
#[test] #[test]
fn uuid_output_throws_if_passed_args() { fn uuid_output_throws_if_passed_args() {
let extension = init().testing(); let extension = init().testing();
let args: Vec<String> = vec![1.to_string(),2.to_string()]; let args: Vec<String> = vec![1.to_string(), 2.to_string()];
let (output, _) = extension.call("uuid", Some(args)); let (output, _) = extension.call("uuid", Some(args));
assert_eq!(output,"") assert_eq!(output, "")
} }
} }

169
src/udp_socket.rs
View File

@@ -9,116 +9,119 @@ use std::thread;
use crate::cot; use crate::cot;
pub enum UdpCommand { pub enum UdpCommand {
SendMessage(String, Context), SendMessage(String, Context),
Stop, Stop,
} }
pub struct UdpClient { pub struct UdpClient {
pub(crate) tx: Sender<UdpCommand>, pub(crate) tx: Sender<UdpCommand>,
} }
impl UdpClient { impl UdpClient {
pub fn start(&self, address: String, rx: Receiver<UdpCommand>, ctx: Context) { pub fn start(&self, address: String, rx: Receiver<UdpCommand>, ctx: Context) {
if let Some(ref client) = *UDP_CLIENT.lock().unwrap() { if let Some(ref client) = *UDP_CLIENT.lock().unwrap() {
client.stop(); client.stop();
}
thread::spawn(move || {
let socket = match UdpSocket::bind("0.0.0.0:0") {
Ok(s) => s,
Err(e) => {
let _ = ctx.callback_data(
"UDP SOCKET ERROR",
"Failed to bind UDP socket",
e.to_string(),
);
info!("Failed to bind UDP socket: {}", e);
return;
}
};
let _ = ctx.callback_data("UDP SOCKET", "EUD Connected", address.clone());
let mut running = true;
while running {
match rx.recv() {
Ok(UdpCommand::SendMessage(message, context)) => {
if let Err(e) = socket.send_to(message.as_bytes(), &address) {
info!("Failed to send UDP message: {}", e);
let _ = context.callback_data(
"UDP SOCKET ERROR",
"Failed to send UDP message",
e.to_string(),
);
}
}
Ok(UdpCommand::Stop) => {
running = false;
info!("Stopping UDP client.");
}
Err(error) => {
info!("Error receiving command: {}", error.to_string());
}
}
}
});
} }
thread::spawn(move || { pub fn send_payload(&self, context: Context, payload: String) {
let socket = match UdpSocket::bind("0.0.0.0:0") { let tx = self.tx.clone();
Ok(s) => s, thread::spawn(move || {
Err(e) => { tx.send(UdpCommand::SendMessage(payload, context)).unwrap();
let _ = ctx.callback_data( });
"UDP SOCKET ERROR", }
"Failed to bind UDP socket",
e.to_string(),
);
info!("Failed to bind UDP socket: {}", e);
return;
}
};
let _ = ctx.callback_data("UDP SOCKET", "EUD Connected", address.clone()); pub fn stop(&self) {
let tx = self.tx.clone();
let mut running = true; thread::spawn(move || {
while running { tx.send(UdpCommand::Stop).unwrap();
match rx.recv() { });
Ok(UdpCommand::SendMessage(message, context)) => { }
if let Err(e) = socket.send_to(message.as_bytes(), &address) {
info!("Failed to send UDP message: {}", e);
let _ = context.callback_data(
"UDP SOCKET ERROR",
"Failed to send UDP message",
e.to_string(),
);
}
}
Ok(UdpCommand::Stop) => {
running = false;
info!("Stopping UDP client.");
}
Err(error) => {
info!("Error receiving command: {}", error.to_string());
}
}
}
});
}
pub fn send_payload(&self, context: Context, payload: String) {
let tx = self.tx.clone();
thread::spawn(move || {
tx.send(UdpCommand::SendMessage(payload, context)).unwrap();
});
}
pub fn stop(&self) {
let tx = self.tx.clone();
thread::spawn(move || {
tx.send(UdpCommand::Stop).unwrap();
});
}
} }
lazy_static! { lazy_static! {
static ref UDP_CLIENT: Arc<Mutex<Option<UdpClient>>> = Arc::new(Mutex::new(None)); static ref UDP_CLIENT: Arc<Mutex<Option<UdpClient>>> = Arc::new(Mutex::new(None));
} }
pub fn start(ctx: Context, address: String) -> &'static str { pub fn start(ctx: Context, address: String) -> &'static str {
let (tx, rx): (Sender<UdpCommand>, Receiver<UdpCommand>) = mpsc::channel(); let (tx, rx): (Sender<UdpCommand>, Receiver<UdpCommand>) = mpsc::channel();
let client = UdpClient { tx }; let client = UdpClient { tx };
client.start(address, rx, ctx); client.start(address, rx, ctx);
let mut client_guard = UDP_CLIENT.lock().unwrap(); let mut client_guard = UDP_CLIENT.lock().unwrap();
*client_guard = Some(client); *client_guard = Some(client);
"Starting UDP Client" "Starting UDP Client"
} }
pub fn send_payload(ctx: Context, payload: String) -> &'static str { pub fn send_payload(ctx: Context, payload: String) -> &'static str {
if let Some(ref client) = *UDP_CLIENT.lock().unwrap() { if let Some(ref client) = *UDP_CLIENT.lock().unwrap() {
client.send_payload(ctx, payload); client.send_payload(ctx, payload);
} else { } else {
let _ = ctx.callback_null("UDP SOCKET ERROR", "UDP Socket is not running"); let _ = ctx.callback_null("UDP SOCKET ERROR", "UDP Socket is not running");
} }
"Sending payload to UDP server" "Sending payload to UDP server"
} }
pub fn send_gps_cot(ctx: Context, cursor_over_time: cot::gps::ExternalPositionPayload) -> &'static str { pub fn send_gps_cot(
let payload = cursor_over_time.to_cot().convert_to_xml(); ctx: Context,
send_payload(ctx, payload); cursor_over_time: cot::gps::ExternalPositionPayload,
) -> &'static str {
let payload = cursor_over_time.to_cot().convert_to_xml();
send_payload(ctx, payload);
"Sending GPS Cursor Over Time to UDP server" "Sending GPS Cursor Over Time to UDP server"
} }
pub fn stop(ctx: Context) -> &'static str { pub fn stop(ctx: Context) -> &'static str {
if let Some(ref client) = *UDP_CLIENT.lock().unwrap() { if let Some(ref client) = *UDP_CLIENT.lock().unwrap() {
client.stop(); client.stop();
let _ = ctx.callback_null("UDP SOCKET", "EUD Disconnected"); let _ = ctx.callback_null("UDP SOCKET", "EUD Disconnected");
} else { } else {
let _ = ctx.callback_null("UDP SOCKET ERROR", "UDP Socket is not running"); let _ = ctx.callback_null("UDP SOCKET ERROR", "UDP Socket is not running");
} }
"Stopping UDP Client" "Stopping UDP Client"
} }

34
src/utils/address.rs
View File

@@ -1,23 +1,23 @@
use std::net::{IpAddr, UdpSocket}; use std::net::{IpAddr, UdpSocket};
pub fn get_local_address() -> String { pub fn get_local_address() -> String {
fn get_local_ip() -> Result<IpAddr, String> { fn get_local_ip() -> Result<IpAddr, String> {
let socket = UdpSocket::bind("0.0.0.0:0").map_err(|e| e.to_string())?; let socket = UdpSocket::bind("0.0.0.0:0").map_err(|e| e.to_string())?;
socket.connect("8.8.8.8:80").map_err(|e| e.to_string())?; socket.connect("8.8.8.8:80").map_err(|e| e.to_string())?;
socket socket
.local_addr() .local_addr()
.map(|addr| addr.ip()) .map(|addr| addr.ip())
.map_err(|e| e.to_string()) .map_err(|e| e.to_string())
} }
let parsed_data = get_local_ip(); let parsed_data = get_local_ip();
match parsed_data { match parsed_data {
Ok(ip) => { Ok(ip) => {
return format!("ws://{}:4152", ip.to_string()); return format!("ws://{}:4152", ip.to_string());
} }
Err(_) => { Err(_) => {
return "not provided".to_string(); return "not provided".to_string();
} }
} }
} }

14
src/utils/log.rs
View File

@@ -2,11 +2,11 @@ use crate::structs::LogPayload;
use log::{error, info, warn}; use log::{error, info, warn};
pub fn log_info(data: LogPayload) -> String { pub fn log_info(data: LogPayload) -> String {
match data.status.as_str() { match data.status.as_str() {
"info" => info!("{}", data.message), "info" => info!("{}", data.message),
"warn" => warn!("{}", data.message), "warn" => warn!("{}", data.message),
"error" => error!("{}", data.message), "error" => error!("{}", data.message),
_ => error!("{}", "Wrong log call"), _ => error!("{}", "Wrong log call"),
} }
"logged".to_string() "logged".to_string()
} }

2
src/utils/mod.rs
View File

@@ -1,3 +1,3 @@
pub mod uuid;
pub mod address; pub mod address;
pub mod log; pub mod log;
pub mod uuid;

6
src/utils/uuid.rs
View File

@@ -1,7 +1,7 @@
pub fn get_uuid() -> String { pub fn get_uuid() -> String {
use uuid::Uuid; use uuid::Uuid;
let id = Uuid::new_v4().to_string(); let id = Uuid::new_v4().to_string();
return id; return id;
} }

32
src/video_stream.rs
View File

@@ -16,7 +16,13 @@ lazy_static! {
#[cfg(target_os = "windows")] #[cfg(target_os = "windows")]
const CREATE_NO_WINDOW: u32 = 0x08000000; const CREATE_NO_WINDOW: u32 = 0x08000000;
fn build_rtsp_url(address: &str, port: &str, stream_path: &str, username: &str, password: &str) -> String { fn build_rtsp_url(
address: &str,
port: &str,
stream_path: &str,
username: &str,
password: &str,
) -> String {
if username.is_empty() || password.is_empty() { if username.is_empty() || password.is_empty() {
format!("rtsp://{}:{}/{}", address, port, stream_path) format!("rtsp://{}:{}/{}", address, port, stream_path)
} else { } else {
@@ -28,20 +34,22 @@ fn build_rtsp_url(address: &str, port: &str, stream_path: &str, username: &str,
} }
#[cfg(any(target_os = "windows", target_os = "linux"))] #[cfg(any(target_os = "windows", target_os = "linux"))]
fn spawn_ffmpeg( fn spawn_ffmpeg(rtsp_url: String, stop_rx: Receiver<()>, status_tx: Sender<Result<(), String>>) {
rtsp_url: String,
stop_rx: Receiver<()>,
status_tx: Sender<Result<(), String>>,
) {
thread::spawn(move || { thread::spawn(move || {
let mut cmd = Command::new("ffmpeg"); let mut cmd = Command::new("ffmpeg");
cmd.args(&[ cmd.args(&[
"-f","x11grab", "-f",
"-framerate","30", "x11grab",
"-video_size","1920x1080", "-framerate",
"-i" ,":0", "30",
"-f","rtsp", "-video_size",
"-rtsp_transport","tcp", "1920x1080",
"-i",
":0",
"-f",
"rtsp",
"-rtsp_transport",
"tcp",
&rtsp_url, &rtsp_url,
]); ]);