tribufu/rust-gamedig
1
0
Fork 0
mirror of https://github.com/tribufu/rust-gamedig synced 2026-05-06 15:27:28 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

[Games] Add method to query with timeout options (#60)

Browse source
This commit is contained in:
Tom 2023-06-26 21:50:06 +00:00 • committed by GitHub
parent dd80d6309f
commit 8316dac2cc
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
2 changed files with 47 additions and 19 deletions
Download patch file Download diff file Expand all files Collapse all files

29
examples/generic.rs
View file

@ -1,13 +1,23 @@
use gamedig::{protocols::types::CommonResponse, query, GDResult, GAMES};
use gamedig::{
protocols::types::{CommonResponse, TimeoutSettings},
query_with_timeout,
GDResult,
GAMES,
};
use std::net::IpAddr;
fn generic_query(game_name: &str, addr: &IpAddr, port: Option<u16>) -> GDResult<Box<dyn CommonResponse>> {
fn generic_query(
game_name: &str,
addr: &IpAddr,
port: Option<u16>,
timeout_settings: Option<TimeoutSettings>,
) -> GDResult<Box<dyn CommonResponse>> {
let game = GAMES.get(game_name).expect("Game doesn't exist");
println!("Querying {:#?} with game {:#?}.", addr, game);
let response = query(game, addr, port)?;
let response = query_with_timeout(game, addr, port, timeout_settings)?;
println!("Response: {:#?}", response.as_json());
let common = response.as_original();
@ -26,20 +36,25 @@ fn main() {
.expect("Must provide address");
let port: Option<u16> = args.next().map(|s| s.parse().unwrap());
generic_query(&game_name, &addr, port).unwrap();
generic_query(&game_name, &addr, port, None).unwrap();
}
#[cfg(test)]
mod test {
use gamedig::GAMES;
use std::net::{IpAddr, Ipv4Addr};
use gamedig::{protocols::types::TimeoutSettings, GAMES};
use std::{
net::{IpAddr, Ipv4Addr},
time::Duration,
};
use super::generic_query;
const ADDR: IpAddr = IpAddr::V4(Ipv4Addr::LOCALHOST);
fn test_game(game_name: &str) {
assert!(generic_query(game_name, &ADDR, None).is_err());
let timeout_settings =
Some(TimeoutSettings::new(Some(Duration::from_nanos(1)), Some(Duration::from_nanos(1))).unwrap());
assert!(generic_query(game_name, &ADDR, None, timeout_settings).is_err());
}
#[test]

37
src/games/mod.rs
View file

@ -114,7 +114,7 @@ pub mod vr;
use crate::protocols::gamespy::GameSpyVersion;
use crate::protocols::quake::QuakeVersion;
use crate::protocols::types::{CommonResponse, ProprietaryProtocol};
use crate::protocols::types::{CommonResponse, ProprietaryProtocol, TimeoutSettings};
use crate::protocols::{self, Protocol};
use crate::GDResult;
use std::net::{IpAddr, SocketAddr};
@ -139,39 +139,52 @@ pub use definitions::GAMES;
/// Make a query given a game definition
pub fn query(game: &Game, address: &IpAddr, port: Option<u16>) -> GDResult<Box<dyn CommonResponse>> {
query_with_timeout(game, address, port, None)
}
/// Make a query given a game definition and timeout settings
pub fn query_with_timeout(
game: &Game,
address: &IpAddr,
port: Option<u16>,
timeout_settings: Option<TimeoutSettings>,
) -> GDResult<Box<dyn CommonResponse>> {
let socket_addr = SocketAddr::new(*address, port.unwrap_or(game.default_port));
Ok(match &game.protocol {
Protocol::Valve(steam_app) => {
protocols::valve::query(&socket_addr, steam_app.as_engine(), None, None).map(Box::new)?
protocols::valve::query(&socket_addr, steam_app.as_engine(), None, timeout_settings).map(Box::new)?
}
Protocol::Minecraft(version) => {
match version {
Some(protocols::minecraft::Server::Java) => {
protocols::minecraft::query_java(&socket_addr, None).map(Box::new)?
protocols::minecraft::query_java(&socket_addr, timeout_settings).map(Box::new)?
}
Some(protocols::minecraft::Server::Bedrock) => {
protocols::minecraft::query_bedrock(&socket_addr, None).map(Box::new)?
protocols::minecraft::query_bedrock(&socket_addr, timeout_settings).map(Box::new)?
}
Some(protocols::minecraft::Server::Legacy(group)) => {
protocols::minecraft::query_legacy_specific(*group, &socket_addr, None).map(Box::new)?
protocols::minecraft::query_legacy_specific(*group, &socket_addr, timeout_settings).map(Box::new)?
}
None => protocols::minecraft::query(&socket_addr, None).map(Box::new)?,
None => protocols::minecraft::query(&socket_addr, timeout_settings).map(Box::new)?,
}
}
Protocol::Gamespy(version) => {
match version {
GameSpyVersion::One => protocols::gamespy::one::query(&socket_addr, None).map(Box::new)?,
GameSpyVersion::Two => protocols::gamespy::two::query(&socket_addr, None).map(Box::new)?,
GameSpyVersion::Three => protocols::gamespy::three::query(&socket_addr, None).map(Box::new)?,
GameSpyVersion::One => protocols::gamespy::one::query(&socket_addr, timeout_settings).map(Box::new)?,
GameSpyVersion::Two => protocols::gamespy::two::query(&socket_addr, timeout_settings).map(Box::new)?,
GameSpyVersion::Three => {
protocols::gamespy::three::query(&socket_addr, timeout_settings).map(Box::new)?
}
}
}
Protocol::Quake(version) => {
match version {
QuakeVersion::One => protocols::quake::one::query(&socket_addr, None).map(Box::new)?,
QuakeVersion::Two => protocols::quake::two::query(&socket_addr, None).map(Box::new)?,
QuakeVersion::Three => protocols::quake::three::query(&socket_addr, None).map(Box::new)?,
QuakeVersion::One => protocols::quake::one::query(&socket_addr, timeout_settings).map(Box::new)?,
QuakeVersion::Two => protocols::quake::two::query(&socket_addr, timeout_settings).map(Box::new)?,
QuakeVersion::Three => protocols::quake::three::query(&socket_addr, timeout_settings).map(Box::new)?,
}
}
// TODO: No way to query proprietary games with timeout
Protocol::PROPRIETARY(protocol) => {
match protocol {
ProprietaryProtocol::TheShip => ts::query(address, port).map(Box::new)?,