Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Fix: src: device: manager: Panic when call unimplemented options #6

Merged
merged 2 commits into from
Jul 19, 2024
Merged

Fix: src: device: manager: Panic when call unimplemented options #6

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
1d84f90
src: device: manager: Fix panic when call unimplemented options
RaulTrombin Jul 19, 2024
9261d24
src: device: {manager, device}: Enchancement: Rewrite the logs to kee…
RaulTrombin Jul 19, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
14 changes: 5 additions & 9 deletions src/device/devices.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -19,7 +19,7 @@ impl DeviceActor {
match request.request.clone() {
PingRequest::Ping1D(device_request) => match &self.device_type {
DeviceType::Ping1D(device) => {
trace!("Handling Ping1D request: {:?}", device_request);
trace!("Handling Ping1D request: {device_request:?}");
let answer = device.handle(device_request).await;
let _ = request.respond_to.send(answer);
}
Expand All @@ -36,7 +36,7 @@ impl DeviceActor {
},
PingRequest::Ping360(device_request) => match &self.device_type {
DeviceType::Ping360(device) => {
trace!("Handling Ping360 request: {:?}", device_request);
trace!("Handling Ping360 request: {device_request:?}");
let answer = device.handle(device_request).await;
let _ = request.respond_to.send(answer);
}
Expand All @@ -53,7 +53,7 @@ impl DeviceActor {
},
PingRequest::Common(device_request) => match &self.device_type {
DeviceType::Common(device) => {
trace!("Handling Common request: {:?}", device_request);
trace!("Handling Common request: {device_request:?}");
let answer = device.handle(device_request).await;
let _ = request.respond_to.send(answer);
}
Expand Down Expand Up @@ -203,10 +203,7 @@ impl DeviceActorHandler {
};

if let Err(err) = self.sender.send(device_request).await {
error!(
"DeviceManagerHandler: Failed to reach Device, details: {:?}",
err
);
error!("DeviceManagerHandler: Failed to reach Device, details: {err:?}");
return Err(DeviceError::TokioError(err.to_string()));
}

Expand All @@ -217,8 +214,7 @@ impl DeviceActorHandler {
Ok(ans) => ans,
Err(err) => {
error!(
"DeviceManagerHandler: Failed to receive message from Device, details: {:?}",
err
"DeviceManagerHandler: Failed to receive message from Device, details: {err:?}"
);
Err(err)
}
Expand Down
76 changes: 29 additions & 47 deletions src/device/manager.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,7 +6,7 @@ use std::{
};
use tokio::sync::{mpsc, oneshot};
use tokio_serial::{SerialPort, SerialPortBuilderExt, SerialStream};
use tracing::{error, info, trace};
use tracing::{error, info, trace, warn};
use udp_stream::UdpStream;
use uuid::Uuid;

Expand Down Expand Up @@ -109,6 +109,7 @@ pub enum ManagerError {
DeviceSourceError(String),
NoDevices,
TokioMpsc(String),
NotImplemented(Request),
}

#[derive(Debug, Serialize, Deserialize, Clone)]
Expand Down Expand Up @@ -142,39 +143,40 @@ pub struct DeviceRequestStruct {

impl DeviceManager {
async fn handle_message(&mut self, actor_request: ManagerActorRequest) {
trace!(
"DeviceManager: Received a request, details: {:?}",
actor_request
);
trace!("DeviceManager: Received a request, details: {actor_request:?}");
match actor_request.request {
Request::Create(request) => {
let result = self.create(request.source, request.device_selection).await;
if let Err(e) = actor_request.respond_to.send(result) {
error!("DeviceManager: Failed to return Create response: {:?}", e);
error!("DeviceManager: Failed to return Create response: {e:?}");
}
}
Request::Delete(uuid) => {
let result = self.delete(uuid).await;
if let Err(e) = actor_request.respond_to.send(result) {
error!("DeviceManager: Failed to return Delete response: {:?}", e);
error!("DeviceManager: Failed to return Delete response: {e:?}");
}
}
Request::List => {
let result = self.list().await;
if let Err(e) = actor_request.respond_to.send(result) {
error!("DeviceManager: Failed to return List response: {:?}", e);
error!("DeviceManager: Failed to return List response: {e:?}");
}
}
Request::GetDeviceHandler(id) => {
let answer = self.get_device_handler(id).await;
if let Err(e) = actor_request.respond_to.send(answer) {
error!(
"DeviceManager: Failed to return GetDeviceHandler response: {:?}",
e
);
error!("DeviceManager: Failed to return GetDeviceHandler response: {e:?}");
}
}
_ => {
if let Err(e) = actor_request
.respond_to
.send(Err(ManagerError::NotImplemented(actor_request.request)))
{
warn!("DeviceManager: Failed to return response: {e:?}");
}
}
_ => todo!(), // Unreachable, DeviceManagerHandler uses GetDeviceHandler and forwards the requests.
}
}

Expand Down Expand Up @@ -206,7 +208,7 @@ impl DeviceManager {
break;
}
if device_entry.actor.is_finished() {
info!("Device stopped, device id: {:?}", device);
info!("Device stopped, device id: {device:?}");
device_entry.status = DeviceStatus::Stopped;
}
}
Expand All @@ -224,7 +226,7 @@ impl DeviceManager {
let hash = Uuid::from_u128(hasher.finish().into());

if self.device.contains_key(&hash) {
trace!("Device creation error: Device already exist for provided SourceSelection, details: {:?}", source);
trace!("Device creation error: Device already exist for provided SourceSelection, details: {source:?}");
return Err(ManagerError::DeviceAlreadyExist(hash));
}

Expand Down Expand Up @@ -299,8 +301,7 @@ impl DeviceManager {
},
Err(err) => {
error!(
"Device creation error: Can't auto upgrade the DeviceType, details: {:?}",
err
"Device creation error: Can't auto upgrade the DeviceType, details: {err:?}"
);
return Err(ManagerError::DeviceError(err));
}
Expand Down Expand Up @@ -349,21 +350,15 @@ impl DeviceManager {
Ok(Answer::DeviceInfo(vec![device.info()]))
}
None => {
error!(
"Device delete id {:?} : Error, device doesn't exist",
device_id
);
error!("Device delete id {device_id:?} : Error, device doesn't exist");
Err(ManagerError::DeviceNotExist(device_id))
}
}
}

pub async fn get_device_handler(&self, device_id: Uuid) -> Result<Answer, ManagerError> {
if self.device.contains_key(&device_id) {
trace!(
"Getting device handler for device: {:?} : Success",
device_id
);
trace!("Getting device handler for device: {device_id:?} : Success");

if self.device.get(&device_id).unwrap().status == DeviceStatus::Running {
let handler: DeviceActorHandler =
Expand All @@ -372,10 +367,7 @@ impl DeviceManager {
};
return Err(ManagerError::DeviceIsStopped(device_id));
}
error!(
"Getting device handler for device: {:?} : Error, device doesn't exist",
device_id
);
error!("Getting device handler for device: {device_id:?} : Error, device doesn't exist");
Err(ManagerError::DeviceNotExist(device_id))
}
}
Expand All @@ -387,10 +379,7 @@ impl ManagerActorHandler {
match &request {
// Devices requests are forwarded directly to device and let manager handle other incoming request.
Request::Ping(request) => {
trace!(
"Handling Ping request: {:?}: Forwarding request to device handler",
request
);
trace!("Handling Ping request: {request:?}: Forwarding request to device handler");
let get_handler_target = request.target;
let handler_request = Request::GetDeviceHandler(get_handler_target);
let manager_request = ManagerActorRequest {
Expand All @@ -407,31 +396,28 @@ impl ManagerActorHandler {
{
Ok(ans) => ans,
Err(err) => {
error!("DeviceManagerHandler: Failed to receive handler from Manager, details: {:?}", err);
error!("DeviceManagerHandler: Failed to receive handler from Manager, details: {err:?}");
return Err(err);
}
};

match result? {
Answer::InnerDeviceHandler(handler) => {
trace!(
"Handling Ping request: {:?}: Successfully received the handler",
request
"Handling Ping request: {request:?}: Successfully received the handler"
);
let result = handler.send(request.request.clone()).await;
match result {
Ok(result) => {
info!("Handling Ping request: {:?}: Success", request);
info!("Handling Ping request: {request:?}: Success");
Ok(Answer::Ping(PingAnswer {
answer: Ok(result),
device_id: request.target,
}))
}
Err(err) => {
error!(
"Handling Ping request: {:?}: Error ocurred on device: {:?}",
request, err
);
"Handling Ping request: {request:?}: Error ocurred on device: {err:?}" );
Err(ManagerError::DeviceError(err))
}
}
Expand All @@ -440,10 +426,7 @@ impl ManagerActorHandler {
}
}
_ => {
trace!(
"Handling DeviceManager request: {:?}: Forwarding request.",
request
);
trace!("Handling DeviceManager request: {request:?}: Forwarding request.");
let device_request = ManagerActorRequest {
request: request.clone(),
respond_to: result_sender,
Expand All @@ -459,13 +442,12 @@ impl ManagerActorHandler {
.map_err(|err| ManagerError::TokioMpsc(err.to_string()))?
{
Ok(ans) => {
info!("Handling DeviceManager request: {:?}: Success", request);
info!("Handling DeviceManager request: {request:?}: Success");
Ok(ans)
}
Err(err) => {
error!(
"Handling DeviceManager request: {:?}: Error ocurred on manager: {:?}",
request, err
"Handling DeviceManager request: {request:?}: Error ocurred on manager: {err:?}",
);
Err(err)
}
Expand Down