Implement legacy api

Author: TymanWasTaken

Cargo.lock

@@ -21,7 +21,6 @@ publish = { workspace = true }
 
 [dependencies]
 actix-web = { version = "4.11.0", features = ["http2"] }
-anyhow = "1.0.98"
 base16ct = { version = "0.2.0", features = ["std"] }
 clap = { version = "4.5.41", features = ["derive", "env"] }
 documented = "0.9.2"
@@ -33,6 +32,7 @@ reqwest = { version = "0.12.22", default-features = false, features = ["charset"
 semver = "1.0.26"
 serde = { workspace = true }
 serde_json = { workspace = true }
+serde_variant = "0.1.3"
 sha2 = "0.11.0-rc.0"
 thiserror = "2.0.12"
 tokio = { version = "1.46.1", features = ["macros", "rt-multi-thread"] }

Cargo.toml

@@ -4,6 +4,7 @@ use chrono::{DateTime, Utc};
 use serde::Deserialize;
 
 pub type ParseError = quick_xml::DeError;
+pub type Timestamp = DateTime<Utc>;
 
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]

maven/src/parsing/maven.rs

@@ -4,7 +4,7 @@ combine_control_expr = false
 condense_wildcard_suffixes = true
 control_brace_style = "AlwaysSameLine"
 empty_item_single_line = true
-error_on_line_overflow = true
+error_on_line_overflow = false
 fn_single_line = true
 force_multiline_blocks = false
 format_code_in_doc_comments = true
@@ -34,3 +34,4 @@ use_small_heuristics = "Default"
 use_try_shorthand = true
 where_single_line = false
 wrap_comments = true
+tab_spaces = 4

rustfmt.toml

@@ -0,0 +1,65 @@
+use actix_web::{HttpResponse, Responder, get, web};
+use tokio::try_join;
+
+use crate::api::{
+	common::data::ApiData,
+	legacy::{
+		types::{
+			LegacyArtifactsErrorResponse,
+			LegacyArtifactsResponse,
+			LegacyLoader,
+			LegacyVersion
+		},
+		utils::get_latest_artifact
+	}
+};
+
+const ONECONFIG_GROUP: &str = "cc.polyfrost";
+
+#[get("/oneconfig/{version}-{loader}")]
+async fn oneconfig(
+	state: web::Data<ApiData>,
+	path: web::Path<(LegacyVersion, LegacyLoader)>
+) -> Result<impl Responder, LegacyArtifactsErrorResponse> {
+	let version = serde_variant::to_variant_name(&path.0)
+		.map_err(LegacyArtifactsErrorResponse::EnumVariantSerialization)?;
+	let loader = serde_variant::to_variant_name(&path.1)
+		.map_err(LegacyArtifactsErrorResponse::EnumVariantSerialization)?;
+	let loader_type = path.1.get_loader_type();
+
+	let oneconfig_artifact = format!("oneconfig-{version}-{loader}");
+	let loader_artifact = format!("oneconfig-loader-{loader_type}");
+
+	let ((release, release_ts), (snapshot, snapshot_ts), (loader, _)) = try_join!(
+		get_latest_artifact(
+			&state,
+			"releases",
+			ONECONFIG_GROUP,
+			&oneconfig_artifact,
+			Some("full")
+		),
+		get_latest_artifact(
+			&state,
+			"snapshots",
+			ONECONFIG_GROUP,
+			&oneconfig_artifact,
+			None
+		),
+		get_latest_artifact(&state, "releases", ONECONFIG_GROUP, &loader_artifact, None)
+	)?;
+
+	// Replace snapshot with release if it is newer
+	let snapshot = if release_ts > snapshot_ts {
+		release.clone()
+	} else {
+		snapshot
+	};
+
+	let res = HttpResponse::Ok().json(LegacyArtifactsResponse {
+		release,
+		snapshot,
+		loader
+	});
+
+	Ok(res)
+}

src/api/legacy/endpoint.rs

@@ -1 +1,7 @@
+use actix_web::web::ServiceConfig;
 
+pub mod endpoint;
+pub mod types;
+pub mod utils;
+
+pub fn configure(config: &mut ServiceConfig) { config.service(endpoint::oneconfig); }

src/api/legacy/mod.rs

@@ -0,0 +1,58 @@
+use actix_web::{ResponseError, http::StatusCode};
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+
+#[derive(Serialize, Deserialize, Debug, Hash, PartialEq, Eq, Clone)]
+pub enum LegacyVersion {
+	#[serde(rename = "1.8.9")]
+	OneEightNine,
+	#[serde(rename = "1.12.2")]
+	OneTwelveTwo
+}
+
+#[derive(Serialize, Deserialize, Debug, Hash, PartialEq, Eq, Clone)]
+#[serde(rename_all = "lowercase")]
+pub enum LegacyLoader {
+	Forge
+}
+
+impl LegacyLoader {
+	pub fn get_loader_type(&self) -> &'static str {
+		match self {
+			LegacyLoader::Forge => "launchwrapper"
+		}
+	}
+}
+
+#[derive(Serialize, Deserialize, Debug, Hash, PartialEq, Eq, Clone)]
+pub struct LegacyArtifact {
+	pub url: String,
+	pub sha256: String
+}
+
+#[derive(Serialize, Deserialize, Debug, Hash, PartialEq, Eq, Clone)]
+pub struct LegacyArtifactsResponse {
+	pub release: LegacyArtifact,
+	pub snapshot: LegacyArtifact,
+	pub loader: LegacyArtifact
+}
+
+#[derive(Debug, Error)]
+pub enum LegacyArtifactsErrorResponse {
+	#[error("unable to serialize serde enum variant name: {0}")]
+	EnumVariantSerialization(#[source] serde_variant::UnsupportedType),
+	#[error("unable to connect to maven: {0}")]
+	MavenFetch(#[source] reqwest::Error),
+	#[error("maven request returned non-2xx status code: {0}")]
+	MavenResponse(#[source] reqwest::Error),
+	#[error("decoding maven metadata response failed: {0}")]
+	MavenMetadataDecoding(#[source] reqwest::Error),
+	#[error("parsing maven metadata response as XML failed: {0}")]
+	MavenMetadataParsing(#[source] maven::parsing::maven::ParseError)
+}
+
+impl ResponseError for LegacyArtifactsErrorResponse {
+	fn status_code(&self) -> StatusCode { StatusCode::INTERNAL_SERVER_ERROR }
+
+	// TODO: Implement RFC9457 problem details
+}

src/api/legacy/types.rs

@@ -0,0 +1,70 @@
+use actix_web::web;
+use maven::{
+	parsing::{MavenArtifactMetadata, maven::Timestamp},
+	types::ArtifactCoordinate
+};
+
+use crate::api::{
+	common::data::ApiData,
+	legacy::types::{LegacyArtifact, LegacyArtifactsErrorResponse}
+};
+
+pub async fn get_latest_artifact(
+	state: &web::Data<ApiData>,
+	repository: &str,
+	group_id: &str,
+	artifact_id: &str,
+	classifier: Option<&str>
+) -> Result<(LegacyArtifact, Timestamp), LegacyArtifactsErrorResponse> {
+	let internal_repository_url = state.internal_maven_url.clone() + repository;
+	let public_repository_url = state.public_maven_url.clone() + repository;
+
+	let res = state
+		// Fetch metadata with HTTP
+		.client
+		.get(MavenArtifactMetadata::get_metadata_url(&internal_repository_url, group_id, artifact_id))
+		.send()
+		.await
+		.map_err(LegacyArtifactsErrorResponse::MavenFetch)?
+		// Error on non-2xx response codes
+		.error_for_status()
+		.map_err(LegacyArtifactsErrorResponse::MavenResponse)?
+		// Decode response
+		.text()
+		.await
+		.map_err(LegacyArtifactsErrorResponse::MavenMetadataDecoding)?;
+
+	let parsed = MavenArtifactMetadata::parse_from_str(&res)
+		.map_err(LegacyArtifactsErrorResponse::MavenMetadataParsing)?;
+
+	let coordinate =
+		ArtifactCoordinate::new(group_id, artifact_id, parsed.versioning.latest);
+	let coordinate = if let Some(classifier) = classifier {
+		coordinate.with_classifier(classifier)
+	} else {
+		coordinate
+	};
+
+	let checksum = state
+		.client
+		// Fetch sha256 url
+		.get(coordinate.to_sha256_url(&internal_repository_url))
+		.send()
+		.await
+		.map_err(LegacyArtifactsErrorResponse::MavenFetch)?
+		// Error on non-2xx response codes
+		.error_for_status()
+		.map_err(LegacyArtifactsErrorResponse::MavenResponse)?
+		// Decode response as UTF8
+		.text()
+		.await
+		.map_err(LegacyArtifactsErrorResponse::MavenMetadataDecoding)?;
+
+	Ok((
+		LegacyArtifact {
+			url: coordinate.to_artifact_url(&public_repository_url),
+			sha256: checksum
+		},
+		parsed.versioning.last_updated
+	))
+}

src/api/legacy/utils.rs

@@ -46,11 +46,7 @@ pub enum ArtifactErrorResponse {
 }
 
 impl ResponseError for ArtifactErrorResponse {
-	fn status_code(&self) -> StatusCode {
-		match self {
-			_ => StatusCode::INTERNAL_SERVER_ERROR
-		}
-	}
+	fn status_code(&self) -> StatusCode { StatusCode::INTERNAL_SERVER_ERROR }
 
 	// TODO: Implement RFC9457 problem details
 }