noth/surrealpatch
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Replaces option_env by std::env::var ()

Browse source
This commit is contained in:
Emmanuel Keller 2024-03-27 18:19:54 +00:00 committed by GitHub
parent 5d3e537abe
commit ea8810d905
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
5 changed files with 108 additions and 129 deletions
core/src
cnf
mod.rs
kvs
rocksdb
cnf.rs
speedb
cnf.rs
mac
mod.rs
src/cnf
mod.rs

12
core/src/cnf/mod.rs
View file

@ -17,9 +17,8 @@ pub const MAX_CONCURRENT_TASKS: usize = 64;
/// During query execution, all potentially-recursive code paths count against this limit. Whereas
/// parsing assigns equal weight to each recursion, certain expensive code paths are allowed to
/// count for more than one unit of depth during execution.
pub static MAX_COMPUTATION_DEPTH: Lazy<u8> = Lazy::new(|| {
option_env!("SURREAL_MAX_COMPUTATION_DEPTH").and_then(|s| s.parse::<u8>().ok()).unwrap_or(120)
});
pub static MAX_COMPUTATION_DEPTH: Lazy<u8> =
lazy_env_parse!("SURREAL_MAX_COMPUTATION_DEPTH", u8, 120);
/// Specifies the names of parameters which can not be specified in a query.
pub const PROTECTED_PARAM_NAMES: &[&str] = &["auth", "scope", "token", "session"];
@ -37,8 +36,5 @@ pub const SERVER_NAME: &str = "SurrealDB";
pub const PROCESSOR_BATCH_SIZE: u32 = 50;
/// Forward all signup/signin query errors to a client trying authenticate to a scope. Do not use in production.
pub static INSECURE_FORWARD_SCOPE_ERRORS: Lazy<bool> = Lazy::new(|| {
option_env!("SURREAL_INSECURE_FORWARD_SCOPE_ERRORS")
.and_then(|s| s.parse::<bool>().ok())
.unwrap_or(false)
});
pub static INSECURE_FORWARD_SCOPE_ERRORS: Lazy<bool> =
lazy_env_parse!("SURREAL_INSECURE_FORWARD_SCOPE_ERRORS", bool, false);

64
core/src/kvs/rocksdb/cnf.rs
View file

