fix(s3): use EmulatorConfig for FLOCI_HOSTNAME to fix native image crash

S3VirtualHostFilter used @ConfigProperty injection in its constructor,
which gets baked into the GraalVM native binary at build time. Setting
FLOCI_HOSTNAME at runtime via Docker env var caused an
IllegalStateException because the runtime value differed from the
build-time value (null).

Refactor to inject EmulatorConfig (which uses @ConfigMapping and is
runtime-safe) instead of raw @ConfigProperty, following the established
pattern used by StorageFactory, ServiceRegistry, RegionResolver, etc.

Also make bucket extraction hostname-aware: only treat the first label
as a bucket name when the remainder matches the configured base
hostname (or a well-known AWS S3 domain). This prevents false positives
when Floci sits behind a multi-label hostname like
floci.svc.cluster.local.

Co-Authored-By: Matej Snuderl <ematej.snuderl@gmail.com>

Author: devin-ai-integration[bot]

src/main/java/io/github/hectorvent/floci/services/s3/S3VirtualHostFilter.java

@@ -1,16 +1,26 @@
 package io.github.hectorvent.floci.services.s3;
 
+import io.github.hectorvent.floci.config.EmulatorConfig;
+import jakarta.inject.Inject;
 import jakarta.ws.rs.container.ContainerRequestContext;
 import jakarta.ws.rs.container.ContainerRequestFilter;
 import jakarta.ws.rs.container.PreMatching;
 import jakarta.ws.rs.core.UriBuilder;
 import jakarta.ws.rs.ext.Provider;
