Replace expect usage with Result

emgauwa-controller/src/main.rs

@@ -1,6 +1,6 @@
 use emgauwa_lib::constants::WEBSOCKET_RETRY_TIMEOUT;
 use emgauwa_lib::db::{DbController, DbJunctionRelaySchedule, DbRelay, DbSchedule};
-use emgauwa_lib::errors::DatabaseError;
+use emgauwa_lib::errors::{DatabaseError, EmgauwaError};
 use emgauwa_lib::models::{Controller, FromDbModel};
 use emgauwa_lib::types::{ControllerUid, ControllerWsAction};
 use emgauwa_lib::{db, utils};
@@ -23,7 +23,7 @@ mod settings;
 async fn create_this_controller(
 	conn: &mut PoolConnection<Sqlite>,
 	settings: &Settings,
-) -> DbController {
+) -> Result<DbController, EmgauwaError> {
 	DbController::create(
 		conn,
 		&ControllerUid::default(),
@@ -31,18 +31,20 @@ async fn create_this_controller(
 		settings.relays.len() as i64,
 	)
 	.await
-	.expect("Failed to create controller")
+	.map_err(EmgauwaError::from)
 }
 
 async fn create_this_relay(
 	conn: &mut PoolConnection<Sqlite>,
 	this_controller: &DbController,
 	settings_relay: &settings::Relay,
-) -> Result<DbRelay, DatabaseError> {
+) -> Result<DbRelay, EmgauwaError> {
 	let relay = DbRelay::create(
 		conn,
 		&settings_relay.name,
-		settings_relay.number.expect("Relay number is missing"),
+		settings_relay.number.ok_or(EmgauwaError::Internal(
+			"Relay number is missing".to_string(),
+		))?,
 		this_controller,
 	)
 	.await?;
@@ -55,7 +57,7 @@ async fn create_this_relay(
 	Ok(relay)
 }
 
-async fn run_websocket(this: Controller, url: &str) {
+async fn run_websocket(this: Controller, url: &str) -> Result<(), EmgauwaError> {
 	match connect_async(url).await {
 		Ok(connection) => {
 			let (ws_stream, _) = connection;
@@ -64,11 +66,10 @@ async fn run_websocket(this: Controller, url: &str) {
 
 			let ws_action = ControllerWsAction::Register(this.clone());
 
-			let ws_action_json =
-				serde_json::to_string(&ws_action).expect("Failed to serialize action");
+			let ws_action_json = serde_json::to_string(&ws_action)?;
 			if let Err(err) = write.send(Message::text(ws_action_json)).await {
 				log::error!("Failed to register at websocket: {}", err);
-				return;
+				return Ok(());
 			}
 
 			let read_handler = read.for_each(handle_message);
@@ -81,23 +82,23 @@ async fn run_websocket(this: Controller, url: &str) {
 			log::warn!("Failed to connect to websocket: {}", err,);
 		}
 	}
+	Ok(())
 }
 
 #[tokio::main]
-async fn main() {
-	let settings = settings::init();
-	init_logging(&settings.logging.level);
+async fn main() -> Result<(), std::io::Error> {
+	let settings = settings::init()?;
+	init_logging(&settings.logging.level)?;
 
-	let pool = db::init(&settings.database).await;
-
-	let mut conn = pool
-		.acquire()
+	let pool = db::init(&settings.database)
 		.await
-		.expect("Failed to get database connection");
+		.map_err(EmgauwaError::from)?;
+
+	let mut conn = pool.acquire().await.map_err(EmgauwaError::from)?;
 
 	let db_controller = match DbController::get_all(&mut conn)
 		.await
-		.expect("Failed to get controller from database")
+		.map_err(EmgauwaError::from)?
 		.pop()
 	{
 		None => futures::executor::block_on(create_this_controller(&mut conn, &settings)),
@@ -108,25 +109,26 @@ async fn main() {
 		if DbRelay::get_by_controller_and_num(
 			&mut conn,
 			&db_controller,
-			relay.number.expect("Relay number is missing"),
+			relay.number.ok_or(EmgauwaError::Internal(
+				"Relay number is missing".to_string(),
+			))?,
 		)
 		.await
-		.expect("Failed to get relay from database")
+		.map_err(EmgauwaError::from)?
 		.is_none()
 		{
 			create_this_relay(&mut conn, &db_controller, relay)
 				.await
-				.expect("Failed to create schedule.");
+				.map_err(EmgauwaError::from)?;
 		}
 	}
 
 	let db_controller = db_controller
 		.update(&mut conn, &db_controller.name, settings.relays.len() as i64)
 		.await
-		.expect("Failed to update controller");
+		.map_err(EmgauwaError::from)?;
 
-	let this = Controller::from_db_model(&mut conn, db_controller)
-		.expect("Failed to convert database models");
+	let this = Controller::from_db_model(&mut conn, db_controller).map_err(EmgauwaError::from)?;
 
 	let url = format!(
 		"ws://{}:{}/api/v1/ws/controllers",
@@ -136,7 +138,10 @@ async fn main() {
 	tokio::spawn(run_relay_loop(settings));
 
 	loop {
-		run_websocket(this.clone(), &url).await;
+		let run_result = run_websocket(this.clone(), &url).await;
+		if let Err(err) = run_result {
+			log::error!("Error running websocket: {}", err);
+		}
 
 		log::info!(
 			"Retrying to connect in {} seconds...",

emgauwa-controller/src/settings.rs

@@ -1,3 +1,4 @@
+use emgauwa_lib::errors::EmgauwaError;
 use emgauwa_lib::{constants, utils};
 use serde_derive::Deserialize;
 
@@ -83,8 +84,8 @@ impl Default for Logging {
 	}
 }
 
-pub fn init() -> Settings {
-	let mut settings: Settings = utils::load_settings("controller", "CONTROLLER");
+pub fn init() -> Result<Settings, EmgauwaError> {
+	let mut settings: Settings = utils::load_settings("controller", "CONTROLLER")?;
 
 	for (num, relay) in settings.relays.iter_mut().enumerate() {
 		if relay.number.is_none() {
@@ -92,5 +93,5 @@ pub fn init() -> Settings {
 		}
 	}
 
-	settings
+	Ok(settings)
 }