@ -1,55 +1,29 @@
use crate::{lazy_env_parse, lazy_env_parse_or_else};
use once_cell::sync::Lazy;
pub static ROCKSDB_THREAD_COUNT: Lazy<i32> = Lazy::new(|| {
option_env!("SURREAL_ROCKSDB_THREAD_COUNT")
.and_then(|s| s.parse::<i32>().ok())
.unwrap_or(num_cpus::get() as i32)
});
pub static ROCKSDB_THREAD_COUNT: Lazy<i32> =
lazy_env_parse_or_else!("SURREAL_ROCKSDB_THREAD_COUNT", i32, |_| num_cpus::get() as i32);
pub static ROCKSDB_WRITE_BUFFER_SIZE: Lazy<usize> = Lazy::new(|| {
option_env!("SURREAL_ROCKSDB_WRITE_BUFFER_SIZE")
.and_then(|s| s.parse::<usize>().ok())
.unwrap_or(256 * 1024 * 1024)
});
pub static ROCKSDB_WRITE_BUFFER_SIZE: Lazy<usize> =
lazy_env_parse!("SURREAL_ROCKSDB_WRITE_BUFFER_SIZE", usize, 256 * 1024 * 1024);
pub static ROCKSDB_TARGET_FILE_SIZE_BASE: Lazy<u64> = Lazy::new(|| {
option_env!("SURREAL_ROCKSDB_TARGET_FILE_SIZE_BASE")
.and_then(|s| s.parse::<u64>().ok())
.unwrap_or(512 * 1024 * 1024)
});
pub static ROCKSDB_TARGET_FILE_SIZE_BASE: Lazy<u64> =
lazy_env_parse!("SURREAL_ROCKSDB_TARGET_FILE_SIZE_BASE", u64, 512 * 1024 * 1024);
pub static ROCKSDB_MAX_WRITE_BUFFER_NUMBER: Lazy<i32> = Lazy::new(|| {
option_env!("SURREAL_ROCKSDB_MAX_WRITE_BUFFER_NUMBER")
.and_then(|s| s.parse::<i32>().ok())
.unwrap_or(32)
});
pub static ROCKSDB_MAX_WRITE_BUFFER_NUMBER: Lazy<i32> =
lazy_env_parse!("SURREAL_ROCKSDB_MAX_WRITE_BUFFER_NUMBER", i32, 32);
pub static ROCKSDB_MIN_WRITE_BUFFER_NUMBER_TO_MERGE: Lazy<i32> = Lazy::new(|| {
option_env!("SURREAL_ROCKSDB_MIN_WRITE_BUFFER_NUMBER_TO_MERGE")
.and_then(|s| s.parse::<i32>().ok())
.unwrap_or(4)
});
pub static ROCKSDB_MIN_WRITE_BUFFER_NUMBER_TO_MERGE: Lazy<i32> =
lazy_env_parse!("SURREAL_ROCKSDB_MIN_WRITE_BUFFER_NUMBER_TO_MERGE", i32, 4);
pub static ROCKSDB_ENABLE_PIPELINED_WRITES: Lazy<bool> = Lazy::new(|| {
option_env!("SURREAL_ROCKSDB_ENABLE_PIPELINED_WRITES")
.and_then(|s| s.parse::<bool>().ok())
.unwrap_or(true)
});
pub static ROCKSDB_ENABLE_PIPELINED_WRITES: Lazy<bool> =
lazy_env_parse!("SURREAL_ROCKSDB_ENABLE_PIPELINED_WRITES", bool, true);
pub static ROCKSDB_ENABLE_BLOB_FILES: Lazy<bool> = Lazy::new(|| {
option_env!("SURREAL_ROCKSDB_ENABLE_BLOB_FILES")
.and_then(|s| s.parse::<bool>().ok())
.unwrap_or(true)
});
pub static ROCKSDB_ENABLE_BLOB_FILES: Lazy<bool> =
lazy_env_parse!("SURREAL_ROCKSDB_ENABLE_BLOB_FILES", bool, true);
pub static ROCKSDB_MIN_BLOB_SIZE: Lazy<u64> = Lazy::new(|| {
option_env!("SURREAL_ROCKSDB_MIN_BLOB_SIZE")
.and_then(|s| s.parse::<u64>().ok())
.unwrap_or(4 * 1024)
});
pub static ROCKSDB_MIN_BLOB_SIZE: Lazy<u64> =
lazy_env_parse!("SURREAL_ROCKSDB_MIN_BLOB_SIZE", u64, 4 * 1024);
pub static ROCKSDB_KEEP_LOG_FILE_NUM: Lazy<usize> = Lazy::new(|| {
option_env!("SURREAL_ROCKSDB_KEEP_LOG_FILE_NUM")
.and_then(|s| s.parse::<usize>().ok())
.unwrap_or(20)
});
pub static ROCKSDB_KEEP_LOG_FILE_NUM: Lazy<usize> =
lazy_env_parse!("SURREAL_ROCKSDB_KEEP_LOG_FILE_NUM", usize, 20);

64
core/src/kvs/speedb/cnf.rs
View file

