use qubit_fs::metadata::FileSystemCapability;
use crate::ContractCheckId;
use crate::FileSystemContract;
use crate::internal::check_spec::CheckSpec;
pub(crate) const fn specification(id: ContractCheckId) -> CheckSpec {
match id {
ContractCheckId::AppendBasic => CheckSpec {
id,
copy_scenario: None,
write_scenario: Some(crate::WriteScenario::Append),
read_scenario: None,
contract: FileSystemContract::Write,
capability: Some(FileSystemCapability::Append),
asynchronous_only: false,
optional: false,
},
ContractCheckId::AsyncCopyCancelCommit => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Copy,
capability: Some(FileSystemCapability::Copy),
asynchronous_only: true,
optional: true,
},
ContractCheckId::AsyncCopyCancelNativeAttempt => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Copy,
capability: Some(FileSystemCapability::Copy),
asynchronous_only: true,
optional: true,
},
ContractCheckId::AsyncCopyCancelReader => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Copy,
capability: Some(FileSystemCapability::Copy),
asynchronous_only: true,
optional: true,
},
ContractCheckId::AsyncCopyCancelWriter => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Copy,
capability: Some(FileSystemCapability::Copy),
asynchronous_only: true,
optional: true,
},
ContractCheckId::CopyAtomicFile => CheckSpec {
id,
copy_scenario: Some(crate::CopyScenario::AtomicFile),
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Copy,
capability: Some(FileSystemCapability::AtomicFileCopy),
asynchronous_only: false,
optional: false,
},
ContractCheckId::CopyAtomicTree => CheckSpec {
id,
copy_scenario: Some(crate::CopyScenario::AtomicTree),
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Copy,
capability: Some(FileSystemCapability::AtomicTreeCopy),
asynchronous_only: false,
optional: false,
},
ContractCheckId::CopyBasic => CheckSpec {
id,
copy_scenario: Some(crate::CopyScenario::Basic),
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Copy,
capability: Some(FileSystemCapability::Copy),
asynchronous_only: false,
optional: false,
},
ContractCheckId::CopyDurableFile => CheckSpec {
id,
copy_scenario: Some(crate::CopyScenario::DurableFile),
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Copy,
capability: Some(FileSystemCapability::DurableFileCopy),
asynchronous_only: false,
optional: false,
},
ContractCheckId::CopyDurableTree => CheckSpec {
id,
copy_scenario: Some(crate::CopyScenario::DurableTree),
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Copy,
capability: Some(FileSystemCapability::DurableTreeCopy),
asynchronous_only: false,
optional: false,
},
ContractCheckId::CopyFallbackOverwriteRejected => CheckSpec {
id,
copy_scenario: Some(crate::CopyScenario::Conflict),
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Copy,
capability: Some(FileSystemCapability::Copy),
asynchronous_only: false,
optional: false,
},
ContractCheckId::CopyRepeatedExecute => CheckSpec {
id,
copy_scenario: Some(crate::CopyScenario::Basic),
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Copy,
capability: Some(FileSystemCapability::Copy),
asynchronous_only: true,
optional: false,
},
ContractCheckId::CopyServerSide => CheckSpec {
id,
copy_scenario: Some(crate::CopyScenario::ServerSide),
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Copy,
capability: Some(FileSystemCapability::ServerSideCopy),
asynchronous_only: false,
optional: false,
},
ContractCheckId::DeleteBasic => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Delete,
capability: Some(FileSystemCapability::Delete),
asynchronous_only: false,
optional: false,
},
ContractCheckId::DeleteIfMatch => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Delete,
capability: Some(FileSystemCapability::ConditionalDelete),
asynchronous_only: false,
optional: false,
},
ContractCheckId::DeleteMissingOk => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Delete,
capability: Some(FileSystemCapability::Delete),
asynchronous_only: false,
optional: false,
},
ContractCheckId::DeleteTree => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Delete,
capability: Some(FileSystemCapability::RecursiveDelete),
asynchronous_only: false,
optional: false,
},
ContractCheckId::DirectoryCreate => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::CreateDirectory,
capability: Some(FileSystemCapability::CreateDirectory),
asynchronous_only: false,
optional: false,
},
ContractCheckId::DirectoryRecursive => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::CreateDirectory,
capability: Some(FileSystemCapability::CreateDirectory),
asynchronous_only: false,
optional: false,
},
ContractCheckId::ErrorContext => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::ErrorContext,
capability: None,
asynchronous_only: false,
optional: false,
},
ContractCheckId::ListBasic => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::List,
capability: Some(FileSystemCapability::List),
asynchronous_only: false,
optional: false,
},
ContractCheckId::ListLiteralPrefix | ContractCheckId::ListNamespace | ContractCheckId::ListRawRootPrefix => {
CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::List,
capability: Some(FileSystemCapability::List),
asynchronous_only: false,
optional: false,
}
}
ContractCheckId::ListPagination => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::List,
capability: Some(FileSystemCapability::List),
asynchronous_only: false,
optional: false,
},
ContractCheckId::ListPrefix => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::List,
capability: Some(FileSystemCapability::List),
asynchronous_only: false,
optional: false,
},
ContractCheckId::PropertiesCapabilityDependencies => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Properties,
capability: None,
asynchronous_only: false,
optional: false,
},
ContractCheckId::PropertiesLimitComponentAdmission => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Properties,
capability: None,
asynchronous_only: false,
optional: true,
},
ContractCheckId::PropertiesLimitListPage => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Properties,
capability: None,
asynchronous_only: false,
optional: true,
},
ContractCheckId::PropertiesLimitPathAdmission => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Properties,
capability: None,
asynchronous_only: false,
optional: true,
},
ContractCheckId::PropertiesLimits => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Properties,
capability: None,
asynchronous_only: false,
optional: false,
},
ContractCheckId::PropertiesPathConstraints => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Properties,
capability: None,
asynchronous_only: false,
optional: false,
},
ContractCheckId::PropertiesSnapshot => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Properties,
capability: Some(FileSystemCapability::Read),
asynchronous_only: false,
optional: false,
},
ContractCheckId::PropertiesSymlinkPolicy => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Properties,
capability: None,
asynchronous_only: false,
optional: false,
},
ContractCheckId::ReadBasic => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: Some(crate::ReadScenario::Basic),
contract: FileSystemContract::Read,
capability: Some(FileSystemCapability::Read),
asynchronous_only: false,
optional: false,
},
ContractCheckId::ReadChecksum => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: Some(crate::ReadScenario::Checksum),
contract: FileSystemContract::Read,
capability: Some(FileSystemCapability::ChecksumValidation),
asynchronous_only: false,
optional: false,
},
ContractCheckId::ReadChecksumCorruption => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: Some(crate::ReadScenario::ChecksumCorruption),
contract: FileSystemContract::Read,
capability: Some(FileSystemCapability::ChecksumValidation),
asynchronous_only: false,
optional: true,
},
ContractCheckId::ReadIfMatchCurrent => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: Some(crate::ReadScenario::IfMatchCurrent),
contract: FileSystemContract::Read,
capability: Some(FileSystemCapability::ConditionalRead),
asynchronous_only: false,
optional: false,
},
ContractCheckId::ReadIfMatchStale => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: Some(crate::ReadScenario::IfMatchStale),
contract: FileSystemContract::Read,
capability: Some(FileSystemCapability::ConditionalRead),
asynchronous_only: false,
optional: false,
},
ContractCheckId::ReadIfNoneMatchCurrent => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: Some(crate::ReadScenario::IfNoneMatchCurrent),
contract: FileSystemContract::Read,
capability: Some(FileSystemCapability::ConditionalRead),
asynchronous_only: false,
optional: false,
},
ContractCheckId::ReadIfNoneMatchStale => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: Some(crate::ReadScenario::IfNoneMatchStale),
contract: FileSystemContract::Read,
capability: Some(FileSystemCapability::ConditionalRead),
asynchronous_only: false,
optional: false,
},
ContractCheckId::ReadRange => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: Some(crate::ReadScenario::Range),
contract: FileSystemContract::Read,
capability: Some(FileSystemCapability::RangeRead),
asynchronous_only: false,
optional: false,
},
ContractCheckId::ReadRangeLimit => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: Some(crate::ReadScenario::RangeLimit),
contract: FileSystemContract::Read,
capability: Some(FileSystemCapability::RangeRead),
asynchronous_only: false,
optional: true,
},
ContractCheckId::RenameAtomic => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Rename,
capability: Some(FileSystemCapability::AtomicRename),
asynchronous_only: false,
optional: false,
},
ContractCheckId::RenameBasic => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Rename,
capability: Some(FileSystemCapability::Rename),
asynchronous_only: false,
optional: false,
},
ContractCheckId::RenameConflict => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Rename,
capability: Some(FileSystemCapability::Rename),
asynchronous_only: false,
optional: false,
},
ContractCheckId::RenameDurable => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Rename,
capability: Some(FileSystemCapability::DurableRename),
asynchronous_only: false,
optional: false,
},
ContractCheckId::RepresentationEmpty => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Representations,
capability: Some(FileSystemCapability::EmptyDirectory),
asynchronous_only: false,
optional: false,
},
ContractCheckId::RepresentationSymlink => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Representations,
capability: Some(FileSystemCapability::Symlink),
asynchronous_only: false,
optional: false,
},
ContractCheckId::StatBasic => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Stat,
capability: Some(FileSystemCapability::Read),
asynchronous_only: false,
optional: false,
},
ContractCheckId::StatFileKind => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Stat,
capability: None,
asynchronous_only: false,
optional: false,
},
ContractCheckId::TempAtomic => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::TempResources,
capability: Some(FileSystemCapability::AtomicTempPersist),
asynchronous_only: false,
optional: false,
},
ContractCheckId::TempDirectory => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::TempResources,
capability: Some(FileSystemCapability::TempDirectory),
asynchronous_only: false,
optional: false,
},
ContractCheckId::TempFile => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::TempResources,
capability: Some(FileSystemCapability::TempFile),
asynchronous_only: false,
optional: false,
},
ContractCheckId::TempRepeatedLifecycle => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::TempResources,
capability: None,
asynchronous_only: false,
optional: false,
},
ContractCheckId::WriteAtomicReplaceExisting => CheckSpec {
id,
copy_scenario: None,
write_scenario: Some(crate::WriteScenario::AtomicReplace),
read_scenario: None,
contract: FileSystemContract::Write,
capability: Some(FileSystemCapability::AtomicReplace),
asynchronous_only: false,
optional: false,
},
ContractCheckId::WriteBasic => CheckSpec {
id,
copy_scenario: None,
write_scenario: Some(crate::WriteScenario::Create),
read_scenario: None,
contract: FileSystemContract::Write,
capability: Some(FileSystemCapability::Write),
asynchronous_only: false,
optional: false,
},
ContractCheckId::WriteAbort => CheckSpec {
id,
copy_scenario: None,
write_scenario: Some(crate::WriteScenario::Abort),
read_scenario: None,
contract: FileSystemContract::Write,
capability: Some(FileSystemCapability::Write),
asynchronous_only: false,
optional: false,
},
ContractCheckId::WriteReplace => CheckSpec {
id,
copy_scenario: None,
write_scenario: Some(crate::WriteScenario::Replace),
read_scenario: None,
contract: FileSystemContract::Write,
capability: Some(FileSystemCapability::Write),
asynchronous_only: false,
optional: false,
},
ContractCheckId::WriteCreateConflict => CheckSpec {
id,
copy_scenario: None,
write_scenario: Some(crate::WriteScenario::CreateConflict),
read_scenario: None,
contract: FileSystemContract::Write,
capability: Some(FileSystemCapability::Write),
asynchronous_only: false,
optional: false,
},
ContractCheckId::WriteCancelCommit => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Write,
capability: Some(FileSystemCapability::Write),
asynchronous_only: true,
optional: true,
},
ContractCheckId::WriteCancelFlush => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Write,
capability: Some(FileSystemCapability::Write),
asynchronous_only: true,
optional: true,
},
ContractCheckId::WriteCancelOpen => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Write,
capability: Some(FileSystemCapability::Write),
asynchronous_only: true,
optional: true,
},
ContractCheckId::WriteCancelWrite => CheckSpec {
id,
copy_scenario: None,
write_scenario: None,
read_scenario: None,
contract: FileSystemContract::Write,
capability: Some(FileSystemCapability::Write),
asynchronous_only: true,
optional: true,
},
ContractCheckId::WriteDurable => CheckSpec {
id,
copy_scenario: None,
write_scenario: Some(crate::WriteScenario::Durable),
read_scenario: None,
contract: FileSystemContract::Write,
capability: Some(FileSystemCapability::DurableWrite),
asynchronous_only: false,
optional: false,
},
ContractCheckId::WriteIfAbsent => CheckSpec {
id,
copy_scenario: None,
write_scenario: Some(crate::WriteScenario::IfAbsent),
read_scenario: None,
contract: FileSystemContract::Write,
capability: Some(FileSystemCapability::ConditionalWrite),
asynchronous_only: false,
optional: false,
},
ContractCheckId::WriteIfMatch => CheckSpec {
id,
copy_scenario: None,
write_scenario: Some(crate::WriteScenario::IfMatch),
read_scenario: None,
contract: FileSystemContract::Write,
capability: Some(FileSystemCapability::ConditionalWrite),
asynchronous_only: false,
optional: false,
},
ContractCheckId::WriteLimit => CheckSpec {
id,
copy_scenario: None,
write_scenario: Some(crate::WriteScenario::Create),
read_scenario: None,
contract: FileSystemContract::Write,
capability: Some(FileSystemCapability::Write),
asynchronous_only: false,
optional: true,
},
ContractCheckId::WriteOwningOperation => CheckSpec {
id,
copy_scenario: None,
write_scenario: Some(crate::WriteScenario::Create),
read_scenario: None,
contract: FileSystemContract::Write,
capability: Some(FileSystemCapability::Write),
asynchronous_only: true,
optional: false,
},
ContractCheckId::WriteRepeatedExecute => CheckSpec {
id,
copy_scenario: None,
write_scenario: Some(crate::WriteScenario::Create),
read_scenario: None,
contract: FileSystemContract::Write,
capability: Some(FileSystemCapability::Write),
asynchronous_only: true,
optional: false,
},
}
}
const WRITE_CHECKS: &[ContractCheckId] = &[
ContractCheckId::WriteBasic,
ContractCheckId::WriteCreateConflict,
ContractCheckId::WriteReplace,
ContractCheckId::WriteAbort,
ContractCheckId::WriteLimit,
ContractCheckId::WriteIfAbsent,
ContractCheckId::WriteIfMatch,
ContractCheckId::WriteAtomicReplaceExisting,
ContractCheckId::WriteDurable,
ContractCheckId::WriteOwningOperation,
ContractCheckId::WriteRepeatedExecute,
ContractCheckId::WriteCancelOpen,
ContractCheckId::WriteCancelWrite,
ContractCheckId::WriteCancelFlush,
ContractCheckId::WriteCancelCommit,
ContractCheckId::AppendBasic,
];
const COPY_CHECKS: &[ContractCheckId] = &[
ContractCheckId::CopyBasic,
ContractCheckId::CopyRepeatedExecute,
ContractCheckId::CopyFallbackOverwriteRejected,
ContractCheckId::CopyServerSide,
ContractCheckId::CopyAtomicFile,
ContractCheckId::CopyAtomicTree,
ContractCheckId::CopyDurableFile,
ContractCheckId::CopyDurableTree,
ContractCheckId::AsyncCopyCancelNativeAttempt,
ContractCheckId::AsyncCopyCancelReader,
ContractCheckId::AsyncCopyCancelWriter,
ContractCheckId::AsyncCopyCancelCommit,
];
pub(crate) fn for_contract(contract: FileSystemContract, asynchronous: bool) -> Vec<CheckSpec> {
let ids = match contract {
FileSystemContract::Write => WRITE_CHECKS,
FileSystemContract::Copy => COPY_CHECKS,
_ => ContractCheckId::ALL,
};
ids.iter()
.copied()
.map(specification)
.filter(|check| check.contract == contract && (asynchronous || !check.asynchronous_only))
.collect()
}
#[cfg(test)]
mod tests {
use std::collections::HashSet;
use super::for_contract;
use super::specification;
use crate::ContractCheckId;
use crate::FileSystemContract;
#[test]
fn each_executable_check_has_one_owner() {
let mut seen = HashSet::new();
for phase in FileSystemContract::ALL {
for check in for_contract(phase, true) {
assert!(seen.insert(check.id), "duplicate owner for {}", check.id);
assert_eq!(
check.read_scenario.is_some(),
phase == FileSystemContract::Read,
"read preparation metadata must match execution ownership for {}",
check.id
);
}
}
for id in ContractCheckId::ALL {
assert!(seen.contains(id), "missing catalog entry for {id}");
}
}
#[test]
fn prerequisites_are_cataloged_in_the_same_phase() {
for id in ContractCheckId::ALL {
let spec = specification(*id);
assert!(
!spec.prerequisites().contains(id),
"check cannot depend on itself: {id}"
);
for prerequisite in spec.prerequisites() {
assert!(
ContractCheckId::ALL.contains(prerequisite),
"unknown prerequisite for {id}"
);
assert_eq!(
specification(*prerequisite).contract,
spec.contract,
"prerequisite must be owned by the same phase: {id}"
);
}
}
}
}