Pernoise/Rocketmc
1
0
Fork 0
forked from didirus/AstralRinth
Code Pull Requests Activity

Revert "Use alt CDN URL when request header is passed (#4921)" (#4923)

Browse Source 
This reverts commit 609e3896eb.
This commit is contained in:
Prospector
2025-12-18 10:40:27 -08:00
committed by GitHub
parent 8d894541e8
commit 5bbc3872f3
18 changed files with 43 additions and 282 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.lock generated
View File

@@ -4503,7 +4503,6 @@ dependencies = [
"actix-http",
"actix-multipart",
"actix-rt",
"actix-utils",
"actix-web",
"actix-web-prom",
"actix-ws",

1
Cargo.toml
View File

@@ -25,7 +25,6 @@ actix-files = "0.6.8"
actix-http = "3.11.2"
actix-multipart = "0.7.2"
actix-rt = "2.11.0"
actix-utils = "3.0.1"
actix-web = "4.11.0"
actix-web-prom = "0.10.0"
actix-ws = "0.3.0"

1
apps/labrinth/.env.docker-compose
View File

@@ -5,7 +5,6 @@ SENTRY_DSN=none
SITE_URL=http://localhost:3000
# This CDN URL matches the local storage backend set below, which uses MOCK_FILE_PATH
CDN_URL=file:///tmp/modrinth
CDN_ALT_URL=file:///tmp/modrinth
LABRINTH_ADMIN_KEY=feedbeef
RATE_LIMIT_IGNORE_KEY=feedbeef

1
apps/labrinth/.env.local
View File

@@ -5,7 +5,6 @@ SENTRY_DSN=none
SITE_URL=http://localhost:3000
# This CDN URL matches the local storage backend set below, which uses MOCK_FILE_PATH
CDN_URL=file:///tmp/modrinth
CDN_ALT_URL=file:///tmp/modrinth
LABRINTH_ADMIN_KEY=feedbeef
LABRINTH_EXTERNAL_NOTIFICATION_KEY=beeffeed
RATE_LIMIT_IGNORE_KEY=feedbeef

5
apps/labrinth/Cargo.toml
View File

@@ -12,10 +12,9 @@ path = "src/main.rs"
[dependencies]
actix-cors = { workspace = true }
actix-files = { workspace = true }
actix-http = { workspace = true }
actix-http = { workspace = true, optional = true }
actix-multipart = { workspace = true }
actix-rt = { workspace = true }
actix-utils = { workspace = true }
actix-web = { workspace = true }
actix-web-prom = { workspace = true, features = ["process"] }
actix-ws = { workspace = true }
@@ -151,7 +150,7 @@ tikv-jemallocator = { workspace = true, features = [
] }
[features]
test = []
test = ["dep:actix-http"]
[lints]
workspace = true

7
apps/labrinth/src/auth/checks.rs
View File

@@ -4,7 +4,6 @@ use crate::database::models::version_item::VersionQueryResult;
use crate::database::models::{DBCollection, DBOrganization, DBTeamMember};
use crate::database::redis::RedisPool;
use crate::database::{DBProject, DBVersion, models};
use crate::file_hosting::CdnChoice;
use crate::models::users::User;
use crate::routes::ApiError;
use futures::TryStreamExt;
@@ -196,7 +195,6 @@ pub async fn filter_visible_versions(
user_option: &Option<User>,
pool: &PgPool,
redis: &RedisPool,
cdn_choice: &CdnChoice,
) -> Result<Vec<crate::models::projects::Version>, ApiError> {
let filtered_version_ids = filter_visible_version_ids(
versions.iter().map(|x| &x.inner).collect_vec(),
@@ -206,10 +204,7 @@ pub async fn filter_visible_versions(
)
.await?;
versions.retain(|x| filtered_version_ids.contains(&x.inner.id));
Ok(versions
.into_iter()
.map(|v| crate::models::projects::Version::from(v, cdn_choice))
.collect())
Ok(versions.into_iter().map(|x| x.into()).collect())
}
impl ValidateAuthorized for models::DBOAuthClient {

79
apps/labrinth/src/file_hosting/cdn.rs
View File

@@ -1,79 +0,0 @@
use std::{convert::Infallible, sync::Arc};
use actix_http::header::HeaderName;
use actix_utils::future::{Ready, ready};
use actix_web::FromRequest;
use eyre::Result;
use crate::util::env::env_var;
#[derive(Debug, Clone, Copy)]
pub struct UseAltCdn(pub bool);
const HEADER_NAME: HeaderName = HeaderName::from_static("labrinth-alt-cdn");
impl FromRequest for UseAltCdn {
type Error = Infallible;
type Future = Ready<Result<Self, Self::Error>>;
fn from_request(
req: &actix_web::HttpRequest,
_payload: &mut actix_http::Payload,
) -> Self::Future {
ready(Ok(Self(use_alt_cdn(req))))
}
}
fn use_alt_cdn(req: &actix_web::HttpRequest) -> bool {
let Some(use_alt_cdn) = req.headers().get(HEADER_NAME) else {
return false;
};
use_alt_cdn.as_bytes() == b"true"
}
#[derive(Debug, Clone)]
pub enum CdnChoice {
Default,
Alt {
base_url: Arc<str>,
alt_url: Arc<str>,
},
}
impl CdnChoice {
pub fn transform_file_url(&self, file_url: impl Into<String>) -> String {
let file_url = file_url.into();
match self {
Self::Default => file_url,
Self::Alt { base_url, alt_url } => {
file_url.replace(&**base_url, alt_url)
}
}
}
}
#[derive(Debug, Clone)]
pub struct CdnConfig {
pub url: Arc<str>,
pub alt_url: Arc<str>,
}
impl CdnConfig {
pub fn from_env() -> Result<Self> {
Ok(Self {
url: Arc::from(env_var("CDN_URL")?),
alt_url: Arc::from(env_var("CDN_ALT_URL")?),
})
}
pub fn make_choice(&self, use_alt_cdn: bool) -> CdnChoice {
if use_alt_cdn {
CdnChoice::Alt {
base_url: self.url.clone(),
alt_url: self.alt_url.clone(),
}
} else {
CdnChoice::Default
}
}
}

2
apps/labrinth/src/file_hosting/mod.rs
View File

@@ -1,12 +1,10 @@
use async_trait::async_trait;
use thiserror::Error;
mod cdn;
mod mock;
mod s3_host;
use bytes::Bytes;
pub use cdn::*;
pub use mock::MockHost;
pub use s3_host::{S3BucketConfig, S3Host};

5
apps/labrinth/src/lib.rs
View File

@@ -18,7 +18,6 @@ use util::gotenberg::GotenbergClient;
use crate::background_task::update_versions;
use crate::database::ReadOnlyPgPool;
use crate::file_hosting::CdnConfig;
use crate::queue::billing::{index_billing, index_subscriptions};
use crate::queue::moderation::AutomatedModerationQueue;
use crate::util::anrok;
@@ -56,7 +55,6 @@ pub struct LabrinthConfig {
pub redis_pool: RedisPool,
pub clickhouse: Client,
pub file_host: Arc<dyn file_hosting::FileHost + Send + Sync>,
pub cdn_config: web::Data<CdnConfig>,
pub maxmind: web::Data<MaxMind>,
pub scheduler: Arc<scheduler::Scheduler>,
pub ip_salt: Pepper,
@@ -277,7 +275,6 @@ pub fn app_setup(
redis_pool,
clickhouse: clickhouse.clone(),
file_host,
cdn_config: web::Data::new(CdnConfig::from_env().unwrap()),
maxmind: web::Data::new(maxmind),
scheduler: Arc::new(scheduler),
ip_salt,
@@ -319,7 +316,6 @@ pub fn app_config(
.app_data(web::Data::new(labrinth_config.pool.clone()))
.app_data(web::Data::new(labrinth_config.ro_pool.clone()))
.app_data(web::Data::new(labrinth_config.file_host.clone()))
.app_data(labrinth_config.cdn_config.clone())
.app_data(web::Data::new(labrinth_config.search_config.clone()))
.app_data(web::Data::new(labrinth_config.gotenberg_client.clone()))
.app_data(labrinth_config.session_queue.clone())
@@ -378,7 +374,6 @@ pub fn check_env_vars() -> bool {
failed |= check_var::<String>("SITE_URL");
failed |= check_var::<String>("CDN_URL");
failed |= check_var::<String>("CDN_ALT_URL");
failed |= check_var::<String>("LABRINTH_ADMIN_KEY");
failed |= check_var::<String>("LABRINTH_EXTERNAL_NOTIFICATION_KEY");
failed |= check_var::<String>("RATE_LIMIT_IGNORE_KEY");

7
apps/labrinth/src/models/v3/projects.rs
View File

@@ -4,7 +4,6 @@ use std::mem;
use crate::database::models::loader_fields::VersionField;
use crate::database::models::project_item::{LinkUrl, ProjectQueryResult};
use crate::database::models::version_item::VersionQueryResult;
use crate::file_hosting::CdnChoice;
use crate::models::ids::{
OrganizationId, ProjectId, TeamId, ThreadId, VersionId,
};
@@ -703,8 +702,8 @@ where
Ok(map)
}
impl Version {
pub fn from(data: VersionQueryResult, cdn_choice: &CdnChoice) -> Self {
impl From<VersionQueryResult> for Version {
fn from(data: VersionQueryResult) -> Version {
let v = data.inner;
Version {
id: v.id.into(),
@@ -732,7 +731,7 @@ impl Version {
.files
.into_iter()
.map(|f| VersionFile {
url: cdn_choice.transform_file_url(f.url),
url: f.url,
filename: f.filename,
hashes: f.hashes,
primary: f.primary,

2
apps/labrinth/src/queue/moderation.rs
View File

@@ -3,7 +3,6 @@ use crate::database;
use crate::database::models::notification_item::NotificationBuilder;
use crate::database::models::thread_item::ThreadMessageBuilder;
use crate::database::redis::RedisPool;
use crate::file_hosting::CdnChoice;
use crate::models::ids::ProjectId;
use crate::models::notifications::NotificationBody;
use crate::models::pack::{PackFile, PackFileHash, PackFormat};
@@ -363,7 +362,6 @@ impl AutomatedModerationQueue {
&None,
&pool,
&redis,
&CdnChoice::Default,
)
.await?;

4
apps/labrinth/src/routes/updates.rs
View File

@@ -9,7 +9,6 @@ use crate::auth::get_user_from_headers;
use crate::database;
use crate::database::models::legacy_loader_fields::MinecraftGameVersion;
use crate::database::redis::RedisPool;
use crate::file_hosting::{CdnConfig, UseAltCdn};
use crate::models::pats::Scopes;
use crate::models::projects::VersionType;
use crate::queue::session::AuthQueue;
@@ -38,8 +37,6 @@ pub async fn forge_updates(
pool: web::Data<PgPool>,
redis: web::Data<RedisPool>,
session_queue: web::Data<AuthQueue>,
cdn_config: web::Data<CdnConfig>,
UseAltCdn(use_alt_cdn): UseAltCdn,
) -> Result<HttpResponse, ApiError> {
const ERROR: &str = "The specified project does not exist!";
@@ -85,7 +82,6 @@ pub async fn forge_updates(
&user_option,
&pool,
&redis,
&cdn_config.make_choice(use_alt_cdn),
)
.await?;

9
apps/labrinth/src/routes/v2/projects.rs
View File

@@ -1,8 +1,7 @@
use crate::database::models::categories::LinkPlatform;
use crate::database::models::{project_item, version_item};
use crate::database::redis::RedisPool;
use crate::file_hosting::{CdnChoice, CdnConfig};
use crate::file_hosting::{FileHost, UseAltCdn};
use crate::file_hosting::FileHost;
use crate::models::projects::{
Link, MonetizationStatus, Project, ProjectStatus, SearchRequest, Version,
};
@@ -268,8 +267,6 @@ pub async fn dependency_list(
pool: web::Data<PgPool>,
redis: web::Data<RedisPool>,
session_queue: web::Data<AuthQueue>,
cdn_config: web::Data<CdnConfig>,
use_alt_cdn: UseAltCdn,
) -> Result<HttpResponse, ApiError> {
// TODO: tests, probably
let response = v3::projects::dependency_list(
@@ -278,8 +275,6 @@ pub async fn dependency_list(
pool.clone(),
redis.clone(),
session_queue,
cdn_config,
use_alt_cdn,
)
.await
.or_else(v2_reroute::flatten_404_error)?;
@@ -551,7 +546,7 @@ pub async fn project_edit(
version_item::DBVersion::get_many(&version_ids, &**pool, &redis)
.await?;
for version in versions {
let version = Version::from(version, &CdnChoice::Default);
let version = Version::from(version);
let mut fields = version.fields;
let (current_client_side, current_server_side) =
v2_reroute::convert_v3_side_types_to_v2_side_types(

34
apps/labrinth/src/routes/v2/version_file.rs
View File

@@ -1,7 +1,6 @@
use super::ApiError;
use crate::database::ReadOnlyPgPool;
use crate::database::redis::RedisPool;
use crate::file_hosting::{CdnConfig, UseAltCdn};
use crate::models::projects::{Project, Version, VersionType};
use crate::models::v2::projects::{LegacyProject, LegacyVersion};
use crate::queue::session::AuthQueue;
@@ -39,8 +38,6 @@ pub async fn get_version_from_hash(
redis: web::Data<RedisPool>,
hash_query: web::Query<HashQuery>,
session_queue: web::Data<AuthQueue>,
cdn_config: web::Data<CdnConfig>,
use_alt_cdn: UseAltCdn,
) -> Result<HttpResponse, ApiError> {
let response = v3::version_file::get_version_from_hash(
req,
@@ -49,8 +46,6 @@ pub async fn get_version_from_hash(
redis,
hash_query,
session_queue,
cdn_config,
use_alt_cdn,
)
.await
.or_else(v2_reroute::flatten_404_error)?;
@@ -74,7 +69,6 @@ pub async fn download_version(
redis: web::Data<RedisPool>,
hash_query: web::Query<HashQuery>,
session_queue: web::Data<AuthQueue>,
use_alt_cdn: UseAltCdn,
) -> Result<HttpResponse, ApiError> {
// Returns TemporaryRedirect, so no need to convert to V2
v3::version_file::download_version(
@@ -84,7 +78,6 @@ pub async fn download_version(
redis,
hash_query,
session_queue,
use_alt_cdn,
)
.await
.or_else(v2_reroute::flatten_404_error)
@@ -129,8 +122,6 @@ pub async fn get_update_from_hash(
hash_query: web::Query<HashQuery>,
update_data: web::Json<UpdateData>,
session_queue: web::Data<AuthQueue>,
cdn_config: web::Data<CdnConfig>,
use_alt_cdn: UseAltCdn,
) -> Result<HttpResponse, ApiError> {
let update_data = update_data.into_inner();
let mut loader_fields = HashMap::new();
@@ -155,8 +146,6 @@ pub async fn get_update_from_hash(
hash_query,
web::Json(update_data),
session_queue,
cdn_config,
use_alt_cdn,
)
.await
.or_else(v2_reroute::flatten_404_error)?;
@@ -186,8 +175,6 @@ pub async fn get_versions_from_hashes(
redis: web::Data<RedisPool>,
file_data: web::Json<FileHashes>,
session_queue: web::Data<AuthQueue>,
cdn_config: web::Data<CdnConfig>,
use_alt_cdn: UseAltCdn,
) -> Result<HttpResponse, ApiError> {
let file_data = file_data.into_inner();
let file_data = v3::version_file::FileHashes {
@@ -200,8 +187,6 @@ pub async fn get_versions_from_hashes(
redis,
web::Json(file_data),
session_queue,
cdn_config,
use_alt_cdn,
)
.await
.or_else(v2_reroute::flatten_404_error)?;
@@ -296,8 +281,6 @@ pub async fn update_files(
pool: web::Data<ReadOnlyPgPool>,
redis: web::Data<RedisPool>,
update_data: web::Json<ManyUpdateData>,
cdn_config: web::Data<CdnConfig>,
use_alt_cdn: UseAltCdn,
) -> Result<HttpResponse, ApiError> {
let update_data = update_data.into_inner();
let update_data = v3::version_file::ManyUpdateData {
@@ -308,15 +291,10 @@ pub async fn update_files(
hashes: update_data.hashes,
};
let response = v3::version_file::update_files(
pool,
redis,
web::Json(update_data),
cdn_config,
use_alt_cdn,
)
.await
.or_else(v2_reroute::flatten_404_error)?;
let response =
v3::version_file::update_files(pool, redis, web::Json(update_data))
.await
.or_else(v2_reroute::flatten_404_error)?;
// Convert response to V2 format
match v2_reroute::extract_ok_json::<HashMap<String, Version>>(response)
@@ -357,8 +335,6 @@ pub async fn update_individual_files(
redis: web::Data<RedisPool>,
update_data: web::Json<ManyFileUpdateData>,
session_queue: web::Data<AuthQueue>,
cdn_config: web::Data<CdnConfig>,
use_alt_cdn: UseAltCdn,
) -> Result<HttpResponse, ApiError> {
let update_data = update_data.into_inner();
let update_data = v3::version_file::ManyFileUpdateData {
@@ -392,8 +368,6 @@ pub async fn update_individual_files(
redis,
web::Json(update_data),
session_queue,
cdn_config,
use_alt_cdn,
)
.await
.or_else(v2_reroute::flatten_404_error)?;

34
apps/labrinth/src/routes/v2/versions.rs
View File

@@ -2,7 +2,6 @@ use std::collections::HashMap;
use super::ApiError;
use crate::database::redis::RedisPool;
use crate::file_hosting::{CdnConfig, UseAltCdn};
use crate::models;
use crate::models::ids::VersionId;
use crate::models::projects::{
@@ -48,8 +47,6 @@ pub async fn version_list(
pool: web::Data<PgPool>,
redis: web::Data<RedisPool>,
session_queue: web::Data<AuthQueue>,
cdn_config: web::Data<CdnConfig>,
use_alt_cdn: UseAltCdn,
) -> Result<HttpResponse, ApiError> {
let loaders = if let Some(loaders) = filters.loaders {
if let Ok(mut loaders) = serde_json::from_str::<Vec<String>>(&loaders) {
@@ -107,8 +104,6 @@ pub async fn version_list(
pool,
redis,
session_queue,
cdn_config,
use_alt_cdn,
)
.await
.or_else(v2_reroute::flatten_404_error)?;
@@ -134,8 +129,6 @@ pub async fn version_project_get(
pool: web::Data<PgPool>,
redis: web::Data<RedisPool>,
session_queue: web::Data<AuthQueue>,
cdn_config: web::Data<CdnConfig>,
use_alt_cdn: UseAltCdn,
) -> Result<HttpResponse, ApiError> {
let id = info.into_inner();
let response = v3::versions::version_project_get_helper(
@@ -144,8 +137,6 @@ pub async fn version_project_get(
pool,
redis,
session_queue,
cdn_config,
use_alt_cdn,
)
.await
.or_else(v2_reroute::flatten_404_error)?;
@@ -171,8 +162,6 @@ pub async fn versions_get(
pool: web::Data<PgPool>,
redis: web::Data<RedisPool>,
session_queue: web::Data<AuthQueue>,
cdn_config: web::Data<CdnConfig>,
use_alt_cdn: UseAltCdn,
) -> Result<HttpResponse, ApiError> {
let ids = v3::versions::VersionIds { ids: ids.ids };
let response = v3::versions::versions_get(
@@ -181,8 +170,6 @@ pub async fn versions_get(
pool,
redis,
session_queue,
cdn_config,
use_alt_cdn,
)
.await
.or_else(v2_reroute::flatten_404_error)?;
@@ -207,21 +194,12 @@ pub async fn version_get(
pool: web::Data<PgPool>,
redis: web::Data<RedisPool>,
session_queue: web::Data<AuthQueue>,
cdn_config: web::Data<CdnConfig>,
use_alt_cdn: UseAltCdn,
) -> Result<HttpResponse, ApiError> {
let id = info.into_inner().0;
let response = v3::versions::version_get_helper(
req,
id,
pool,
redis,
session_queue,
cdn_config,
use_alt_cdn,
)
.await
.or_else(v2_reroute::flatten_404_error)?;
let response =
v3::versions::version_get_helper(req, id, pool, redis, session_queue)
.await
.or_else(v2_reroute::flatten_404_error)?;
// Convert response to V2 format
match v2_reroute::extract_ok_json::<Version>(response).await {
Ok(version) => {
@@ -275,8 +253,6 @@ pub async fn version_edit(
redis: web::Data<RedisPool>,
new_version: web::Json<EditVersion>,
session_queue: web::Data<AuthQueue>,
cdn_config: web::Data<CdnConfig>,
use_alt_cdn: UseAltCdn,
) -> Result<HttpResponse, ApiError> {
let new_version = new_version.into_inner();
@@ -295,8 +271,6 @@ pub async fn version_edit(
pool.clone(),
redis.clone(),
session_queue.clone(),
cdn_config,
use_alt_cdn,
)
.await
.or_else(v2_reroute::flatten_404_error)?;

5
apps/labrinth/src/routes/v3/projects.rs
View File

@@ -9,7 +9,7 @@ use crate::database::models::thread_item::ThreadMessageBuilder;
use crate::database::models::{DBTeamMember, ids as db_ids, image_item};
use crate::database::redis::RedisPool;
use crate::database::{self, models as db_models};
use crate::file_hosting::{CdnConfig, FileHost, FileHostPublicity, UseAltCdn};
use crate::file_hosting::{FileHost, FileHostPublicity};
use crate::models;
use crate::models::ids::{ProjectId, VersionId};
use crate::models::images::ImageContext;
@@ -1068,8 +1068,6 @@ pub async fn dependency_list(
pool: web::Data<PgPool>,
redis: web::Data<RedisPool>,
session_queue: web::Data<AuthQueue>,
cdn_config: web::Data<CdnConfig>,
UseAltCdn(use_alt_cdn): UseAltCdn,
) -> Result<HttpResponse, ApiError> {
let string = info.into_inner().0;
@@ -1138,7 +1136,6 @@ pub async fn dependency_list(
&user_option,
&pool,
&redis,
&cdn_config.make_choice(use_alt_cdn),
)
.await?;

55
apps/labrinth/src/routes/v3/version_file.rs
View File

@@ -3,7 +3,6 @@ use crate::auth::checks::{filter_visible_versions, is_visible_version};
use crate::auth::{filter_visible_projects, get_user_from_headers};
use crate::database::ReadOnlyPgPool;
use crate::database::redis::RedisPool;
use crate::file_hosting::{CdnConfig, UseAltCdn};
use crate::models::ids::VersionId;
use crate::models::pats::Scopes;
use crate::models::projects::VersionType;
@@ -42,8 +41,6 @@ pub async fn get_version_from_hash(
redis: web::Data<RedisPool>,
hash_query: web::Query<HashQuery>,
session_queue: web::Data<AuthQueue>,
cdn_config: web::Data<CdnConfig>,
UseAltCdn(use_alt_cdn): UseAltCdn,
) -> Result<HttpResponse, ApiError> {
let user_option = get_user_from_headers(
&req,
@@ -78,10 +75,8 @@ pub async fn get_version_from_hash(
return Err(ApiError::NotFound);
}
Ok(HttpResponse::Ok().json(models::projects::Version::from(
version,
&cdn_config.make_choice(use_alt_cdn),
)))
Ok(HttpResponse::Ok()
.json(models::projects::Version::from(version)))
} else {
Err(ApiError::NotFound)
}
@@ -132,8 +127,6 @@ pub async fn get_update_from_hash(
hash_query: web::Query<HashQuery>,
update_data: web::Json<UpdateData>,
session_queue: web::Data<AuthQueue>,
cdn_config: web::Data<CdnConfig>,
UseAltCdn(use_alt_cdn): UseAltCdn,
) -> Result<HttpResponse, ApiError> {
let user_option = get_user_from_headers(
&req,
@@ -202,12 +195,9 @@ pub async fn get_update_from_hash(
return Err(ApiError::NotFound);
}
return Ok(HttpResponse::Ok().json(
models::projects::Version::from(
first,
&cdn_config.make_choice(use_alt_cdn),
),
));
return Ok(
HttpResponse::Ok().json(models::projects::Version::from(first))
);
}
}
Err(ApiError::NotFound)
@@ -226,8 +216,6 @@ pub async fn get_versions_from_hashes(
redis: web::Data<RedisPool>,
file_data: web::Json<FileHashes>,
session_queue: web::Data<AuthQueue>,
cdn_config: web::Data<CdnConfig>,
UseAltCdn(use_alt_cdn): UseAltCdn,
) -> Result<HttpResponse, ApiError> {
let user_option = get_user_from_headers(
&req,
@@ -260,7 +248,6 @@ pub async fn get_versions_from_hashes(
&user_option,
&pool,
&redis,
&cdn_config.make_choice(use_alt_cdn),
)
.await?;
@@ -348,8 +335,6 @@ pub async fn update_files(
pool: web::Data<ReadOnlyPgPool>,
redis: web::Data<RedisPool>,
update_data: web::Json<ManyUpdateData>,
cdn_config: web::Data<CdnConfig>,
UseAltCdn(use_alt_cdn): UseAltCdn,
) -> Result<HttpResponse, ApiError> {
let algorithm = update_data
.algorithm
@@ -407,11 +392,10 @@ pub async fn update_files(
.find(|x| x.inner.project_id == file.project_id)
&& let Some(hash) = file.hashes.get(&algorithm)
{
let version = models::projects::Version::from(
version.clone(),
&cdn_config.make_choice(use_alt_cdn),
response.insert(
hash.clone(),
models::projects::Version::from(version.clone()),
);
response.insert(hash.clone(), version);
}
}
@@ -438,8 +422,6 @@ pub async fn update_individual_files(
redis: web::Data<RedisPool>,
update_data: web::Json<ManyFileUpdateData>,
session_queue: web::Data<AuthQueue>,
cdn_config: web::Data<CdnConfig>,
UseAltCdn(use_alt_cdn): UseAltCdn,
) -> Result<HttpResponse, ApiError> {
let user_option = get_user_from_headers(
&req,
@@ -542,11 +524,10 @@ pub async fn update_individual_files(
)
.await?
{
let version = models::projects::Version::from(
version.clone(),
&cdn_config.make_choice(use_alt_cdn),
response.insert(
hash.clone(),
models::projects::Version::from(version.clone()),
);
response.insert(hash.clone(), version);
}
}
}
@@ -693,7 +674,6 @@ pub async fn download_version(
redis: web::Data<RedisPool>,
hash_query: web::Query<HashQuery>,
session_queue: web::Data<AuthQueue>,
UseAltCdn(use_alt_cdn): UseAltCdn,
) -> Result<HttpResponse, ApiError> {
let user_option = get_user_from_headers(
&req,
@@ -724,15 +704,6 @@ pub async fn download_version(
database::models::DBVersion::get(file.version_id, &**pool, &redis)
.await?;
let url = if use_alt_cdn {
let cdn_url = dotenvy::var("CDN_URL").unwrap();
let cdn_alt_url = dotenvy::var("CDN_ALT_URL").unwrap();
file.url.replace(&cdn_url, &cdn_alt_url)
} else {
file.url.clone()
};
if let Some(version) = version {
if !is_visible_version(&version.inner, &user_option, &pool, &redis)
.await?
@@ -741,8 +712,8 @@ pub async fn download_version(
}
Ok(HttpResponse::TemporaryRedirect()
.append_header(("Location", &*url))
.json(DownloadRedirect { url }))
.append_header(("Location", &*file.url))
.json(DownloadRedirect { url: file.url }))
} else {
Err(ApiError::NotFound)
}

73
apps/labrinth/src/routes/v3/versions.rs
View File

@@ -14,7 +14,6 @@ use crate::database::models::version_item::{
};
use crate::database::models::{DBOrganization, image_item};
use crate::database::redis::RedisPool;
use crate::file_hosting::{CdnConfig, UseAltCdn};
use crate::models;
use crate::models::ids::VersionId;
use crate::models::images::ImageContext;
@@ -62,30 +61,16 @@ pub async fn version_project_get(
pool: web::Data<PgPool>,
redis: web::Data<RedisPool>,
session_queue: web::Data<AuthQueue>,
cdn_config: web::Data<CdnConfig>,
use_alt_cdn: UseAltCdn,
) -> Result<HttpResponse, ApiError> {
let info = info.into_inner();
version_project_get_helper(
req,
info,
pool,
redis,
session_queue,
cdn_config,
use_alt_cdn,
)
.await
version_project_get_helper(req, info, pool, redis, session_queue).await
}
pub async fn version_project_get_helper(
req: HttpRequest,
id: (String, String),
pool: web::Data<PgPool>,
redis: web::Data<RedisPool>,
session_queue: web::Data<AuthQueue>,
cdn_config: web::Data<CdnConfig>,
UseAltCdn(use_alt_cdn): UseAltCdn,
) -> Result<HttpResponse, ApiError> {
let result =
database::models::DBProject::get(&id.0, &**pool, &redis).await?;
@@ -125,12 +110,8 @@ pub async fn version_project_get_helper(
&& is_visible_version(&version.inner, &user_option, &pool, &redis)
.await?
{
return Ok(HttpResponse::Ok().json(
models::projects::Version::from(
version,
&cdn_config.make_choice(use_alt_cdn),
),
));
return Ok(HttpResponse::Ok()
.json(models::projects::Version::from(version)));
}
}
@@ -148,8 +129,6 @@ pub async fn versions_get(
pool: web::Data<PgPool>,
redis: web::Data<RedisPool>,
session_queue: web::Data<AuthQueue>,
cdn_config: web::Data<CdnConfig>,
UseAltCdn(use_alt_cdn): UseAltCdn,
) -> Result<HttpResponse, ApiError> {
let version_ids =
serde_json::from_str::<Vec<models::ids::VersionId>>(&ids.ids)?
@@ -171,14 +150,9 @@ pub async fn versions_get(
.map(|x| x.1)
.ok();
let versions = filter_visible_versions(
versions_data,
&user_option,
&pool,
&redis,
&cdn_config.make_choice(use_alt_cdn),
)
.await?;
let versions =
filter_visible_versions(versions_data, &user_option, &pool, &redis)
.await?;
Ok(HttpResponse::Ok().json(versions))
}
@@ -189,20 +163,9 @@ pub async fn version_get(
pool: web::Data<PgPool>,
redis: web::Data<RedisPool>,
session_queue: web::Data<AuthQueue>,
cdn_config: web::Data<CdnConfig>,
use_alt_cdn: UseAltCdn,
) -> Result<HttpResponse, ApiError> {
let id = info.into_inner().0;
version_get_helper(
req,
id,
pool,
redis,
session_queue,
cdn_config,
use_alt_cdn,
)
.await
version_get_helper(req, id, pool, redis, session_queue).await
}
pub async fn version_get_helper(
@@ -211,8 +174,6 @@ pub async fn version_get_helper(
pool: web::Data<PgPool>,
redis: web::Data<RedisPool>,
session_queue: web::Data<AuthQueue>,
cdn_config: web::Data<CdnConfig>,
UseAltCdn(use_alt_cdn): UseAltCdn,
) -> Result<HttpResponse, ApiError> {
let version_data =
database::models::DBVersion::get(id.into(), &**pool, &redis).await?;
@@ -231,10 +192,9 @@ pub async fn version_get_helper(
if let Some(data) = version_data
&& is_visible_version(&data.inner, &user_option, &pool, &redis).await?
{
return Ok(HttpResponse::Ok().json(models::projects::Version::from(
data,
&cdn_config.make_choice(use_alt_cdn),
)));
return Ok(
HttpResponse::Ok().json(models::projects::Version::from(data))
);
}
Err(ApiError::NotFound)
@@ -764,8 +724,6 @@ pub async fn version_list(
pool: web::Data<PgPool>,
redis: web::Data<RedisPool>,
session_queue: web::Data<AuthQueue>,
cdn_config: web::Data<CdnConfig>,
UseAltCdn(use_alt_cdn): UseAltCdn,
) -> Result<HttpResponse, ApiError> {
let string = info.into_inner().0;
@@ -898,14 +856,9 @@ pub async fn version_list(
});
response.dedup_by(|a, b| a.inner.id == b.inner.id);
let response = filter_visible_versions(
response,
&user_option,
&pool,
&redis,
&cdn_config.make_choice(use_alt_cdn),
)
.await?;
let response =
filter_visible_versions(response, &user_option, &pool, &redis)
.await?;
Ok(HttpResponse::Ok().json(response))
} else {