centralcore 1.0.2

Open-source Rust library for building Minecraft Java Edition launchers
Documentation
use std::sync::{
    atomic::{AtomicBool, AtomicUsize, Ordering},
    Arc,
};

use centralcore::{
    providers::{ProviderId, ProviderSource},
    trust::SignaturePolicy,
    CentralCore, CoreConfig,
};
use tokio::{
    io::{AsyncReadExt, AsyncWriteExt},
    net::TcpListener,
};
use url::Url;

struct MockProviderHttp {
    base: Url,
    fail_index: Arc<AtomicBool>,
    index_requests: Arc<AtomicUsize>,
    instance_requests: Arc<AtomicUsize>,
    task: tokio::task::JoinHandle<()>,
}

impl MockProviderHttp {
    async fn start(oversized: bool) -> Self {
        let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind");
        let address = listener.local_addr().expect("address");
        let fail_index = Arc::new(AtomicBool::new(false));
        let index_requests = Arc::new(AtomicUsize::new(0));
        let instance_requests = Arc::new(AtomicUsize::new(0));
        let task_fail = fail_index.clone();
        let task_index = index_requests.clone();
        let task_instance = instance_requests.clone();
        let task = tokio::spawn(async move {
            loop {
                let Ok((mut socket, _)) = listener.accept().await else {
                    break;
                };
                let fail = task_fail.clone();
                let index_count = task_index.clone();
                let instance_count = task_instance.clone();
                tokio::spawn(async move {
                    let mut request = vec![0_u8; 8192];
                    let Ok(read) = socket.read(&mut request).await else {
                        return;
                    };
                    let request = String::from_utf8_lossy(&request[..read]);
                    let path = request
                        .lines()
                        .next()
                        .and_then(|line| line.split_whitespace().nth(1))
                        .unwrap_or("/");
                    let has_index_etag = request
                        .lines()
                        .any(|line| line.eq_ignore_ascii_case("if-none-match: \"index-v1\""));
                    let (status, headers, body) = match path {
                        "/provider.json" if fail.load(Ordering::SeqCst) => {
                            index_count.fetch_add(1, Ordering::SeqCst);
                            ("500 Internal Server Error", "", "failure".to_owned())
                        }
                        "/provider.json" if has_index_etag => {
                            index_count.fetch_add(1, Ordering::SeqCst);
                            ("304 Not Modified", "ETag: \"index-v1\"\r\n", String::new())
                        }
                        "/provider.json" => {
                            index_count.fetch_add(1, Ordering::SeqCst);
                            let body = if oversized {
                                "x".repeat(512)
                            } else {
                                serde_json::json!({
                                    "format_version":1,
                                    "provider":{"id":"http-fixture","name":"HTTP Fixture"},
                                    "instances":[{"id":"survival","manifest":"instances/survival.json"}]
                                })
                                .to_string()
                            };
                            ("200 OK", "ETag: \"index-v1\"\r\n", body)
                        }
                        "/instances/survival.json" => {
                            instance_count.fetch_add(1, Ordering::SeqCst);
                            (
                                "200 OK",
                                "ETag: \"instance-v1\"\r\nLast-Modified: Thu, 10 Sep 2026 12:00:00 GMT\r\n",
                                serde_json::json!({
                                    "format_version":1,
                                    "id":"survival",
                                    "name":"Survival",
                                    "revision":1,
                                    "minecraft":{"version":"1.20.4","loader":{"type":"vanilla"}},
                                    "files":[]
                                })
                                .to_string(),
                            )
                        }
                        _ => ("404 Not Found", "", "missing".to_owned()),
                    };
                    let response = format!(
                        "HTTP/1.1 {status}\r\n{headers}Content-Length: {}\r\nConnection: close\r\n\r\n{body}",
                        body.len()
                    );
                    let _ = socket.write_all(response.as_bytes()).await;
                });
            }
        });
        Self {
            base: Url::parse(&format!("http://{address}/")).expect("base URL"),
            fail_index,
            index_requests,
            instance_requests,
            task,
        }
    }
}

impl Drop for MockProviderHttp {
    fn drop(&mut self) {
        self.task.abort();
    }
}

async fn test_core(data: &std::path::Path, max_index_size: u64) -> CentralCore {
    let mut config = CoreConfig::new(data);
    config.download.allow_insecure_http = true;
    config.download.allowed_hosts = vec!["127.0.0.1".into()];
    config.download.retries = 0;
    config.providers.allow_private_networks = true;
    config.providers.max_index_size = max_index_size;
    CentralCore::builder()
        .config(config)
        .build()
        .await
        .expect("core")
}

#[tokio::test]
async fn remote_sync_uses_etag_and_keeps_last_snapshot_after_failure() {
    let temporary = tempfile::tempdir().expect("tempdir");
    let server = MockProviderHttp::start(false).await;
    let core = test_core(temporary.path(), 4096).await;
    let id = ProviderId::new("http-demo").expect("id");
    core.providers()
        .add_with_trust(
            id.clone(),
            ProviderSource::Remote(server.base.join("provider.json").expect("URL")),
            SignaturePolicy::Optional,
            None,
        )
        .await
        .expect("add");

    let first = core.providers().sync(&id).await.expect("first sync");
    assert!(!first.not_modified);
    let second = core.providers().sync(&id).await.expect("conditional sync");
    assert!(second.not_modified);
    assert_eq!(server.index_requests.load(Ordering::SeqCst), 2);
    assert_eq!(server.instance_requests.load(Ordering::SeqCst), 1);

    server.fail_index.store(true, Ordering::SeqCst);
    assert!(core.providers().sync(&id).await.is_err());
    let retained = core.providers().snapshot(&id).await.expect("snapshot");
    assert_eq!(retained.instances().len(), 1);
    assert_eq!(
        retained
            .instances()
            .values()
            .next()
            .expect("instance")
            .revision,
        1
    );
}

#[tokio::test]
async fn remote_provider_index_is_strictly_bounded() {
    let temporary = tempfile::tempdir().expect("tempdir");
    let server = MockProviderHttp::start(true).await;
    let core = test_core(temporary.path(), 128).await;
    let id = ProviderId::new("oversized").expect("id");
    core.providers()
        .add_with_trust(
            id.clone(),
            ProviderSource::Remote(server.base.join("provider.json").expect("URL")),
            SignaturePolicy::Disabled,
            None,
        )
        .await
        .expect("add");
    assert!(core.providers().sync(&id).await.is_err());
    assert!(core.providers().snapshot(&id).await.is_err());
}