fix(ci): preserve the S3S footprint ratchet

rustfs/src/app/multipart_usecase.rs

@@ -394,7 +394,7 @@ fn require_upload_part_size(size: Option<i64>, capped: bool) -> S3Result<i64> {
         Some(size) if size >= 0 => Ok(size),
         Some(_) => Err(s3_error!(UnexpectedContent)),
         None if capped => Err(s3_error!(UnexpectedContent)),
-        None => Err(s3_error!(MissingContentLength)),
+        None => Err(S3Error::new(S3ErrorCode::MissingContentLength)),
     }
 }
 

rustfs/src/app/multipart_usecase/tests/body_read_tests.rs

@@ -14,6 +14,7 @@
 
 use super::*;
 use crate::app::object::request_body::{BodyReadControl, ObservedBody};
+use crate::app::storage_api::s3::Body as S3Body;
 use crate::app::storage_api::test::contract::bucket::{BucketOperations, MakeBucketOptions};
 use crate::app::storage_api::test::contract::object::ObjectIO;
 use http_body::Frame;
@@ -59,7 +60,7 @@ fn observed_request(
     });
     let control = BodyReadControl::default();
     let body = ObservedBody::new(http_body_util::StreamBody::new(stream), control.clone());
-    let mut request = part_request(bucket, upload, StreamingBlob::from(s3s::Body::http_body_unsync(body)), size as i64);
+    let mut request = part_request(bucket, upload, StreamingBlob::from(S3Body::http_body_unsync(body)), size as i64);
     request.extensions.insert(control);
     (request, sender, waiting, polls)
 }

rustfs/src/app/object/request_body/tests.rs

@@ -13,11 +13,10 @@
 // limitations under the License.
 
 use super::*;
+use crate::app::storage_api::s3::{Body as S3Body, S3Error, S3ErrorCode, StreamingBlob};
 use crate::error::ApiError;
 use futures::{StreamExt, poll};
 use http_body_util::StreamBody;
-use s3s::S3ErrorCode;
-use s3s::dto::StreamingBlob;
 use std::io;
 use tokio::io::AsyncReadExt;
 use tokio::sync::mpsc;
@@ -33,7 +32,7 @@ fn raw_reader(timeout: Duration) -> (FrameSender, DynReader, BodyReadControl) {
     let control = BodyReadControl::default();
     control.activate(timeout, "bucket", "object", "request", 65536);
     let body = ObservedBody::new(StreamBody::new(UnboundedReceiverStream::new(receiver)), control.clone());
-    let stream = StreamingBlob::from(s3s::Body::http_body_unsync(body));
+    let stream = StreamingBlob::from(S3Body::http_body_unsync(body));
     let reader = rustfs_rio::wrap_reader(StreamReader::new(stream.map(|item| item.map_err(io::Error::other))));
     (sender, reader, control)
 }
@@ -51,7 +50,7 @@ async fn body_stall_survives_s3s_and_io_wrapping() {
     let error = read.await.expect_err("a body that remains open must time out");
     let api = ApiError::from(error);
     assert_eq!(api.code, S3ErrorCode::RequestTimeout);
-    let s3_error = s3s::S3Error::from(api);
+    let s3_error = S3Error::from(api);
     assert_eq!(s3_error.status_code(), Some(http::StatusCode::BAD_REQUEST));
 }
 

rustfs/src/app/object/request_body/tests/protocol.rs

@@ -13,11 +13,11 @@
 // limitations under the License.
 
 use super::*;
+use crate::app::storage_api::s3::{
+    Body as S3Body, S3, S3Config, S3Error, S3Request, S3Response, S3Result, S3Service, S3ServiceBuilder, SimpleAuth,
+    StaticConfigProvider, UploadPartInput, UploadPartOutput,
+};
 use http_body_util::BodyExt;
-use s3s::config::{S3Config, StaticConfigProvider};
-use s3s::dto::{UploadPartInput, UploadPartOutput};
-use s3s::service::{S3Service, S3ServiceBuilder};
-use s3s::{S3, S3Request, S3Response, S3Result};
 use std::sync::atomic::{AtomicUsize, Ordering};
 
 #[derive(Clone, Default)]
@@ -50,7 +50,7 @@ impl S3 for Consumer {
             let count = reader
                 .read(&mut buffer)
                 .await
-                .map_err(|error| s3s::S3Error::from(ApiError::from(error)))?;
+                .map_err(|error| S3Error::from(ApiError::from(error)))?;
             if count == 0 {
                 break;
             }
@@ -68,7 +68,7 @@ impl S3 for Consumer {
 
 fn service(consumer: Consumer) -> S3Service {
     let mut builder = S3ServiceBuilder::new(consumer);
-    builder.set_auth(s3s::auth::SimpleAuth::from_single("test-access", "test-secret"));
+    builder.set_auth(SimpleAuth::from_single("test-access", "test-secret"));
     let mut config = S3Config::default();
     config.presigned_url_max_skew_time_secs = u32::MAX;
     builder.set_config(Arc::new(StaticConfigProvider::new(Arc::new(config))));
@@ -76,7 +76,7 @@ fn service(consumer: Consumer) -> S3Service {
 }
 
 struct SignedRequest {
-    request: http::Request<s3s::Body>,
+    request: http::Request<S3Body>,
     sender: FrameSender,
     prefix: Bytes,
     suffix: Bytes,
@@ -147,7 +147,7 @@ fn signed_request(payload: &[u8], unsigned_trailer: bool) -> SignedRequest {
     if unsigned_trailer {
         builder = builder.header("x-amz-trailer", "x-amz-checksum-crc32");
     }
-    let mut request = builder.body(s3s::Body::http_body_unsync(body)).expect("signed request");
+    let mut request = builder.body(S3Body::http_body_unsync(body)).expect("signed request");
     request.extensions_mut().insert(control);
     SignedRequest {
         request,

rustfs/src/app/storage_api.rs

@@ -28,9 +28,9 @@ pub(crate) fn EndpointServerPools(
 /// the direct s3s surface (s3s footprint ratchet, `scripts/check_s3s_footprint.sh`).
 pub(crate) mod s3 {
     #[cfg(test)]
-    pub(crate) use s3s::S3Response;
+    pub(crate) use s3s::auth::SimpleAuth;
     #[cfg(test)]
-    pub(crate) use s3s::dto::ListObjectsInput;
+    pub(crate) use s3s::config::{S3Config, StaticConfigProvider};
     #[cfg(test)]
     pub(crate) use s3s::dto::{
         BucketVersioningStatus, DeleteMarkerReplication, DeleteMarkerReplicationStatus, Destination, GetObjectInput,
@@ -39,7 +39,13 @@ pub(crate) mod s3 {
         ServerSideEncryptionRule, Tag, VersioningConfiguration,
     };
     #[cfg(test)]
+    pub(crate) use s3s::dto::{ListObjectsInput, StreamingBlob, UploadPartInput, UploadPartOutput};
+    #[cfg(test)]
+    pub(crate) use s3s::service::{S3Service, S3ServiceBuilder};
+    #[cfg(test)]
     pub(crate) use s3s::xml::{Serialize as XmlSerialize, Serializer as XmlSerializer};
+    #[cfg(test)]
+    pub(crate) use s3s::{Body, S3, S3Response};
     pub(crate) use s3s::{S3Error, S3ErrorCode, S3Request, S3Result};
 }