in eden/mononoke/metaconfig/parser/src/config.rs [718:1260]
fn test_read_manifest() {
let fbsource_content = r#"
generation_cache_size=1048576
scuba_table_hooks="scm_hooks"
skiplist_index_blobstore_key="skiplist_key"
storage_config="main"
list_keys_patterns_max=123
hook_max_file_size=456
repo_client_use_warm_bookmarks_cache=true
phabricator_callsign="FBS"
[cache_warmup]
bookmark="master"
commit_limit=100
[hook_manager_params]
disable_acl_checker=false
all_hooks_bypassed=false
bypassed_commits_scuba_table="commits_bypassed_hooks"
[derived_data_config]
enabled_config_name = "default"
[derived_data_config.available_configs.default]
types = ["fsnodes", "unodes", "blame"]
unode_version = 2
blame_filesize_limit = 101
[[bookmarks]]
name="master"
allowed_users="^(svcscm|twsvcscm)$"
[[bookmarks.hooks]]
hook_name="hook1"
[[bookmarks.hooks]]
hook_name="rust:rusthook"
[[bookmarks]]
regex="[^/]*/stable"
ensure_ancestor_of="master"
allow_move_to_public_commits_without_hooks=true
[[hooks]]
name="hook1"
bypass_commit_string="@allow_hook1"
[[hooks]]
name="rust:rusthook"
config_ints={ int1 = 44 }
config_ints_64={ int2 = 42 }
[hooks.config_string_lists]
list1 = ["val1", "val2"]
[push]
pure_push_allowed = false
commit_scribe_category = "cat"
[pushrebase]
rewritedates = false
recursion_limit = 1024
forbid_p2_root_rebases = false
casefolding_check = false
emit_obsmarkers = false
allow_change_xrepo_mapping_extra = true
[lfs]
threshold = 1000
rollout_percentage = 56
generate_lfs_blob_in_hg_sync_job = true
[bundle2_replay_params]
preserve_raw_bundle2 = true
[infinitepush]
allow_writes = true
namespace_pattern = "foobar/.+"
[filestore]
chunk_size = 768
concurrency = 48
[source_control_service_monitoring]
bookmarks_to_report_age= ["master", "master2"]
[repo_client_knobs]
allow_short_getpack_history = true
[segmented_changelog_config]
enabled = true
master_bookmark = "test_bookmark"
tailer_update_period_secs = 0
skip_dag_load_at_startup = true
reload_dag_save_period_secs = 0
update_to_master_bookmark_period_secs = 120
[backup_config]
verification_enabled = false
"#;
let fbsource_repo_def = r#"
repo_id=0
write_lock_db_address="write_lock_db_address"
repo_name="fbsource"
hipster_acl="foo/test"
repo_config="fbsource"
needs_backup=false
backup_source_repo_name="source"
acl_region_config="fbsource"
"#;
let www_content = r#"
scuba_table_hooks="scm_hooks"
storage_config="files"
hgsql_name = "www-foobar"
hgsql_globalrevs_name = "www-barfoo"
phabricator_callsign="WWW"
"#;
let www_repo_def = r#"
repo_id=1
repo_name="www"
repo_config="www"
"#;
let common_content = r#"
loadlimiter_category="test-category"
scuba_censored_table="censored_table"
scuba_local_path_censored="censored_local_path"
[redaction_config]
blobstore="main"
redaction_sets_location="loc"
[[whitelist_entry]]
tier = "tier1"
[[whitelist_entry]]
identity_type = "username"
identity_data = "user"
"#;
let storage = r#"
[main.metadata.remote]
primary = { db_address = "db_address" }
filenodes = { sharded = { shard_map = "db_address_shards", shard_num = 123 } }
mutation = { db_address = "mutation_db_address" }
[main.blobstore.multiplexed]
multiplex_id = 1
scuba_table = "blobstore_scuba_table"
multiplex_scuba_table = "multiplex_scuba_table"
components = [
{ blobstore_id = 0, blobstore = { manifold = { manifold_bucket = "bucket" } } },
{ blobstore_id = 1, blobstore = { blob_files = { path = "/tmp/foo" } } },
]
queue_db = { remote = { db_address = "queue_db_address" } }
minimum_successful_writes = 2
[files.metadata.local]
local_db_path = "/tmp/www"
[files.blobstore.blob_files]
path = "/tmp/www"
[files.ephemeral_blobstore]
initial_bubble_lifespan_secs = 86400
bubble_expiration_grace_secs = 3600
bubble_deletion_mode = 1
[files.ephemeral_blobstore.metadata.local]
local_db_path = "/tmp/www-ephemeral"
[files.ephemeral_blobstore.blobstore.blob_files]
path = "/tmp/www-ephemeral"
"#;
let acl_region_configs = r#"
[[fbsource.allow_rules]]
name = "name_test"
hipster_acl = "acl_test"
[[fbsource.allow_rules.regions]]
roots = ["1111111111111111111111111111111111111111111111111111111111111111"]
heads = []
path_prefixes = ["test/prefix"]
"#;
let paths = btreemap! {
"common/storage.toml" => storage,
"common/common.toml" => common_content,
"common/commitsyncmap.toml" => "",
"common/acl_regions.toml" => acl_region_configs,
"repos/fbsource/server.toml" => fbsource_content,
"repos/www/server.toml" => www_content,
"repo_definitions/fbsource/server.toml" => fbsource_repo_def,
"repo_definitions/www/server.toml" => www_repo_def,
"my_path/my_files" => "",
};
let config_store = ConfigStore::new(Arc::new(TestSource::new()), None, None);
let tmp_dir = write_files(&paths);
let repoconfig =
load_repo_configs(tmp_dir.path(), &config_store).expect("Read configs failed");
let multiplex = BlobConfig::Multiplexed {
multiplex_id: MultiplexId::new(1),
scuba_table: Some("blobstore_scuba_table".to_string()),
multiplex_scuba_table: Some("multiplex_scuba_table".to_string()),
scuba_sample_rate: nonzero!(100u64),
blobstores: vec![
(
BlobstoreId::new(0),
MultiplexedStoreType::Normal,
BlobConfig::Manifold {
bucket: "bucket".into(),
prefix: "".into(),
},
),
(
BlobstoreId::new(1),
MultiplexedStoreType::Normal,
BlobConfig::Files {
path: "/tmp/foo".into(),
},
),
],
minimum_successful_writes: nonzero!(2usize),
not_present_read_quorum: nonzero!(2usize),
queue_db: DatabaseConfig::Remote(RemoteDatabaseConfig {
db_address: "queue_db_address".into(),
}),
};
let main_storage_config = StorageConfig {
blobstore: multiplex,
metadata: MetadataDatabaseConfig::Remote(RemoteMetadataDatabaseConfig {
primary: RemoteDatabaseConfig {
db_address: "db_address".into(),
},
filenodes: ShardableRemoteDatabaseConfig::Sharded(ShardedRemoteDatabaseConfig {
shard_map: "db_address_shards".into(),
shard_num: NonZeroUsize::new(123).unwrap(),
}),
mutation: RemoteDatabaseConfig {
db_address: "mutation_db_address".into(),
},
}),
ephemeral_blobstore: None,
};
let mut repos = HashMap::new();
repos.insert(
"fbsource".to_string(),
RepoConfig {
enabled: true,
storage_config: main_storage_config.clone(),
write_lock_db_address: Some("write_lock_db_address".into()),
generation_cache_size: 1024 * 1024,
repoid: RepositoryId::new(0),
scuba_table_hooks: Some("scm_hooks".to_string()),
scuba_local_path_hooks: None,
cache_warmup: Some(CacheWarmupParams {
bookmark: BookmarkName::new("master").unwrap(),
commit_limit: 100,
microwave_preload: false,
}),
hook_manager_params: Some(HookManagerParams {
disable_acl_checker: false,
all_hooks_bypassed: false,
bypassed_commits_scuba_table: Some("commits_bypassed_hooks".to_string()),
}),
bookmarks: vec![
BookmarkParams {
bookmark: BookmarkName::new("master").unwrap().into(),
hooks: vec!["hook1".to_string(), "rust:rusthook".to_string()],
only_fast_forward: false,
allowed_users: Some(Regex::new("^(svcscm|twsvcscm)$").unwrap().into()),
allowed_hipster_group: None,
rewrite_dates: None,
hooks_skip_ancestors_of: vec![],
ensure_ancestor_of: None,
allow_move_to_public_commits_without_hooks: false,
},
BookmarkParams {
bookmark: Regex::new("[^/]*/stable").unwrap().into(),
hooks: vec![],
only_fast_forward: false,
allowed_users: None,
allowed_hipster_group: None,
rewrite_dates: None,
hooks_skip_ancestors_of: vec![],
ensure_ancestor_of: Some(BookmarkName::new("master").unwrap()),
allow_move_to_public_commits_without_hooks: true,
},
],
hooks: vec![
HookParams {
name: "hook1".to_string(),
config: HookConfig {
bypass: Some(HookBypass::new_with_commit_msg("@allow_hook1".into())),
strings: hashmap! {},
ints: hashmap! {},
ints_64: hashmap! {},
string_lists: hashmap! {},
int_lists: hashmap! {},
int_64_lists: hashmap! {},
},
},
HookParams {
name: "rust:rusthook".to_string(),
config: HookConfig {
bypass: None,
strings: hashmap! {},
ints: hashmap! {
"int1".into() => 44,
},
ints_64: hashmap! {
"int2".into() => 42,
},
string_lists: hashmap! {
"list1".into() => vec!("val1".to_owned(), "val2".to_owned()),
},
int_lists: hashmap! {},
int_64_lists: hashmap! {},
},
},
],
push: PushParams {
pure_push_allowed: false,
commit_scribe_category: Some("cat".to_string()),
},
pushrebase: PushrebaseParams {
flags: PushrebaseFlags {
rewritedates: false,
recursion_limit: Some(1024),
forbid_p2_root_rebases: false,
casefolding_check: false,
not_generated_filenodes_limit: 500,
},
block_merges: false,
emit_obsmarkers: false,
commit_scribe_category: None,
globalrevs_publishing_bookmark: None,
populate_git_mapping: false,
allow_change_xrepo_mapping_extra: true,
},
lfs: LfsParams {
threshold: Some(1000),
rollout_percentage: 56,
generate_lfs_blob_in_hg_sync_job: true,
},
hash_validation_percentage: 0,
readonly: RepoReadOnly::ReadWrite,
redaction: Redaction::Enabled,
skiplist_index_blobstore_key: Some("skiplist_key".into()),
bundle2_replay_params: Bundle2ReplayParams {
preserve_raw_bundle2: true,
},
infinitepush: InfinitepushParams {
allow_writes: true,
namespace: Some(InfinitepushNamespace::new(Regex::new("foobar/.+").unwrap())),
hydrate_getbundle_response: false,
commit_scribe_category: None,
},
list_keys_patterns_max: 123,
hook_max_file_size: 456,
filestore: Some(FilestoreParams {
chunk_size: 768,
concurrency: 48,
}),
hipster_acl: Some("foo/test".to_string()),
source_control_service: SourceControlServiceParams {
permit_writes: false,
permit_service_writes: false,
service_write_hipster_acl: None,
permit_commits_without_parents: false,
service_write_restrictions: Default::default(),
},
source_control_service_monitoring: Some(SourceControlServiceMonitoring {
bookmarks_to_report_age: vec![
BookmarkName::new("master").unwrap(),
BookmarkName::new("master2").unwrap(),
],
}),
derived_data_config: DerivedDataConfig {
enabled_config_name: "default".to_string(),
available_configs: hashmap!["default".to_string() => DerivedDataTypesConfig {
types: hashset! {
String::from("fsnodes"),
String::from("unodes"),
String::from("blame"),
},
mapping_key_prefixes: hashmap! {},
unode_version: UnodeVersion::V2,
blame_filesize_limit: Some(101),
hg_set_committer_extra: false,
blame_version: BlameVersion::V1,
},],
scuba_table: None,
},
hgsql_name: HgsqlName("fbsource".to_string()),
hgsql_globalrevs_name: HgsqlGlobalrevsName("fbsource".to_string()),
enforce_lfs_acl_check: false,
repo_client_use_warm_bookmarks_cache: true,
segmented_changelog_config: SegmentedChangelogConfig {
enabled: true,
master_bookmark: Some(String::from("test_bookmark")),
tailer_update_period: None,
skip_dag_load_at_startup: true,
reload_dag_save_period: None,
update_to_master_bookmark_period: Some(Duration::from_secs(120)),
bonsai_changesets_to_include: vec![],
},
repo_client_knobs: RepoClientKnobs {
allow_short_getpack_history: true,
},
phabricator_callsign: Some("FBS".to_string()),
backup_repo_config: Some(BackupRepoConfig {
source_repo_name: "source".to_string(),
}),
acl_region_config: Some(AclRegionConfig {
allow_rules: vec![AclRegionRule {
name: "name_test".to_string(),
regions: vec![AclRegion {
roots: vec![ONES_CSID],
heads: vec![],
path_prefixes: vec![MPath::new("test/prefix").unwrap()],
}],
hipster_acl: "acl_test".to_string(),
}],
}),
},
);
repos.insert(
"www".to_string(),
RepoConfig {
enabled: true,
storage_config: StorageConfig {
metadata: MetadataDatabaseConfig::Local(LocalDatabaseConfig {
path: "/tmp/www".into(),
}),
blobstore: BlobConfig::Files {
path: "/tmp/www".into(),
},
ephemeral_blobstore: Some(EphemeralBlobstoreConfig {
blobstore: BlobConfig::Files {
path: "/tmp/www-ephemeral".into(),
},
metadata: DatabaseConfig::Local(LocalDatabaseConfig {
path: "/tmp/www-ephemeral".into(),
}),
initial_bubble_lifespan: Duration::from_secs(86400),
bubble_expiration_grace: Duration::from_secs(3600),
bubble_deletion_mode: BubbleDeletionMode::MarkOnly,
}),
},
write_lock_db_address: None,
generation_cache_size: 10 * 1024 * 1024,
repoid: RepositoryId::new(1),
scuba_table_hooks: Some("scm_hooks".to_string()),
scuba_local_path_hooks: None,
cache_warmup: None,
hook_manager_params: None,
bookmarks: vec![],
hooks: vec![],
push: Default::default(),
pushrebase: Default::default(),
lfs: Default::default(),
hash_validation_percentage: 0,
readonly: RepoReadOnly::ReadWrite,
redaction: Redaction::Enabled,
skiplist_index_blobstore_key: None,
bundle2_replay_params: Bundle2ReplayParams::default(),
infinitepush: InfinitepushParams::default(),
list_keys_patterns_max: LIST_KEYS_PATTERNS_MAX_DEFAULT,
hook_max_file_size: HOOK_MAX_FILE_SIZE_DEFAULT,
filestore: None,
hipster_acl: None,
source_control_service: SourceControlServiceParams::default(),
source_control_service_monitoring: None,
derived_data_config: DerivedDataConfig::default(),
hgsql_name: HgsqlName("www-foobar".to_string()),
hgsql_globalrevs_name: HgsqlGlobalrevsName("www-barfoo".to_string()),
enforce_lfs_acl_check: false,
repo_client_use_warm_bookmarks_cache: false,
segmented_changelog_config: SegmentedChangelogConfig {
enabled: false,
master_bookmark: None,
tailer_update_period: Some(Duration::from_secs(45)),
skip_dag_load_at_startup: false,
reload_dag_save_period: Some(Duration::from_secs(3600)),
update_to_master_bookmark_period: Some(Duration::from_secs(60)),
bonsai_changesets_to_include: vec![],
},
repo_client_knobs: RepoClientKnobs::default(),
phabricator_callsign: Some("WWW".to_string()),
backup_repo_config: None,
acl_region_config: None,
},
);
assert_eq!(
repoconfig.common,
CommonConfig {
security_config: vec![
AllowlistEntry::Tier("tier1".to_string()),
AllowlistEntry::HardcodedIdentity {
ty: "username".to_string(),
data: "user".to_string(),
},
],
loadlimiter_category: Some("test-category".to_string()),
enable_http_control_api: false,
censored_scuba_params: CensoredScubaParams {
table: Some("censored_table".to_string()),
local_path: Some("censored_local_path".to_string()),
},
redaction_config: RedactionConfig {
blobstore: main_storage_config.blobstore.clone(),
darkstorm_blobstore: None,
redaction_sets_location: "loc".to_string(),
},
}
);
assert_eq!(
repoconfig.repos.get("www"),
repos.get("www"),
"www mismatch\ngot {:#?}\nwant {:#?}",
repoconfig.repos.get("www"),
repos.get("www")
);
assert_eq!(
repoconfig.repos.get("fbsource"),
repos.get("fbsource"),
"fbsource mismatch\ngot {:#?}\nwant {:#?}",
repoconfig.repos.get("fbsource"),
repos.get("fbsource")
);
assert_eq!(
&repoconfig.repos, &repos,
"Repo mismatch:\n\
got:\n\
{:#?}\n\
Want:\n\
{:#?}",
repoconfig.repos, repos
)
}