+
 import java.net.URI;
 
 @Provider
 @PreMatching
 public class S3VirtualHostFilter implements ContainerRequestFilter {
 
+    private final String baseHostname;
+
+    @Inject
+    public S3VirtualHostFilter(EmulatorConfig config) {
+        this.baseHostname = extractHostnameFromUrl(config.effectiveBaseUrl());
+    }
+
     @Override
     public void filter(ContainerRequestContext requestContext) {
         String host = requestContext.getHeaderString("Host");
@@ -22,7 +32,7 @@ public void filter(ContainerRequestContext requestContext) {
             return;
         }
 
-        // S3 does not use these content types for bucket/object operations, 
+        // S3 does not use these content types for bucket/object operations,
         // but other AWS services (AwsQuery, JSON protocols) do.
         String contentType = requestContext.getHeaderString("Content-Type");
         if (contentType != null && (
@@ -31,7 +41,7 @@ public void filter(ContainerRequestContext requestContext) {
             return;
         }
 
-        String bucket = extractBucket(host);
+        String bucket = extractBucket(host, baseHostname);
         if (bucket == null) return;
 
         URI uri = requestContext.getUriInfo().getRequestUri();
@@ -50,28 +60,27 @@ public void filter(ContainerRequestContext requestContext) {
     /**
      * Extracts a bucket name from a virtual-hosted-style Host header.
      *
-     * The first label of the hostname (before the first dot) is treated as the
-     * bucket name whenever the hostname contains at least one dot and is not an
-     * IP address. This works for any endpoint hostname — localhost, custom hosts,
-     * or S3-style domains — without requiring configuration.
+     * A request is considered virtual-hosted-style when the hostname's remainder
+     * after the first label matches the configured Floci base hostname, or when it
+     * matches a well-known AWS S3 domain pattern (for DNS-redirect setups).
      *
-     * Note: AWS SDKs automatically fall back to path-style for bucket names that
-     * contain dots, so the first-label heuristic is sufficient.
+     * Examples with baseHostname="localhost":
+     *   my-bucket.localhost:4566       → "my-bucket"
+     *   my-bucket.localhost            → "my-bucket"
+     *   floci.svc.cluster.local        → null  (no bucket prefix, path-style)
+     *   my-svc.floci.svc.cluster.local → null  (remainder doesn't match "localhost")
+     *
+     * Examples with baseHostname="floci.svc.cluster.local":
+     *   my-bucket.floci.svc.cluster.local → "my-bucket"
+     *   floci.svc.cluster.local           → null  (no bucket prefix, path-style)
      *
      * Returns null if the host does not match a virtual-hosted pattern.
      */
-    static String extractBucket(String host) {
+    static String extractBucket(String host, String baseHostname) {
         if (host == null) return null;
 
         // Strip port if present
-        String hostname = host;
-        int colonIndex = hostname.lastIndexOf(':');
-        if (colonIndex > 0) {
-            String maybePart = hostname.substring(colonIndex + 1);
-            if (!maybePart.isEmpty() && maybePart.chars().allMatch(Character::isDigit)) {
-                hostname = hostname.substring(0, colonIndex);
-            }
-        }
+        String hostname = stripPort(host);
 
         // Need at least one dot for a subdomain to exist
         int firstDot = hostname.indexOf('.');
@@ -84,7 +93,42 @@ static String extractBucket(String host) {
             return null;
         }
 
-        return hostname.substring(0, firstDot);
+        String firstLabel = hostname.substring(0, firstDot);
+        String remainder  = hostname.substring(firstDot + 1);
+
+        // Primary: remainder must match the configured base hostname
+        if (baseHostname != null && remainder.equalsIgnoreCase(baseHostname)) {
+            return firstLabel;
+        }
+
+        // Fallback: well-known AWS S3 domains, for users who route AWS DNS to Floci
+        if (isAwsS3Domain(remainder)) {
+            return firstLabel;
+        }
+
+        return null;
+    }
+
+    /** Extracts the hostname (without scheme or port) from a URL string. */
+    static String extractHostnameFromUrl(String url) {
+        if (url == null) return null;
+        try {
+            URI uri = URI.create(url);
+            return uri.getHost();
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    private static String stripPort(String host) {
+        int colonIndex = host.lastIndexOf(':');
+        if (colonIndex > 0) {
+            String maybePart = host.substring(colonIndex + 1);
+            if (!maybePart.isEmpty() && maybePart.chars().allMatch(Character::isDigit)) {
+                return host.substring(0, colonIndex);
+            }
+        }
+        return host;
     }
 
     private static boolean isIpv4Address(String hostname) {
@@ -96,4 +140,12 @@ private static boolean isIpv4Address(String hostname) {
         }
         return true;
     }
+
+    /** Returns true for *.s3.amazonaws.com and *.s3.<region>.amazonaws.com domains. */
+    private static boolean isAwsS3Domain(String remainder) {
+        if ("s3.amazonaws.com".equals(remainder)) return true;
+        // s3.<region>.amazonaws.com
+        if (remainder.startsWith("s3.") && remainder.endsWith(".amazonaws.com")) return true;
+        return false;
+    }
 }

src/test/java/io/github/hectorvent/floci/services/s3/S3VirtualHostFilterTest.java

@@ -1,5 +1,6 @@
 package io.github.hectorvent.floci.services.s3;
 
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.CsvSource;
 import org.junit.jupiter.params.provider.NullSource;
@@ -9,38 +10,84 @@
 
 class S3VirtualHostFilterTest {
 
+    // --- extractBucket with baseHostname ---
+
+    @ParameterizedTest
+    @CsvSource({
+            // Default baseHostname = localhost
+            "my-bucket.localhost:4566,       localhost,    my-bucket",
+            "my-bucket.localhost,            localhost,    my-bucket",
+            // Custom baseHostname (Docker Compose service name)
+            "my-bucket.floci:4566,           floci,        my-bucket",
+            "my-bucket.floci,                floci,        my-bucket",
+            // Multi-label baseHostname (Kubernetes)
+            "my-bucket.floci.svc.cluster.local, floci.svc.cluster.local, my-bucket",
+    })
+    void extractsBucketWithBaseHostname(String host, String baseHostname, String expectedBucket) {
+        assertEquals(expectedBucket, S3VirtualHostFilter.extractBucket(host, baseHostname));
+    }
+
+    @ParameterizedTest
+    @CsvSource({
+            // AWS S3-style domains work regardless of baseHostname
+            "my-bucket.s3.amazonaws.com,     localhost,    my-bucket",
+            "my-bucket.s3.amazonaws.com:443, localhost,    my-bucket",
+            "my-bucket.s3.us-east-1.amazonaws.com,     localhost, my-bucket",
+            "my-bucket.s3.eu-west-1.amazonaws.com:443, localhost, my-bucket",
+    })
+    void extractsBucketFromAwsS3Domains(String host, String baseHostname, String expectedBucket) {
+        assertEquals(expectedBucket, S3VirtualHostFilter.extractBucket(host, baseHostname));
+    }
+
     @ParameterizedTest
     @CsvSource({
-            // localhost variants
-            "my-bucket.localhost:4566,       my-bucket",
-            "my-bucket.localhost,            my-bucket",
-            // S3-style domains
-            "my-bucket.s3.amazonaws.com,     my-bucket",
-            "my-bucket.s3.amazonaws.com:443, my-bucket",
-            "my-bucket.s3.us-east-1.amazonaws.com,     my-bucket",
-            "my-bucket.s3.eu-west-1.amazonaws.com:443, my-bucket",
-            // Custom / arbitrary hostnames
-            "my-bucket.myhost:4566,          my-bucket",
-            "my-bucket.custom.internal:9000, my-bucket",
-            "my-bucket.emulator.local,       my-bucket",
+            // No subdomain
+            "localhost:4566,    localhost",
+            "localhost,         localhost",
+            "floci:4566,        floci",
+            // Remainder doesn't match baseHostname
+            "my-bucket.other:4566, localhost",
+            "my-bucket.wrong.host, floci.svc.cluster.local",
+            // Plain host without dots
+            "plain-host,        localhost",
+            "plain-host:8080,   localhost",
+            // IPv4 addresses
+            "192.168.1.1,       localhost",
+            "192.168.1.1:4566,  localhost",
+            "127.0.0.1,         localhost",
+            "10.0.0.1:9000,     localhost",
     })
-    void extractsBucketFromVirtualHostedStyle(String host, String expectedBucket) {
-        assertEquals(expectedBucket, S3VirtualHostFilter.extractBucket(host));
+    void returnsNullWhenNotVirtualHosted(String host, String baseHostname) {
+        assertNull(S3VirtualHostFilter.extractBucket(host, baseHostname));
     }
 
+    @Test
+    void returnsNullForNullHost() {
+        assertNull(S3VirtualHostFilter.extractBucket(null, "localhost"));
+    }
+
+    @Test
+    void returnsNullForNullBaseHostname() {
+        // Without a baseHostname, only AWS S3 domains should match
+        assertNull(S3VirtualHostFilter.extractBucket("my-bucket.localhost:4566", null));
+        assertEquals("my-bucket", S3VirtualHostFilter.extractBucket("my-bucket.s3.amazonaws.com", null));
+    }
+
+    // --- extractHostnameFromUrl ---
+
     @ParameterizedTest
     @CsvSource({
-            "localhost:4566",
-            "localhost",
-            "plain-host",
-            "plain-host:8080",
-            "192.168.1.1",
-            "192.168.1.1:4566",
-            "127.0.0.1",
-            "10.0.0.1:9000",
+            "http://localhost:4566,     localhost",
+            "http://floci:4566,         floci",
+            "http://my-host.local:4566, my-host.local",
+            "https://s3.amazonaws.com,  s3.amazonaws.com",
     })
-    @NullSource
-    void returnsNullForNonVirtualHostedStyle(String host) {
-        assertNull(S3VirtualHostFilter.extractBucket(host));
+    void extractsHostnameFromUrl(String url, String expectedHostname) {
+        assertEquals(expectedHostname, S3VirtualHostFilter.extractHostnameFromUrl(url));
+    }
+
+    @Test
+    void extractHostnameFromUrlReturnsNullForNull() {
+        assertNull(S3VirtualHostFilter.extractHostnameFromUrl(null));
     }
 }