joshuafhiggins/connect4-moderator-server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Releases 2 Activity

misc: more generic set & gets

Browse Source
This commit is contained in:
Joshua Higgins
2025-12-31 18:18:33 -05:00
Unverified
parent 1e517f9e78
commit 2b1ff2f98b
2 changed files with 66 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
src/main.rs
View File

@@ -187,39 +187,32 @@ async fn handle_connection(
error!("handle_tournament_cancel: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
} else if parts.get(1) == Some(&"WAIT") && parts.len() > 2 {
match parts[2].parse::<f64>() {
Ok(new_timeout) => {
if let Err(e) =
sd.handle_tournament_wait(addr, new_timeout).await
{
error!("handle_tournament_wait: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
}
Err(_) => {
let _ = send(&tx, "ERROR:INVALID:TOURNAMENT");
}
}
} else {
let _ = send(&tx, "ERROR:INVALID:TOURNAMENT");
}
}
"GET" => {
if parts.get(1) == Some(&"MOVE_WAIT") {
if let Err(e) = sd.handle_get_move_wait(tx.clone()).await {
error!("handle_get_move_wait: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
} else if parts.get(1) == Some(&"TOURNAMENT_STATUS") {
if let Err(e) = sd.handle_get_tournament_status(tx.clone()).await {
error!("handle_get_tournament_status: {}", e);
if let Some(data_id) = parts.get(1) {
if let Err(e) = sd.handle_get_data(tx.clone(), data_id.to_string()).await {
error!("handle_get_data: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
} else {
let _ = send(&tx, "ERROR:INVALID:GET");
}
}
"SET" => {
if parts.len() > 2 {
let data_id = parts[1].to_string();
let data_value = parts[2].to_string();
if let Err(e) = sd.handle_set_data(tx.clone(), addr, data_id, data_value).await {
error!("handle_set_data: {}", e);
let _ = send(&tx, e.to_string().as_str());
}
} else {
let _ = send(&tx, "ERROR:INVALID:SET");
}
}
_ => {
let _ = send(&tx, "ERROR:UNKNOWN");
}

107
src/server.rs
View File

@@ -604,71 +604,66 @@ impl Server {
Ok(())
}
pub async fn handle_tournament_wait(
pub async fn handle_get_data(
&self,
tx: UnboundedSender<Message>,
data_id: String,
) -> Result<(), anyhow::Error> {
let mut msg = format!("GET:{}:", data_id);
match data_id.as_str() {
"TOURNAMENT_STATUS" => {
let tournament = self.tournament.read().await.clone();
if tournament.is_some() {
msg += tournament.as_ref().unwrap().read().await.get_type().as_str();
} else {
msg += "false";
}
}
"MOVE_WAIT" => {
let wait_time = *self.waiting_timeout.read().await as f64 / 1000f64;
msg += wait_time.to_string().as_str();
}
"DEMO_MODE" => {
let demo_mode = *self.demo_mode.read().await;
msg += demo_mode.to_string().as_str();
}
&_ => return Err(anyhow::anyhow!("ERROR:INVALID:GET")),
}
let _ = send(&tx, &msg);
Ok(())
}
pub async fn handle_set_data(
&self,
tx: UnboundedSender<Message>,
addr: SocketAddr,
new_timeout: f64,
data_id: String,
data_value: String,
) -> Result<(), anyhow::Error> {
if !self.auth_check(addr).await {
return Err(anyhow::anyhow!("ERROR:INVALID:AUTH"));
}
*self.waiting_timeout.write().await = (new_timeout * 1000.0) as u64;
Ok(())
}
pub async fn handle_get_move_wait(
&self,
tx: UnboundedSender<Message>,
) -> Result<(), anyhow::Error> {
let mut msg = "GET:MOVE_WAIT:".to_string();
msg += &(*self.waiting_timeout.read().await as f64 / 1000f64).to_string();
let _ = send(&tx, &msg);
Ok(())
}
pub async fn handle_get_tournament_status(
&self,
tx: UnboundedSender<Message>,
) -> Result<(), anyhow::Error> {
let status = self.tournament.read().await.is_some();
let mut msg = "GET:TOURNAMENT_STATUS:".to_string();
if status {
msg += self.tournament.read().await.as_ref().unwrap().read().await.get_type().as_str();
} else {
msg += status.to_string().as_str();
}
let _ = send(&tx, &msg);
Ok(())
}
pub async fn handle_get_demo_mode(
&self,
tx: UnboundedSender<Message>,
) -> Result<(), anyhow::Error> {
let demo_mode = *self.demo_mode.read().await;
let mut msg = "GET:DEMO_MODE:".to_string();
msg += demo_mode.to_string().as_str();
let _ = send(&tx, &msg);
Ok(())
}
pub async fn handle_set_demo_mode(
&self,
tx: UnboundedSender<Message>,
addr: SocketAddr,
demo_mode: bool,
) -> Result<(), anyhow::Error> {
if !self.auth_check(addr).await {
return Err(anyhow::anyhow!("ERROR:INVALID:AUTH"));
match data_id.as_str() {
"DEMO_MODE" => {
let demo_mode = data_value.parse::<bool>();
if demo_mode.is_err() {
return Err(anyhow::anyhow!("ERROR:INVALID:SET"));
}
*self.demo_mode.write().await = demo_mode.unwrap();
}
"MOVE_WAIT" => {
let wait_time = data_value.parse::<f64>();
if wait_time.is_err() {
return Err(anyhow::anyhow!("ERROR:INVALID:SET"));
}
*self.waiting_timeout.write().await = (wait_time.unwrap() * 1000.0) as u64;
}
&_ => return Err(anyhow::anyhow!("ERROR:INVALID:SET")),
}
if self.tournament.read().await.is_some() {
return Err(anyhow::anyhow!("ERROR:INVALID:TOURNAMENT"));
}
*self.demo_mode.write().await = demo_mode;
let _ = send(&tx, "SET:DEMO_MODE:ACK");
let _ = send(&tx, &format!("SET:{}:ACK", data_id));
Ok(())
}