refactor: narrow test harness compatibility surfaces (#3592)

crates/e2e_test/src/storage_compat.rs

@@ -15,5 +15,19 @@
 pub(crate) mod ecstore {
     #![allow(unused_imports)]
 
-    pub(crate) use rustfs_ecstore::{bucket, disk, rpc};
+    pub(crate) mod bucket {
+        pub(crate) mod bucket_target_sys {
+            pub(crate) use rustfs_ecstore::bucket::bucket_target_sys::BucketTargetSys;
+        }
+    }
+
+    pub(crate) mod disk {
+        pub(crate) use rustfs_ecstore::disk::{VolumeInfo, WalkDirOptions};
+    }
+
+    pub(crate) mod rpc {
+        pub(crate) use rustfs_ecstore::rpc::{
+            TonicInterceptor, gen_tonic_signature_interceptor, node_service_time_out_client, node_service_time_out_client_no_auth,
+        };
+    }
 }

crates/ecstore/src/bucket/lifecycle/bucket_lifecycle_ops.rs

@@ -15,7 +15,7 @@
 use crate::bucket::lifecycle::bucket_lifecycle_audit::{LcAuditEvent, LcEventSrc};
 use crate::bucket::lifecycle::evaluator::Evaluator;
 use crate::bucket::lifecycle::lifecycle::{
-    self, ExpirationOptions, Lifecycle, ObjectOpts, TransitionOptions, abort_incomplete_multipart_upload_due,
+    self, Lifecycle, ObjectOpts, TransitionOptions, abort_incomplete_multipart_upload_due,
 };
 use crate::bucket::lifecycle::tier_delete_journal::{process_tier_delete_journal_entry, run_tier_delete_journal_recovery_loop};
 use crate::bucket::lifecycle::tier_free_version_recovery::{DEFAULT_FREE_VERSION_RECOVERY_LIMIT, recover_tier_free_versions};
@@ -59,7 +59,8 @@ use rustfs_filemeta::{
 };
 use rustfs_s3_types::EventName;
 use rustfs_storage_api::{
-    DeletedObject, HTTPRangeSpec, ListOperations as _, MultipartOperations as _, ObjectOperations as _, ObjectToDelete,
+    DeletedObject, ExpirationOptions, HTTPRangeSpec, ListOperations as _, MultipartOperations as _, ObjectOperations as _,
+    ObjectToDelete,
 };
 use rustfs_utils::{get_env_i64, get_env_usize, path::encode_dir_object, string::strings_has_prefix_fold};
 use s3s::dto::{
@@ -379,14 +380,7 @@ pub trait ExpiryOp: 'static {
     fn as_any(&self) -> &dyn Any;
 }
 
-#[derive(Debug, Default, Clone)]
-pub struct TransitionedObject {
-    pub name: String,
-    pub version_id: String,
-    pub tier: String,
-    pub free_version: bool,
-    pub status: String,
-}
+pub use rustfs_storage_api::TransitionedObject;
 
 struct FreeVersionTask(ObjectInfo);
 
@@ -2862,7 +2856,6 @@ mod tests {
         transitioned_cleanup_tuple,
     };
     use crate::bucket::lifecycle::bucket_lifecycle_audit::LcEventSrc;
-    use crate::bucket::lifecycle::core::ExpirationOptions;
     use crate::bucket::lifecycle::tier_sweeper::Jentry;
     use crate::bucket::metadata::BUCKET_LIFECYCLE_CONFIG;
     use crate::bucket::metadata_sys;
@@ -2877,6 +2870,7 @@ mod tests {
     use rustfs_common::metrics::{IlmAction, global_metrics};
     use rustfs_config::ENV_TRANSITION_WORKERS_ABSOLUTE_MAX;
     use rustfs_filemeta::{ReplicateDecision, VersionPurgeStatusType};
+    use rustfs_storage_api::ExpirationOptions;
     use rustfs_storage_api::{BucketOperations, BucketOptions, MakeBucketOptions, MultipartOperations as _};
     use s3s::dto::{BucketLifecycleConfiguration, ExpirationStatus, LifecycleExpiration, LifecycleRule, Timestamp};
     use serial_test::serial;

crates/ecstore/src/bucket/lifecycle/core.rs

@@ -934,10 +934,7 @@ impl Default for Event {
     }
 }
 
-#[derive(Debug, Clone, Default)]
-pub struct ExpirationOptions {
-    pub expire: bool,
-}
+pub use rustfs_storage_api::ExpirationOptions;
 
 #[derive(Debug, Clone)]
 pub struct TransitionOptions {

crates/ecstore/src/bucket/lifecycle/tier_sweeper.rs

@@ -18,12 +18,13 @@
 #![allow(unused_must_use)]
 #![allow(clippy::all)]
 
-use crate::bucket::lifecycle::bucket_lifecycle_ops::{ExpiryOp, GLOBAL_ExpiryState, TransitionedObject};
+use crate::bucket::lifecycle::bucket_lifecycle_ops::{ExpiryOp, GLOBAL_ExpiryState};
 use crate::bucket::lifecycle::lifecycle::{self, ObjectOpts};
 use crate::bucket::lifecycle::tier_delete_journal::persist_tier_delete_journal_entry;
 use crate::client::signer_error::error_chain_contains_signer_header_marker;
 use crate::global::GLOBAL_TierConfigMgr;
 use crate::store::ECStore;
+use rustfs_storage_api::TransitionedObject;
 use rustfs_utils::get_env_usize;
 use sha2::{Digest, Sha256};
 use std::any::Any;

crates/ecstore/src/set_disk.rs

@@ -5004,7 +5004,6 @@ pub fn is_infrequent_access_class(storage_class: &str) -> bool {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::bucket::lifecycle::bucket_lifecycle_ops::TransitionedObject;
     use crate::disk::CHECK_PART_UNKNOWN;
     use crate::disk::CHECK_PART_VOLUME_NOT_FOUND;
     use crate::disk::RUSTFS_META_BUCKET;
@@ -5023,6 +5022,7 @@ mod tests {
     use rustfs_filemeta::ReplicationState;
     use rustfs_lock::client::local::LocalClient;
     use rustfs_lock::{LockError, LockInfo, LockResponse, LockStats};
+    use rustfs_storage_api::TransitionedObject;
     use rustfs_storage_api::{CompletePart, NamespaceLocking as _, ObjectOperations as _};
     use serial_test::serial;
     use std::collections::HashMap;

crates/ecstore/src/store/object.rs

@@ -1267,9 +1267,9 @@ impl ECStore {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::bucket::lifecycle::bucket_lifecycle_ops::TransitionedObject;
     use crate::bucket::lifecycle::core::TRANSITION_COMPLETE;
     use bytes::Bytes;
+    use rustfs_storage_api::TransitionedObject;
     use std::io::Cursor;
     use tokio::io::AsyncReadExt;
 

crates/ecstore/src/store_api.rs

@@ -18,11 +18,7 @@ use crate::config::storageclass;
 use crate::error::{Error, Result};
 use crate::rio::{HashReader, LimitReader};
 use crate::store_utils::clean_metadata;
-use crate::{
-    bucket::lifecycle::bucket_lifecycle_audit::LcAuditEvent,
-    bucket::lifecycle::lifecycle::ExpirationOptions,
-    bucket::lifecycle::{bucket_lifecycle_ops::TransitionedObject, lifecycle::TransitionOptions},
-};
+use crate::{bucket::lifecycle::bucket_lifecycle_audit::LcAuditEvent, bucket::lifecycle::lifecycle::TransitionOptions};
 use bytes::Bytes;
 use http::{HeaderMap, HeaderValue};
 use rustfs_common::heal_channel::HealOpts;
@@ -34,7 +30,7 @@ use rustfs_filemeta::{
 use rustfs_lock::NamespaceLockWrapper;
 use rustfs_madmin::heal_commands::HealResultItem;
 use rustfs_rio::Checksum;
-use rustfs_storage_api::HTTPRangeSpec;
+use rustfs_storage_api::{ExpirationOptions, HTTPRangeSpec, TransitionedObject};
 use rustfs_utils::CompressionAlgorithm;
 use rustfs_utils::http::headers::AMZ_OBJECT_TAGGING;
 use rustfs_utils::http::{AMZ_BUCKET_REPLICATION_STATUS, AMZ_RESTORE, AMZ_STORAGE_CLASS};

crates/heal/tests/common/storage_compat.rs

@@ -15,5 +15,25 @@
 pub(crate) mod ecstore {
     #![allow(unused_imports)]
 
-    pub(crate) use rustfs_ecstore::{bucket, disk, endpoints, store};
+    pub(crate) mod bucket {
+        pub(crate) mod metadata_sys {
+            pub(crate) use rustfs_ecstore::bucket::metadata_sys::init_bucket_metadata_sys;
+        }
+    }
+
+    pub(crate) mod disk {
+        pub(crate) use rustfs_ecstore::disk::DiskStore;
+
+        pub(crate) mod endpoint {
+            pub(crate) use rustfs_ecstore::disk::endpoint::Endpoint;
+        }
+    }
+
+    pub(crate) mod endpoints {
+        pub(crate) use rustfs_ecstore::endpoints::{EndpointServerPools, Endpoints, PoolEndpoints};
+    }
+
+    pub(crate) mod store {
+        pub(crate) use rustfs_ecstore::store::{ECStore, init_local_disks};
+    }
 }

crates/notify/Cargo.toml

@@ -60,6 +60,7 @@ quick-xml = { workspace = true, features = ["serialize", "serde-types", "encodin
 tokio = { workspace = true, features = ["test-util"] }
 tracing-subscriber = { workspace = true, features = ["env-filter"] }
 axum = { workspace = true }
+rustfs-storage-api = { workspace = true }
 rustfs-utils = { workspace = true, features = ["path"] }
 serde_json = { workspace = true }
 time = { workspace = true }

crates/notify/src/storage_compat.rs

@@ -79,7 +79,7 @@ impl From<EcstoreObjectInfo> for NotifyObjectInfo {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use rustfs_ecstore::bucket::lifecycle::bucket_lifecycle_ops::TransitionedObject;
+    use rustfs_storage_api::TransitionedObject;
     use std::{collections::HashMap, sync::Arc};
     use time::{Duration, OffsetDateTime};
 

crates/policy/src/policy/action.rs

@@ -412,10 +412,6 @@ pub enum AdminAction {
     TraceAdminAction,
     #[strum(serialize = "admin:ConsoleLog")]
     ConsoleLogAdminAction,
-    #[strum(serialize = "admin:KMSCreateKey")]
-    KMSCreateKeyAdminAction,
-    #[strum(serialize = "admin:KMSKeyStatus")]
-    KMSKeyStatusAdminAction,
     #[strum(serialize = "admin:ServerInfo")]
     ServerInfoAdminAction,
     #[strum(serialize = "admin:OBDInfo")]
@@ -614,8 +610,6 @@ impl AdminAction {
                 | AdminAction::ProfilingAdminAction
                 | AdminAction::TraceAdminAction
                 | AdminAction::ConsoleLogAdminAction
-                | AdminAction::KMSCreateKeyAdminAction
-                | AdminAction::KMSKeyStatusAdminAction
                 | AdminAction::ServerInfoAdminAction
                 | AdminAction::HealthInfoAdminAction
                 | AdminAction::LicenseInfoAdminAction
@@ -768,6 +762,13 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_legacy_kms_admin_actions_are_rejected() {
+        for raw in ["admin:KMSCreateKey", "admin:KMSKeyStatus"] {
+            assert!(Action::try_from(raw).is_err(), "{raw} should not parse as a policy action");
+        }
+    }
+
     #[test]
     fn test_kms_wildcard_matches_dedicated_actions() {
         let wildcard = Action::try_from("kms:*").expect("Should parse KMS wildcard action");

crates/scanner/tests/common/storage_compat.rs

@@ -13,5 +13,69 @@
 // limitations under the License.
 
 pub(crate) mod ecstore {
-    pub(crate) use rustfs_ecstore::{bucket, client, disk, endpoints, global, pools, store, tier};
+    #![allow(unused_imports)]
+
+    pub(crate) mod bucket {
+        pub(crate) mod lifecycle {
+            pub(crate) use rustfs_ecstore::bucket::lifecycle::lifecycle::TransitionOptions;
+
+            pub(crate) mod bucket_lifecycle_ops {
+                pub(crate) use rustfs_ecstore::bucket::lifecycle::bucket_lifecycle_ops::{
+                    enqueue_transition_for_existing_objects, init_background_expiry,
+                };
+            }
+        }
+
+        pub(crate) mod metadata {
+            pub(crate) use rustfs_ecstore::bucket::metadata::BUCKET_LIFECYCLE_CONFIG;
+        }
+
+        pub(crate) mod metadata_sys {
+            pub(crate) use rustfs_ecstore::bucket::metadata_sys::{get, init_bucket_metadata_sys, update};
+        }
+
+        pub(crate) mod versioning_sys {
+            pub(crate) use rustfs_ecstore::bucket::versioning_sys::BucketVersioningSys;
+        }
+    }
+
+    pub(crate) mod client {
+        pub(crate) mod transition_api {
+            pub(crate) use rustfs_ecstore::client::transition_api::{ReadCloser, ReaderImpl};
+        }
+    }
+
+    pub(crate) mod disk {
+        pub(crate) use rustfs_ecstore::disk::{DiskAPI, DiskOption, STORAGE_FORMAT_FILE, new_disk};
+
+        pub(crate) mod endpoint {
+            pub(crate) use rustfs_ecstore::disk::endpoint::Endpoint;
+        }
+    }
+
+    pub(crate) mod endpoints {
+        pub(crate) use rustfs_ecstore::endpoints::{EndpointServerPools, Endpoints, PoolEndpoints};
+    }
+
+    pub(crate) mod global {
+        pub(crate) use rustfs_ecstore::global::GLOBAL_TierConfigMgr;
+    }
+
+    pub(crate) mod pools {
+        pub(crate) use rustfs_ecstore::pools::path2_bucket_object_with_base_path;
+    }
+
+    pub(crate) mod store {
+        pub(crate) use rustfs_ecstore::store::{ECStore, init_local_disks};
+    }
+
+    pub(crate) mod tier {
+        pub(crate) mod tier_config {
+            pub(crate) use rustfs_ecstore::tier::tier_config::{TierConfig, TierMinIO, TierType};
+        }
+
+        pub(crate) mod warm_backend {
+            pub(crate) use rustfs_ecstore::tier::warm_backend::{WarmBackend, WarmBackendGetOpts, build_transition_put_options};
+        }
+    }
 }

crates/scanner/tests/lifecycle_integration_test.rs

@@ -15,10 +15,10 @@
 mod common;
 
 use crate::common::storage_compat::ecstore::{
-    bucket::lifecycle::lifecycle::TransitionOptions,
     bucket::metadata::BUCKET_LIFECYCLE_CONFIG,
     bucket::{
-        lifecycle::bucket_lifecycle_ops::enqueue_transition_for_existing_objects, metadata_sys,
+        lifecycle::{TransitionOptions, bucket_lifecycle_ops::enqueue_transition_for_existing_objects},
+        metadata_sys,
         versioning_sys::BucketVersioningSys,
     },
     client::transition_api::{ReadCloser, ReaderImpl},

crates/storage-api/src/lib.rs

@@ -25,6 +25,7 @@ pub use bucket::{BucketInfo, BucketOperations, BucketOptions, DeleteBucketOption
 pub use error::{StorageErrorCode, StorageResult};
 pub use multipart::{CompletePart, ListMultipartsInfo, ListPartsInfo, MultipartInfo, MultipartUploadResult, PartInfo};
 pub use object::{DeletedObject, ObjectToDelete};
+pub use object::{ExpirationOptions, TransitionedObject};
 pub use object::{HTTPPreconditions, HTTPRangeError, HTTPRangeSpec, ObjectLockRetentionOptions};
 pub use object::{HealOperations, MultipartOperations, NamespaceLocking, ObjectIO, ObjectOperations};
 pub use object::{ListObjectVersionsInfo, ListObjectsInfo, ListObjectsV2Info, ListOperations, ObjectInfoOrErr};

crates/storage-api/src/object.rs

@@ -48,6 +48,20 @@ pub struct ObjectLockRetentionOptions {
     pub bypass_governance: bool,
 }
 
+#[derive(Debug, Clone, Default)]
+pub struct ExpirationOptions {
+    pub expire: bool,
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct TransitionedObject {
+    pub name: String,
+    pub version_id: String,
+    pub tier: String,
+    pub free_version: bool,
+    pub status: String,
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct ObjectPreconditionPart {
     pub number: usize,
@@ -797,6 +811,19 @@ mod tests {
         assert_eq!(object.delete_marker_replication_status(), ReplicationStatusType::Empty);
     }
 
+    #[test]
+    fn lifecycle_helper_defaults_preserve_existing_contracts() {
+        let expiration = ExpirationOptions::default();
+        let transitioned = TransitionedObject::default();
+
+        assert!(!expiration.expire);
+        assert!(transitioned.name.is_empty());
+        assert!(transitioned.version_id.is_empty());
+        assert!(transitioned.tier.is_empty());
+        assert!(!transitioned.free_version);
+        assert!(transitioned.status.is_empty());
+    }
+
     #[derive(Debug)]
     struct TestListBackend;