mdebray/tvl-depot
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

refactor(tvix/store): remove use of lazy_static

Browse source 
This is now supported in the standard library via std::sync::LazyLock,
but requires some manual shuffling around of code.

Change-Id: Ifca792f4d2dbc36b703de4a4dfa406015ab86da7
Reviewed-on: https://cl.tvl.fyi/c/depot/+/12614
Autosubmit: flokli <flokli@flokli.de>
Reviewed-by: flokli <flokli@flokli.de>
Reviewed-by: edef <edef@edef.eu>
Tested-by: BuildkiteCI
This commit is contained in:
Florian Klink 2024-10-13 19:09:15 +03:00 committed by flokli
parent f0d594789e
commit 1c80bc4b5b
9 changed files with 118 additions and 122 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
tvix/Cargo.lock generated
View file

@ -4776,7 +4776,6 @@ dependencies = [
"ed25519-dalek",
"futures",
"hyper-util",
"lazy_static",
"lru",
"mimalloc",
"nix-compat",

4
tvix/Cargo.nix
View file

@ -15964,10 +15964,6 @@ rec {
name = "hyper-util";
packageId = "hyper-util";
}
{
name = "lazy_static";
packageId = "lazy_static";
}
{
name = "lru";
packageId = "lru";

1
tvix/Cargo.toml
View file

@ -77,7 +77,6 @@ http = "1.1.0"
hyper-util = "0.1.7"
indicatif = "0.17.8"
itertools = "0.12.1"
lazy_static = "1.5.0"
lexical-core = "0.8.5"
libc = "0.2.158"
lru = "0.12.4"

1
tvix/store/Cargo.toml
View file

@ -16,7 +16,6 @@ data-encoding = { workspace = true }
ed25519 = { workspace = true }
ed25519-dalek = { workspace = true }
futures = { workspace = true }
lazy_static = { workspace = true }
nix-compat = { path = "../nix-compat", features = ["async"] }
pin-project-lite = { workspace = true }
prost = { workspace = true }

21
tvix/store/src/composition.rs
View file

@ -1,17 +1,16 @@
use lazy_static::lazy_static;
use std::sync::LazyLock;
pub use tvix_castore::composition::*;
lazy_static! {
/// The provided registry of tvix_store, which has all the builtin
/// tvix_castore (BlobStore/DirectoryStore) and tvix_store
/// (PathInfoService) implementations.
pub static ref REG: Registry = {
let mut reg = Default::default();
add_default_services(&mut reg);
reg
};
}
/// The provided registry of tvix_store, which has all the builtin
/// tvix_castore (BlobStore/DirectoryStore) and tvix_store
/// (PathInfoService) implementations.
pub static REG: LazyLock<&'static Registry> = LazyLock::new(|| {
let mut reg = Default::default();
add_default_services(&mut reg);
// explicitly leak to get an &'static, so that we gain `&Registry: Send` from `Registry: Sync`
Box::leak(Box::new(reg))
});
/// Register the builtin services of tvix_castore and tvix_store with the given
/// registry. This is useful for creating your own registry with the builtin

8
tvix/store/src/pathinfoservice/from_addr.rs
View file

