feat: add host-based upload support to rattler_upload

crates/rattler_s3/src/clap.rs

@@ -71,8 +71,7 @@ impl From<S3CredentialsOpts> for Option<S3Credentials> {
             tracing::warn!("The `--force-path-style` option is deprecated, please use `--addressing-style=path` instead.");
             value.addressing_style = S3AddressingStyleOpts::Path;
         }
-
-        if let (Some(endpoint_url), Some(region)) = (value.endpoint_url, value.region) {
+        if let (Some(endpoint_url), Some(region)) = (value.endpoint_url, Some(value.region)) {
             Some(S3Credentials {
                 endpoint_url,
                 region,

crates/rattler_s3/src/lib.rs

@@ -23,14 +23,14 @@ pub enum S3AddressingStyle {
 /// Rattler based crates always either use S3 credentials specified by the user
 /// through CLI arguments combined with credentials coming from `rattler auth`,
 /// or everything is loaded through the AWS SDK.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct S3Credentials {
     /// The endpoint URL of the S3 backend
     pub endpoint_url: Url,
 
     /// The region of the S3 backend
-    pub region: String,
+    pub region: Option<String>,
 
     /// The addressing style to use for the bucket.
     #[cfg_attr(feature = "serde", serde(default))]
@@ -149,7 +149,7 @@ impl S3Credentials {
 
         Some(ResolvedS3Credentials {
             endpoint_url: self.endpoint_url,
-            region: self.region,
+            region: self.region?,
             access_key_id,
             secret_access_key,
             session_token,

crates/rattler_upload/Cargo.toml

@@ -50,6 +50,7 @@ tokio = { workspace = true, features = [
   "rt-multi-thread",
   "process",
 ] }
+regex = "1.10"
 
 [target.'cfg(not(target_os = "windows"))'.dependencies]
 sha2 = { workspace = true, features = ["asm"] }

crates/rattler_upload/src/lib.rs

@@ -1,13 +1,26 @@
 pub mod upload;
 pub(crate) mod utils;
 
+use crate::upload::opt::{AnacondaOpts, ArtifactoryOpts, CondaForgeOpts, PrefixOpts};
+use crate::utils::server_util::{
+    check_server_type, extract_anaconda_info, extract_artifactory_info, extract_conda_forge_info,
+    extract_prefix_info, extract_quetz_info, SimpleServerType,
+};
+use crate::utils::tool_configuration;
 use miette::IntoDiagnostic;
 use rattler_conda_types::package::ArchiveType;
 use upload::opt::{
-    AnacondaData, ArtifactoryData, CondaForgeData, PrefixData, QuetzData, ServerType, UploadOpts,
+    AnacondaData, ArtifactoryData, CondaForgeData, PrefixData, QuetzData, QuetzOpts, ServerType,
+    UploadOpts,
 };
 
-use crate::utils::tool_configuration;
+#[cfg(feature = "s3")]
+use crate::upload::opt::{S3Data, S3Opts};
+#[cfg(feature = "s3")]
+use crate::utils::server_util::extract_s3_info;
+#[cfg(feature = "s3")]
+use rattler_s3::clap::S3AddressingStyleOpts::VirtualHost;
+
 /// Upload package to different channels
 pub async fn upload_from_args(args: UploadOpts) -> miette::Result<()> {
     // Validate package files are provided
@@ -29,8 +42,109 @@ pub async fn upload_from_args(args: UploadOpts) -> miette::Result<()> {
     let store = tool_configuration::get_auth_store(args.common.auth_file, args.auth_store)
         .into_diagnostic()?;
 
+    // Check server type from host (if provided)
+    let detected_type: SimpleServerType = match &args.host {
+        Some(host_url) => check_server_type(host_url),
+        None => SimpleServerType::Unknown,
+    };
+
+    // Use detected type if available, otherwise fall back to provided server_type
+    let server_type = match detected_type {
+        SimpleServerType::Unknown => {
+            // If detection failed, use provided subcommand server_type or return error
+            match args.server_type {
+                Some(server_type) => server_type,
+                None => {
+                    return Err(std::io::Error::new(
+                        std::io::ErrorKind::InvalidInput,
+                        "Cannot determine server type from host and no server type provided",
+                    ))
+                    .into_diagnostic()
+                }
+            }
+        }
+        SimpleServerType::Quetz => {
+            let host_url = args.host.as_ref().unwrap();
+            let (base_url, channel) =
+                extract_quetz_info(host_url).expect("Failed to parse Quetz URL");
+            ServerType::Quetz(QuetzOpts {
+                url: base_url,
+                channels: channel,
+                api_key: None,
+            })
+        }
+        SimpleServerType::Artifactory => {
+            let host_url = args.host.as_ref().unwrap();
+            let (base_url, channel) =
+                extract_artifactory_info(host_url).expect("Failed to parse Artifactory URL");
+            ServerType::Artifactory(ArtifactoryOpts {
+                url: base_url,
+                channels: channel,
+                username: None,
+                password: None,
+                token: None,
+            })
+        }
+        SimpleServerType::Prefix => {
+            let host_url = args.host.as_ref().unwrap();
+            let (base_url, channel) =
+                extract_prefix_info(host_url).expect("Failed to parse Prefix URL");
+            ServerType::Prefix(PrefixOpts {
+                url: base_url,
+                channel,
+                api_key: None,
+                attestation: None,
+                skip_existing: false,
+            })
+        }
+        SimpleServerType::Anaconda => {
+            let host_url = args.host.as_ref().unwrap();
+            let (base_url, channel) =
+                extract_anaconda_info(host_url).expect("Failed to parse Anaconda URL");
+            ServerType::Anaconda(AnacondaOpts {
+                url: Some(base_url),
+                channels: Some(channel),
+                api_key: None,
+                owner: "".to_string(),
+                force: false,
+            })
+        }
+        #[cfg(feature = "s3")]
+        SimpleServerType::S3 => {
+            let host_url = args.host.as_ref().unwrap();
+            let (endpoint_url, channel, region) =
+                extract_s3_info(host_url).expect("Failed to parse S3 URL");
+            ServerType::S3(S3Opts {
+                channel,
+                endpoint_url,
+                region,
+                force_path_style: false,
+                access_key_id: None,
+                secret_access_key: None,
+                session_token: None,
+                credentials: None,
+                force: false,
+                addressing_style: VirtualHost,
+            })
+        }
+        SimpleServerType::CondaForge => {
+            let host_url = args.host.as_ref().unwrap();
+            let (base_url, channel) =
+                extract_conda_forge_info(host_url).expect("Failed to parse Conda Forge URL");
+            ServerType::CondaForge(CondaForgeOpts {
+                anaconda_url: Some(base_url),
+                staging_channel: Some(channel),
+                staging_token: "".to_string(),
+                feedstock: "".to_string(),
+                feedstock_token: "".to_string(),
+                validation_endpoint: None,
+                provider: None,
+                dry_run: false,
+            })
+        }
+    };
     // Upload handler based on server type
-    match args.server_type {
+    match server_type {
         ServerType::Quetz(quetz_opts) => {
             let quetz_data = QuetzData::from(quetz_opts);
             upload::upload_package_to_quetz(&store, &args.package_files, quetz_data).await
@@ -51,12 +165,14 @@ pub async fn upload_from_args(args: UploadOpts) -> miette::Result<()> {
         }
         #[cfg(feature = "s3")]
         ServerType::S3(s3_opts) => {
+            let s3_data = S3Data::from(s3_opts);
             upload::upload_package_to_s3(
                 &store,
-                s3_opts.channel,
-                s3_opts.credentials.into(),
+                s3_data.channel,
+                s3_data.credentials,
                 &args.package_files,
-                s3_opts.force,
+                s3_data.region,
+                s3_data.force, // force parameter - using false as default
             )
             .await
         }