@ -1,55 +1,29 @@
use crate::{lazy_env_parse, lazy_env_parse_or_else};
use once_cell::sync::Lazy;
pub static SPEEDB_THREAD_COUNT: Lazy<i32> = Lazy::new(|| {
option_env!("SURREAL_SPEEDB_THREAD_COUNT")
.and_then(|s| s.parse::<i32>().ok())
.unwrap_or(num_cpus::get() as i32)
});
pub static SPEEDB_THREAD_COUNT: Lazy<i32> =
lazy_env_parse_or_else!("SURREAL_SPEEDB_THREAD_COUNT", i32, |_| num_cpus::get() as i32);
pub static SPEEDB_WRITE_BUFFER_SIZE: Lazy<usize> = Lazy::new(|| {
option_env!("SURREAL_SPEEDB_WRITE_BUFFER_SIZE")
.and_then(|s| s.parse::<usize>().ok())
.unwrap_or(256 * 1024 * 1024)
});
pub static SPEEDB_WRITE_BUFFER_SIZE: Lazy<usize> =
lazy_env_parse!("SURREAL_SPEEDB_WRITE_BUFFER_SIZE", usize, 256 * 1024 * 1024);
pub static SPEEDB_TARGET_FILE_SIZE_BASE: Lazy<u64> = Lazy::new(|| {
option_env!("SURREAL_SPEEDB_TARGET_FILE_SIZE_BASE")
.and_then(|s| s.parse::<u64>().ok())
.unwrap_or(512 * 1024 * 1024)
});
pub static SPEEDB_TARGET_FILE_SIZE_BASE: Lazy<u64> =
lazy_env_parse!("SURREAL_SPEEDB_TARGET_FILE_SIZE_BASE", u64, 512 * 1024 * 1024);
pub static SPEEDB_MAX_WRITE_BUFFER_NUMBER: Lazy<i32> = Lazy::new(|| {
option_env!("SURREAL_SPEEDB_MAX_WRITE_BUFFER_NUMBER")
.and_then(|s| s.parse::<i32>().ok())
.unwrap_or(32)
});
pub static SPEEDB_MAX_WRITE_BUFFER_NUMBER: Lazy<i32> =
lazy_env_parse!("SURREAL_SPEEDB_MAX_WRITE_BUFFER_NUMBER", i32, 32);
pub static SPEEDB_MIN_WRITE_BUFFER_NUMBER_TO_MERGE: Lazy<i32> = Lazy::new(|| {
option_env!("SURREAL_SPEEDB_MIN_WRITE_BUFFER_NUMBER_TO_MERGE")
.and_then(|s| s.parse::<i32>().ok())
.unwrap_or(4)
});
pub static SPEEDB_MIN_WRITE_BUFFER_NUMBER_TO_MERGE: Lazy<i32> =
lazy_env_parse!("SURREAL_SPEEDB_MIN_WRITE_BUFFER_NUMBER_TO_MERGE", i32, 4);
pub static SPEEDB_ENABLE_PIPELINED_WRITES: Lazy<bool> = Lazy::new(|| {
option_env!("SURREAL_SPEEDB_ENABLE_PIPELINED_WRITES")
.and_then(|s| s.parse::<bool>().ok())
.unwrap_or(true)
});
pub static SPEEDB_ENABLE_PIPELINED_WRITES: Lazy<bool> =
lazy_env_parse!("SURREAL_SPEEDB_ENABLE_PIPELINED_WRITES", bool, true);
pub static SPEEDB_ENABLE_BLOB_FILES: Lazy<bool> = Lazy::new(|| {
option_env!("SURREAL_SPEEDB_ENABLE_BLOB_FILES")
.and_then(|s| s.parse::<bool>().ok())
.unwrap_or(true)
});
pub static SPEEDB_ENABLE_BLOB_FILES: Lazy<bool> =
lazy_env_parse!("SURREAL_SPEEDB_ENABLE_BLOB_FILES", bool, true);
pub static SPEEDB_MIN_BLOB_SIZE: Lazy<u64> = Lazy::new(|| {
option_env!("SURREAL_SPEEDB_MIN_BLOB_SIZE")
.and_then(|s| s.parse::<u64>().ok())
.unwrap_or(4 * 1024)
});
pub static SPEEDB_MIN_BLOB_SIZE: Lazy<u64> =
lazy_env_parse!("SURREAL_SPEEDB_MIN_BLOB_SIZE", u64, 4 * 1024);
pub static SPEEDB_KEEP_LOG_FILE_NUM: Lazy<usize> = Lazy::new(|| {
option_env!("SURREAL_SPEEDB_KEEP_LOG_FILE_NUM")
.and_then(|s| s.parse::<usize>().ok())
.unwrap_or(20)
});
pub static SPEEDB_KEEP_LOG_FILE_NUM: Lazy<usize> =
lazy_env_parse!("SURREAL_SPEEDB_KEEP_LOG_FILE_NUM", usize, 20);

48
core/src/mac/mod.rs
View file

@ -27,3 +27,51 @@ macro_rules! get_cfg {
let $i = || { $( if cfg!($i=$s) { return $s; } );+ "unknown"};
)
}
/// A macro that allows lazily parsing a value from the environment variable,
/// with a fallback default value if the variable is not set or parsing fails.
///
/// # Parameters
///
/// - `$key`: An expression representing the name of the environment variable.
/// - `$t`: The type of the value to be parsed.
/// - `$default`: The default value to fall back to if the environment variable
/// is not set or parsing fails.
///
/// # Return Value
///
/// A lazy static variable of type `once_cell::sync::Lazy`, which holds the parsed value
/// from the environment variable or the default value.
#[macro_export]
macro_rules! lazy_env_parse {
($key:expr, $t:ty, $default:expr) => {
once_cell::sync::Lazy::new(|| {
std::env::var($key)
.and_then(|s| Ok(s.parse::<$t>().unwrap_or($default)))
.unwrap_or($default)
})
};
}
/// Lazily parses an environment variable into a specified type. If the environment variable is not set or the parsing fails,
/// it returns a default value.
///
/// # Parameters
///
/// - `$key`: A string literal representing the name of the environment variable.
/// - `$t`: The type to parse the environment variable into.
/// - `$default`: A fallback function or constant value to be returned if the environment variable is not set or the parsing fails.
///
/// # Returns
///
/// A `Lazy` static variable that stores the parsed value or the default value.
#[macro_export]
macro_rules! lazy_env_parse_or_else {
($key:expr, $t:ty, $default:expr) => {
once_cell::sync::Lazy::new(|| {
std::env::var($key)
.and_then(|s| Ok(s.parse::<$t>().unwrap_or_else($default)))
.unwrap_or_else($default)
})
};
}