@ -57,16 +57,14 @@ pub async fn from_addr(
mod tests {
use super::from_addr;
use crate::composition::{Composition, DeserializeWithRegistry, ServiceBuilder, REG};
use lazy_static::lazy_static;
use rstest::rstest;
use std::sync::LazyLock;
use tempfile::TempDir;
use tvix_castore::blobservice::{BlobService, MemoryBlobServiceConfig};
use tvix_castore::directoryservice::{DirectoryService, MemoryDirectoryServiceConfig};
lazy_static! {
static ref TMPDIR_REDB_1: TempDir = TempDir::new().unwrap();
static ref TMPDIR_REDB_2: TempDir = TempDir::new().unwrap();
}
static TMPDIR_REDB_1: LazyLock<TempDir> = LazyLock::new(|| TempDir::new().unwrap());
static TMPDIR_REDB_2: LazyLock<TempDir> = LazyLock::new(|| TempDir::new().unwrap());
// the gRPC tests below don't fail, because we connect lazily.

18
tvix/store/src/pathinfoservice/lru.rs
View file

@ -86,22 +86,20 @@ impl ServiceBuilder for LruPathInfoServiceConfig {
#[cfg(test)]
mod test {
use nix_compat::store_path::StorePath;
use std::num::NonZeroUsize;
use std::{num::NonZeroUsize, sync::LazyLock};
use crate::{
pathinfoservice::{LruPathInfoService, PathInfo, PathInfoService},
tests::fixtures::PATH_INFO,
};
use lazy_static::lazy_static;
static PATHINFO_2: LazyLock<PathInfo> = LazyLock::new(|| {
let mut p = PATH_INFO.clone();
p.store_path = StorePath::from_name_and_digest_fixed("dummy", [1; 20]).unwrap();
p
});
lazy_static! {
static ref PATHINFO_2: PathInfo = {
let mut p = PATH_INFO.clone();
p.store_path = StorePath::from_name_and_digest_fixed("dummy", [1; 20]).unwrap();
p
};
static ref PATHINFO_2_DIGEST: [u8; 20] = *PATHINFO_2.store_path.digest();
}
static PATHINFO_2_DIGEST: LazyLock<[u8; 20]> =
LazyLock::new(|| *PATHINFO_2.store_path.digest());
#[tokio::test]
async fn evict() {

48
tvix/store/src/proto/tests/pathinfo.rs
View file

@ -1,37 +1,39 @@
use std::sync::LazyLock;
use crate::pathinfoservice::PathInfo;
use crate::proto::{self, ValidatePathInfoError};
use crate::tests::fixtures::{DUMMY_PATH, DUMMY_PATH_DIGEST, DUMMY_PATH_STR};
use bytes::Bytes;
use lazy_static::lazy_static;
use nix_compat::store_path;
use rstest::rstest;
use tvix_castore::fixtures::DUMMY_DIGEST;
use tvix_castore::proto as castorepb;
use tvix_castore::{DirectoryError, ValidateNodeError};
lazy_static! {
/// A valid PathInfo message
/// The references in `narinfo.reference_names` aligns with what's in
/// `references`.
static ref PROTO_PATH_INFO : proto::PathInfo = proto::PathInfo {
node: Some(castorepb::Node {
node: Some(castorepb::node::Node::Directory(castorepb::DirectoryNode {
name: DUMMY_PATH_STR.into(),
digest: DUMMY_DIGEST.clone().into(),
size: 0,
})),
/// A valid PathInfo message
/// The references in `narinfo.reference_names` aligns with what's in
/// `references`.
static PROTO_PATH_INFO: LazyLock<proto::PathInfo> = LazyLock::new(|| proto::PathInfo {
node: Some(castorepb::Node {
node: Some(castorepb::node::Node::Directory(castorepb::DirectoryNode {
name: DUMMY_PATH_STR.into(),
digest: DUMMY_DIGEST.clone().into(),
size: 0,
})),
}),
references: vec![DUMMY_PATH_DIGEST.as_slice().into()],
narinfo: Some(proto::NarInfo {
nar_size: 0,
nar_sha256: DUMMY_DIGEST.clone().into(),
signatures: vec![],
reference_names: vec![DUMMY_PATH_STR.to_string()],
deriver: None,
ca: Some(proto::nar_info::Ca {
r#type: proto::nar_info::ca::Hash::NarSha256.into(),
digest: DUMMY_DIGEST.clone().into(),
}),
references: vec![DUMMY_PATH_DIGEST.as_slice().into()],
narinfo: Some(proto::NarInfo {
nar_size: 0,
nar_sha256: DUMMY_DIGEST.clone().into(),
signatures: vec![],
reference_names: vec![DUMMY_PATH_STR.to_string()],
deriver: None,
ca: Some(proto::nar_info::Ca { r#type: proto::nar_info::ca::Hash::NarSha256.into(), digest: DUMMY_DIGEST.clone().into() })
}),
};
}
}),
});
#[test]
fn convert_valid() {

138
tvix/store/src/tests/fixtures.rs
View file

@ -1,11 +1,10 @@
use crate::pathinfoservice::PathInfo;
use lazy_static::lazy_static;
use nix_compat::nixhash::{CAHash, NixHash};
use nix_compat::store_path::StorePath;
use rstest::{self, *};
use rstest_reuse::*;
use std::io;
use std::sync::Arc;
use std::sync::{Arc, LazyLock};
use tvix_castore::fixtures::{
DIRECTORY_COMPLICATED, DIRECTORY_WITH_KEEP, DUMMY_DIGEST, EMPTY_BLOB_CONTENTS,
EMPTY_BLOB_DIGEST, HELLOWORLD_BLOB_CONTENTS, HELLOWORLD_BLOB_DIGEST,
@ -19,69 +18,75 @@ use tvix_castore::{
pub const DUMMY_PATH_STR: &str = "00000000000000000000000000000000-dummy";
pub const DUMMY_PATH_DIGEST: [u8; 20] = [0; 20];
lazy_static! {
pub static ref DUMMY_PATH: StorePath<String> = StorePath::from_name_and_digest_fixed("dummy", DUMMY_PATH_DIGEST).unwrap();
pub static DUMMY_PATH: LazyLock<StorePath<String>> =
LazyLock::new(|| StorePath::from_name_and_digest_fixed("dummy", DUMMY_PATH_DIGEST).unwrap());
pub static ref CASTORE_NODE_SYMLINK: Node = Node::Symlink {
target: "/nix/store/somewhereelse".try_into().unwrap(),
};
pub static CASTORE_NODE_SYMLINK: LazyLock<Node> = LazyLock::new(|| Node::Symlink {
target: "/nix/store/somewhereelse".try_into().unwrap(),
});
/// The NAR representation of a symlink pointing to `/nix/store/somewhereelse`
pub static ref NAR_CONTENTS_SYMLINK: Vec<u8> = vec![
13, 0, 0, 0, 0, 0, 0, 0, b'n', b'i', b'x', b'-', b'a', b'r', b'c', b'h', b'i', b'v', b'e', b'-', b'1', 0,
0, 0, // "nix-archive-1"
/// The NAR representation of a symlink pointing to `/nix/store/somewhereelse`
pub static NAR_CONTENTS_SYMLINK: LazyLock<Vec<u8>> = LazyLock::new(|| {
vec![
13, 0, 0, 0, 0, 0, 0, 0, b'n', b'i', b'x', b'-', b'a', b'r', b'c', b'h', b'i', b'v', b'e',
b'-', b'1', 0, 0, 0, // "nix-archive-1"
1, 0, 0, 0, 0, 0, 0, 0, b'(', 0, 0, 0, 0, 0, 0, 0, // "("
4, 0, 0, 0, 0, 0, 0, 0, b't', b'y', b'p', b'e', 0, 0, 0, 0, // "type"
7, 0, 0, 0, 0, 0, 0, 0, b's', b'y', b'm', b'l', b'i', b'n', b'k', 0, // "symlink"
6, 0, 0, 0, 0, 0, 0, 0, b't', b'a', b'r', b'g', b'e', b't', 0, 0, // target
24, 0, 0, 0, 0, 0, 0, 0, b'/', b'n', b'i', b'x', b'/', b's', b't', b'o', b'r', b'e', b'/', b's', b'o',
b'm', b'e', b'w', b'h', b'e', b'r', b'e', b'e', b'l', b's',
24, 0, 0, 0, 0, 0, 0, 0, b'/', b'n', b'i', b'x', b'/', b's', b't', b'o', b'r', b'e', b'/',
b's', b'o', b'm', b'e', b'w', b'h', b'e', b'r', b'e', b'e', b'l', b's',
b'e', // "/nix/store/somewhereelse"
1, 0, 0, 0, 0, 0, 0, 0, b')', 0, 0, 0, 0, 0, 0, 0 // ")"
];
1, 0, 0, 0, 0, 0, 0, 0, b')', 0, 0, 0, 0, 0, 0, 0, // ")"
]
});
pub static ref CASTORE_NODE_HELLOWORLD: Node = Node::File {
digest: HELLOWORLD_BLOB_DIGEST.clone(),
size: HELLOWORLD_BLOB_CONTENTS.len() as u64,
executable: false,
};
pub static CASTORE_NODE_HELLOWORLD: LazyLock<Node> = LazyLock::new(|| Node::File {
digest: HELLOWORLD_BLOB_DIGEST.clone(),
size: HELLOWORLD_BLOB_CONTENTS.len() as u64,
executable: false,
});
/// The NAR representation of a regular file with the contents "Hello World!"
pub static ref NAR_CONTENTS_HELLOWORLD: Vec<u8> = vec![
13, 0, 0, 0, 0, 0, 0, 0, b'n', b'i', b'x', b'-', b'a', b'r', b'c', b'h', b'i', b'v', b'e', b'-', b'1', 0,
0, 0, // "nix-archive-1"
/// The NAR representation of a regular file with the contents "Hello World!"
pub static NAR_CONTENTS_HELLOWORLD: LazyLock<Vec<u8>> = LazyLock::new(|| {
vec![
13, 0, 0, 0, 0, 0, 0, 0, b'n', b'i', b'x', b'-', b'a', b'r', b'c', b'h', b'i', b'v', b'e',
b'-', b'1', 0, 0, 0, // "nix-archive-1"
1, 0, 0, 0, 0, 0, 0, 0, b'(', 0, 0, 0, 0, 0, 0, 0, // "("
4, 0, 0, 0, 0, 0, 0, 0, b't', b'y', b'p', b'e', 0, 0, 0, 0, // "type"
7, 0, 0, 0, 0, 0, 0, 0, b'r', b'e', b'g', b'u', b'l', b'a', b'r', 0, // "regular"
8, 0, 0, 0, 0, 0, 0, 0, b'c', b'o', b'n', b't', b'e', b'n', b't', b's', // "contents"
12, 0, 0, 0, 0, 0, 0, 0, b'H', b'e', b'l', b'l', b'o', b' ', b'W', b'o', b'r', b'l', b'd', b'!', 0, 0,
0, 0, // "Hello World!"
1, 0, 0, 0, 0, 0, 0, 0, b')', 0, 0, 0, 0, 0, 0, 0 // ")"
];
12, 0, 0, 0, 0, 0, 0, 0, b'H', b'e', b'l', b'l', b'o', b' ', b'W', b'o', b'r', b'l', b'd',
b'!', 0, 0, 0, 0, // "Hello World!"
1, 0, 0, 0, 0, 0, 0, 0, b')', 0, 0, 0, 0, 0, 0, 0, // ")"
]
});
pub static ref CASTORE_NODE_TOO_BIG: Node = Node::File {
digest: HELLOWORLD_BLOB_DIGEST.clone(),
size: 42, // <- note the wrong size here!
executable: false,
};
pub static ref CASTORE_NODE_TOO_SMALL: Node = Node::File {
digest: HELLOWORLD_BLOB_DIGEST.clone(),
size: 2, // <- note the wrong size here!
executable: false,
};
pub static CASTORE_NODE_TOO_BIG: LazyLock<Node> = LazyLock::new(|| Node::File {
digest: HELLOWORLD_BLOB_DIGEST.clone(),
size: 42, // <- note the wrong size here!
executable: false,
});
pub static CASTORE_NODE_TOO_SMALL: LazyLock<Node> = LazyLock::new(|| Node::File {
digest: HELLOWORLD_BLOB_DIGEST.clone(),
size: 2, // <- note the wrong size here!
executable: false,
});
pub static ref CASTORE_NODE_COMPLICATED: Node = Node::Directory {
digest: DIRECTORY_COMPLICATED.digest(),
size: DIRECTORY_COMPLICATED.size(),
};
pub static CASTORE_NODE_COMPLICATED: LazyLock<Node> = LazyLock::new(|| Node::Directory {
digest: DIRECTORY_COMPLICATED.digest(),
size: DIRECTORY_COMPLICATED.size(),
});
/// The NAR representation of a more complicated directory structure.
pub static ref NAR_CONTENTS_COMPLICATED: Vec<u8> = vec![
13, 0, 0, 0, 0, 0, 0, 0, b'n', b'i', b'x', b'-', b'a', b'r', b'c', b'h', b'i', b'v', b'e', b'-', b'1', 0,
0, 0, // "nix-archive-1"
/// The NAR representation of a more complicated directory structure.
pub static NAR_CONTENTS_COMPLICATED: LazyLock<Vec<u8>> = LazyLock::new(|| {
vec![
13, 0, 0, 0, 0, 0, 0, 0, b'n', b'i', b'x', b'-', b'a', b'r', b'c', b'h', b'i', b'v', b'e',
b'-', b'1', 0, 0, 0, // "nix-archive-1"
1, 0, 0, 0, 0, 0, 0, 0, b'(', 0, 0, 0, 0, 0, 0, 0, // "("
4, 0, 0, 0, 0, 0, 0, 0, b't', b'y', b'p', b'e', 0, 0, 0, 0, // "type"
9, 0, 0, 0, 0, 0, 0, 0, b'd', b'i', b'r', b'e', b'c', b't', b'o', b'r', b'y', 0, 0, 0, 0, 0, 0, 0, // "directory"
9, 0, 0, 0, 0, 0, 0, 0, b'd', b'i', b'r', b'e', b'c', b't', b'o', b'r', b'y', 0, 0, 0, 0,
0, 0, 0, // "directory"
5, 0, 0, 0, 0, 0, 0, 0, b'e', b'n', b't', b'r', b'y', 0, 0, 0, // "entry"
1, 0, 0, 0, 0, 0, 0, 0, b'(', 0, 0, 0, 0, 0, 0, 0, // "("
4, 0, 0, 0, 0, 0, 0, 0, b'n', b'a', b'm', b'e', 0, 0, 0, 0, // "name"
@ -103,8 +108,8 @@ lazy_static! {
4, 0, 0, 0, 0, 0, 0, 0, b't', b'y', b'p', b'e', 0, 0, 0, 0, // "type"
7, 0, 0, 0, 0, 0, 0, 0, b's', b'y', b'm', b'l', b'i', b'n', b'k', 0, // "symlink"
6, 0, 0, 0, 0, 0, 0, 0, b't', b'a', b'r', b'g', b'e', b't', 0, 0, // target
24, 0, 0, 0, 0, 0, 0, 0, b'/', b'n', b'i', b'x', b'/', b's', b't', b'o', b'r', b'e', b'/', b's', b'o',
b'm', b'e', b'w', b'h', b'e', b'r', b'e', b'e', b'l', b's',
24, 0, 0, 0, 0, 0, 0, 0, b'/', b'n', b'i', b'x', b'/', b's', b't', b'o', b'r', b'e', b'/',
b's', b'o', b'm', b'e', b'w', b'h', b'e', b'r', b'e', b'e', b'l', b's',
b'e', // "/nix/store/somewhereelse"
1, 0, 0, 0, 0, 0, 0, 0, b')', 0, 0, 0, 0, 0, 0, 0, // ")"
1, 0, 0, 0, 0, 0, 0, 0, b')', 0, 0, 0, 0, 0, 0, 0, // ")"
@ -115,7 +120,8 @@ lazy_static! {
4, 0, 0, 0, 0, 0, 0, 0, b'n', b'o', b'd', b'e', 0, 0, 0, 0, // "node"
1, 0, 0, 0, 0, 0, 0, 0, b'(', 0, 0, 0, 0, 0, 0, 0, // "("
4, 0, 0, 0, 0, 0, 0, 0, b't', b'y', b'p', b'e', 0, 0, 0, 0, // "type"
9, 0, 0, 0, 0, 0, 0, 0, b'd', b'i', b'r', b'e', b'c', b't', b'o', b'r', b'y', 0, 0, 0, 0, 0, 0, 0, // "directory"
9, 0, 0, 0, 0, 0, 0, 0, b'd', b'i', b'r', b'e', b'c', b't', b'o', b'r', b'y', 0, 0, 0, 0,
0, 0, 0, // "directory"
5, 0, 0, 0, 0, 0, 0, 0, b'e', b'n', b't', b'r', b'y', 0, 0, 0, // "entry"
1, 0, 0, 0, 0, 0, 0, 0, b'(', 0, 0, 0, 0, 0, 0, 0, // "("
4, 0, 0, 0, 0, 0, 0, 0, b'n', b'a', b'm', b'e', 0, 0, 0, 0, // "name"
@ -131,23 +137,23 @@ lazy_static! {
1, 0, 0, 0, 0, 0, 0, 0, b')', 0, 0, 0, 0, 0, 0, 0, // ")"
1, 0, 0, 0, 0, 0, 0, 0, b')', 0, 0, 0, 0, 0, 0, 0, // ")"
1, 0, 0, 0, 0, 0, 0, 0, b')', 0, 0, 0, 0, 0, 0, 0, // ")"
];
]
});
/// A PathInfo message
pub static ref PATH_INFO: PathInfo = PathInfo {
store_path: DUMMY_PATH.clone(),
node: tvix_castore::Node::Directory {
digest: DUMMY_DIGEST.clone(),
size: 0,
},
references: vec![DUMMY_PATH.clone()],
nar_sha256: [0; 32],
nar_size: 0,
signatures: vec![],
deriver: None,
ca: Some(CAHash::Nar(NixHash::Sha256([0; 32]))),
};
}
/// A PathInfo message
pub static PATH_INFO: LazyLock<PathInfo> = LazyLock::new(|| PathInfo {
store_path: DUMMY_PATH.clone(),
node: tvix_castore::Node::Directory {
digest: DUMMY_DIGEST.clone(),
size: 0,
},
references: vec![DUMMY_PATH.clone()],
nar_sha256: [0; 32],
nar_size: 0,
signatures: vec![],
deriver: None,
ca: Some(CAHash::Nar(NixHash::Sha256([0; 32]))),
});
#[fixture]
pub(crate) fn blob_service() -> Arc<dyn BlobService> {