change runnerconfig to globalconfig

planetwars-server/src/lib.rs

@@ -16,8 +16,8 @@ use bb8::{Pool, PooledConnection};
 use bb8_diesel::{self, DieselConnectionManager};
 use config::ConfigError;
 use diesel::{Connection, PgConnection};
+use modules::ranking::run_ranker;
 use modules::registry::registry_service;
-use modules::{matches::MatchRunnerConfig, ranking::run_ranker};
 use serde::Deserialize;
 
 use axum::{
@@ -36,6 +36,11 @@ const SIMPLEBOT_PATH: &str = "../simplebot/simplebot.py";
 
 type ConnectionPool = bb8::Pool<DieselConnectionManager<PgConnection>>;
 
+pub struct GlobalConfig {
+    pub python_runner_image: String,
+    pub container_registry_url: String,
+}
+
 pub async fn seed_simplebot(pool: &ConnectionPool) {
     let conn = pool.get().await.expect("could not get database connection");
     // This transaction is expected to fail when simplebot already exists.
@@ -121,7 +126,7 @@ pub async fn run_app() {
     let configuration = get_config().unwrap();
     let db_pool = prepare_db(&configuration.database_url).await;
 
-    let runner_config = Arc::new(MatchRunnerConfig {
+    let runner_config = Arc::new(GlobalConfig {
         python_runner_image: "python:3.10-slim-buster".to_string(),
         container_registry_url: "localhost:9001".to_string(),
     });

planetwars-server/src/modules/bot_api.rs

@@ -20,12 +20,13 @@ use planetwars_matchrunner as runner;
 use crate::db;
 use crate::util::gen_alphanumeric;
 use crate::ConnectionPool;
+use crate::GlobalConfig;
 
-use super::matches::{MatchPlayer, MatchRunnerConfig, RunMatch};
+use super::matches::{MatchPlayer, RunMatch};
 
 pub struct BotApiServer {
     conn_pool: ConnectionPool,
-    runner_config: Arc<MatchRunnerConfig>,
+    runner_config: Arc<GlobalConfig>,
     router: PlayerRouter,
 }
 
@@ -265,7 +266,7 @@ async fn schedule_timeout(
         .resolve_request(request_id, Err(RequestError::Timeout));
 }
 
-pub async fn run_bot_api(runner_config: Arc<MatchRunnerConfig>, pool: ConnectionPool) {
+pub async fn run_bot_api(runner_config: Arc<GlobalConfig>, pool: ConnectionPool) {
     let router = PlayerRouter::new();
     let server = BotApiServer {
         router,

planetwars-server/src/modules/matches.rs

@@ -11,19 +11,13 @@ use crate::{
         matches::{MatchData, MatchResult},
     },
     util::gen_alphanumeric,
-    ConnectionPool, BOTS_DIR, MAPS_DIR, MATCHES_DIR,
+    ConnectionPool, GlobalConfig, BOTS_DIR, MAPS_DIR, MATCHES_DIR,
 };
 
-// TODO: add all paths
-pub struct MatchRunnerConfig {
-    pub python_runner_image: String,
-    pub container_registry_url: String,
-}
-
 pub struct RunMatch {
     log_file_name: String,
     players: Vec<MatchPlayer>,
-    runner_config: Arc<MatchRunnerConfig>,
+    runner_config: Arc<GlobalConfig>,
 }
 
 pub enum MatchPlayer {
@@ -37,7 +31,7 @@ pub enum MatchPlayer {
 }
 
 impl RunMatch {
-    pub fn from_players(runner_config: Arc<MatchRunnerConfig>, players: Vec<MatchPlayer>) -> Self {
+    pub fn from_players(runner_config: Arc<GlobalConfig>, players: Vec<MatchPlayer>) -> Self {
         let log_file_name = format!("{}.log", gen_alphanumeric(16));
         RunMatch {
             runner_config,
@@ -104,7 +98,7 @@ impl RunMatch {
 }
 
 pub fn bot_version_to_botspec(
-    runner_config: &Arc<MatchRunnerConfig>,
+    runner_config: &Arc<GlobalConfig>,
     bot: Option<&db::bots::Bot>,
     bot_version: &db::bots::BotVersion,
 ) -> Box<dyn BotSpec> {
@@ -127,7 +121,7 @@ pub fn bot_version_to_botspec(
 }
 
 fn python_docker_bot_spec(
-    runner_config: &Arc<MatchRunnerConfig>,
+    runner_config: &Arc<GlobalConfig>,
     code_bundle_path: &str,
 ) -> Box<dyn BotSpec> {
     let code_bundle_rel_path = PathBuf::from(BOTS_DIR).join(code_bundle_path);

planetwars-server/src/modules/ranking.rs

@@ -1,4 +1,4 @@
-use crate::{db::bots::Bot, DbPool};
+use crate::{db::bots::Bot, DbPool, GlobalConfig};
 
 use crate::db;
 use crate::modules::matches::{MatchPlayer, RunMatch};
@@ -10,11 +10,9 @@ use std::sync::Arc;
 use std::time::{Duration, Instant};
 use tokio;
 
-use super::matches::MatchRunnerConfig;
-
 const RANKER_INTERVAL: u64 = 60;
 
-pub async fn run_ranker(runner_config: Arc<MatchRunnerConfig>, db_pool: DbPool) {
+pub async fn run_ranker(config: Arc<GlobalConfig>, db_pool: DbPool) {
     // TODO: make this configurable
     // play at most one match every n seconds
     let mut interval = tokio::time::interval(Duration::from_secs(RANKER_INTERVAL));
@@ -33,16 +31,12 @@ pub async fn run_ranker(runner_config: Arc<MatchRunnerConfig>, db_pool: DbPool)
             let mut rng = &mut rand::thread_rng();
             bots.choose_multiple(&mut rng, 2).cloned().collect()
         };
-        play_ranking_match(runner_config.clone(), selected_bots, db_pool.clone()).await;
+        play_ranking_match(config.clone(), selected_bots, db_pool.clone()).await;
         recalculate_ratings(&db_conn).expect("could not recalculate ratings");
     }
 }
 
-async fn play_ranking_match(
+async fn play_ranking_match(config: Arc<GlobalConfig>, selected_bots: Vec<Bot>, db_pool: DbPool) {
-    runner_config: Arc<MatchRunnerConfig>,
-    selected_bots: Vec<Bot>,
-    db_pool: DbPool,
-) {
     let db_conn = db_pool.get().await.expect("could not get db pool");
     let mut players = Vec::new();
     for bot in &selected_bots {
@@ -55,7 +49,7 @@ async fn play_ranking_match(
         players.push(player);
     }
 
-    let (_, handle) = RunMatch::from_players(runner_config, players)
+    let (_, handle) = RunMatch::from_players(config, players)
         .run(db_pool.clone())
         .await
         .expect("failed to run match");

planetwars-server/src/routes/demo.rs

@@ -3,8 +3,9 @@ use std::sync::Arc;
 use crate::db;
 use crate::db::matches::{FullMatchData, FullMatchPlayerData};
 use crate::modules::bots::save_code_string;
-use crate::modules::matches::{MatchPlayer, MatchRunnerConfig, RunMatch};
+use crate::modules::matches::{MatchPlayer, RunMatch};
 use crate::ConnectionPool;
+use crate::GlobalConfig;
 use axum::extract::Extension;
 use axum::Json;
 use hyper::StatusCode;
@@ -32,7 +33,7 @@ pub struct SubmitBotResponse {
 pub async fn submit_bot(
     Json(params): Json<SubmitBotParams>,
     Extension(pool): Extension<ConnectionPool>,
-    Extension(runner_config): Extension<Arc<MatchRunnerConfig>>,
+    Extension(config): Extension<Arc<GlobalConfig>>,
 ) -> Result<Json<SubmitBotResponse>, StatusCode> {
     let conn = pool.get().await.expect("could not get database connection");
 
@@ -50,7 +51,7 @@ pub async fn submit_bot(
         .expect("could not save bot code");
 
     let run_match = RunMatch::from_players(
-        runner_config,
+        config,
         vec![
             MatchPlayer::BotVersion {
                 bot: None,