49
src/cnf/mod.rs
View file

@ -1,5 +1,6 @@
use once_cell::sync::Lazy;
use std::time::Duration;
use surrealdb::{lazy_env_parse, lazy_env_parse_or_else};
pub const LOGO: &str = "
.d8888b. 888 8888888b. 888888b.
@ -31,45 +32,31 @@ pub const APP_ENDPOINT: &str = "https://surrealdb.com/app";
pub const WEBSOCKET_PING_FREQUENCY: Duration = Duration::from_secs(5);
/// What is the maximum WebSocket frame size (defaults to 16 MiB)
pub static WEBSOCKET_MAX_FRAME_SIZE: Lazy<usize> = Lazy::new(|| {
option_env!("SURREAL_WEBSOCKET_MAX_FRAME_SIZE")
.and_then(|s| s.parse::<usize>().ok())
.unwrap_or(16 << 20)
});
pub static WEBSOCKET_MAX_FRAME_SIZE: Lazy<usize> =
lazy_env_parse!("SURREAL_WEBSOCKET_MAX_FRAME_SIZE", usize, 16 << 20);
/// What is the maximum WebSocket message size (defaults to 128 MiB)
pub static WEBSOCKET_MAX_MESSAGE_SIZE: Lazy<usize> = Lazy::new(|| {
option_env!("SURREAL_WEBSOCKET_MAX_MESSAGE_SIZE")
.and_then(|s| s.parse::<usize>().ok())
.unwrap_or(128 << 20)
});
pub static WEBSOCKET_MAX_MESSAGE_SIZE: Lazy<usize> =
lazy_env_parse!("SURREAL_WEBSOCKET_MAX_MESSAGE_SIZE", usize, 128 << 20);
/// How many concurrent tasks can be handled on each WebSocket (defaults to 24)
pub static WEBSOCKET_MAX_CONCURRENT_REQUESTS: Lazy<usize> = Lazy::new(|| {
option_env!("SURREAL_WEBSOCKET_MAX_CONCURRENT_REQUESTS")
.and_then(|s| s.parse::<usize>().ok())
.unwrap_or(24)
});
pub static WEBSOCKET_MAX_CONCURRENT_REQUESTS: Lazy<usize> =
lazy_env_parse!("SURREAL_WEBSOCKET_MAX_CONCURRENT_REQUESTS", usize, 24);
/// What is the runtime thread memory stack size (defaults to 10MiB)
pub static RUNTIME_STACK_SIZE: Lazy<usize> = Lazy::new(|| {
// Stack frames are generally larger in debug mode.
let default = if cfg!(debug_assertions) {
20 * 1024 * 1024 // 20MiB in debug mode
} else {
10 * 1024 * 1024 // 10MiB in release mode
};
option_env!("SURREAL_RUNTIME_STACK_SIZE")
.and_then(|s| s.parse::<usize>().ok())
.unwrap_or(default)
});
pub static RUNTIME_STACK_SIZE: Lazy<usize> =
lazy_env_parse_or_else!("SURREAL_RUNTIME_STACK_SIZE", usize, |_| {
// Stack frames are generally larger in debug mode.
if cfg!(debug_assertions) {
20 * 1024 * 1024 // 20MiB in debug mode
} else {
10 * 1024 * 1024 // 10MiB in release mode
}
});
/// How many threads which can be started for blocking operations (defaults to 512)
pub static RUNTIME_MAX_BLOCKING_THREADS: Lazy<usize> = Lazy::new(|| {
option_env!("SURREAL_RUNTIME_MAX_BLOCKING_THREADS")
.and_then(|s| s.parse::<usize>().ok())
.unwrap_or(512)
});
pub static RUNTIME_MAX_BLOCKING_THREADS: Lazy<usize> =
lazy_env_parse!("SURREAL_RUNTIME_MAX_BLOCKING_THREADS", usize, 512);
/// The version identifier of this build
pub static PKG_VERSION: Lazy<String> = Lazy::new(|| match option_env!("SURREAL_BUILD_METADATA") {