#![allow(clippy::uninlined_format_args, clippy::new_without_default)]
pub mod bootstrap;
pub mod cert;
pub mod cli;
pub mod db;
pub mod editor;
pub mod http;
pub mod metrics;
pub mod orchestration;
pub mod paths;
pub mod premade;
pub mod process;
pub mod rate_limiter;
pub mod server_lock;
pub mod startup;
#[cfg(any(test, feature = "test-helpers"))]
pub mod test_helpers;
#[cfg(any(test, feature = "test-helpers"))]
pub mod test_observer;
pub mod toml_escapes;
pub use db::Database;
pub use metrics::Metrics;
pub use premade::PremadeManager;
pub use rate_limiter::RateLimiter;
use prost::Message;
use serde::Deserialize;
use snip_proto::{
CreateLibraryRequest, CreateLibraryResponse, DeleteLibraryRequest, DeleteLibraryResponse,
GetPremadeLibraryRequest, GetPremadeLibraryResponse, GetSnippetsRequest, HealthRequest,
HealthResponse, Library, ListLibrariesRequest, ListLibrariesResponse,
ListPremadeLibrariesRequest, ListPremadeLibrariesResponse,
PremadeLibrary as ProtoPremadeLibrary, PushSnippetsRequest, PushSnippetsResponse,
RegisterRequest, RegisterResponse, SearchPremadeLibrariesRequest,
SearchPremadeLibrariesResponse, Snippet as ProtoSnippet, SnippetList, SyncRequest,
SyncResponse, snippet_sync_server::SnippetSync,
};
use std::path::PathBuf;
use std::sync::Arc;
use std::time::Duration;
use tonic::{Request, Response, Status};
pub fn extract_api_key<T>(request: &Request<T>, body_api_key: &str) -> String {
request
.metadata()
.get("authorization")
.and_then(|v| v.to_str().ok())
.and_then(|v| {
let (scheme, credential) = v.split_once(' ')?;
scheme
.eq_ignore_ascii_case("bearer")
.then(|| credential.trim().to_owned())
})
.filter(|v| !v.is_empty())
.unwrap_or_else(|| body_api_key.to_string())
}
fn strip_port(addr: &str) -> String {
if let Some(close_bracket) = addr.find("]:") {
if close_bracket > 0 && addr.starts_with('[') {
return addr[1..close_bracket].to_string();
}
return addr.to_string();
}
if !addr.starts_with('[') && addr.matches(':').count() > 1 {
return addr.to_string();
}
if let Some(colon_pos) = addr.rfind(':')
&& !addr.starts_with('[')
{
return addr[..colon_pos].to_string();
}
addr.to_string()
}
pub const DEFAULT_MAX_COMMAND_LENGTH: usize = 1024;
pub const DEFAULT_MAX_ENCRYPTED_PAYLOAD_LENGTH: usize = 1024 * 1024; pub const DEFAULT_MAX_DESCRIPTION_LENGTH: usize = 1024;
pub const DEFAULT_MAX_TAGS: usize = 50;
pub const DEFAULT_MAX_TAG_LENGTH: usize = 100;
pub const DEFAULT_MAX_ID_LENGTH: usize = 128;
pub const DEFAULT_MAX_DEVICE_ID_LENGTH: usize = 128;
pub const DEFAULT_MAX_API_KEY_LENGTH: usize = 512;
pub const DEFAULT_MAX_SYNC_SNIPPETS: usize = 10000;
pub const DEFAULT_REQUEST_TIMEOUT_SECS: u64 = 30;
pub const DEFAULT_RATE_LIMIT_PER_MINUTE: u32 = 120;
pub const DEFAULT_REGISTER_PER_MINUTE: u32 = 10;
pub const DEFAULT_METRICS_AUTH_FAILURES_PER_MINUTE: u32 = 10;
pub const PRE_AUTH_RATE_LIMIT_MULTIPLIER: u32 = 10;
pub const DEFAULT_DB_MAX_CONNECTIONS: u32 = 5;
pub const DEFAULT_GRPC_MAX_MESSAGE_SIZE: u32 = 4 * 1024 * 1024; pub const MAX_REQUEST_LIMIT: i32 = 1000;
const RESPONSE_ENVELOPE_RESERVE_BYTES: usize = 64 * 1024;
fn page_byte_ceiling(grpc_ceiling: usize, envelope_bytes: usize) -> usize {
grpc_ceiling
.saturating_sub(RESPONSE_ENVELOPE_RESERVE_BYTES)
.saturating_sub(envelope_bytes)
}
fn fit_page_to_byte_ceiling(snippets: &mut Vec<ProtoSnippet>, ceiling: usize) -> bool {
let mut used = 0usize;
let mut kept = 0usize;
for snippet in snippets.iter() {
let len = snippet.encoded_len();
if kept > 0 && used.saturating_add(len) > ceiling {
break;
}
used = used.saturating_add(len);
kept += 1;
}
let truncated = kept < snippets.len();
if truncated {
tracing::info!(
dropped = snippets.len() - kept,
kept_bytes = used,
ceiling_bytes = ceiling,
"Response page trimmed to fit the gRPC encode ceiling"
);
snippets.truncate(kept);
}
truncated
}
#[derive(Deserialize, Default)]
pub struct ConfigFile {
pub server: Option<ServerConfig>,
}
#[derive(Deserialize, Default)]
pub struct ServerConfig {
pub grpc_host: Option<String>,
pub grpc_port: Option<u16>,
pub http_host: Option<String>,
pub http_port: Option<u16>,
pub database: Option<DatabaseConfig>,
pub premade: Option<PremadeConfig>,
pub limits: Option<LimitsConfig>,
pub rate_limit: Option<RateLimitConfig>,
pub metrics: Option<MetricsConfig>,
pub cors: Option<CorsConfig>,
}
#[derive(Deserialize, Default)]
pub struct DatabaseConfig {
pub path: Option<String>,
pub max_connections: Option<u32>,
}
#[derive(Deserialize, Default)]
pub struct PremadeConfig {
pub directory: Option<String>,
}
#[derive(Deserialize, Default)]
pub struct LimitsConfig {
pub max_command_length: Option<usize>,
pub max_encrypted_payload_length: Option<usize>,
pub max_description_length: Option<usize>,
pub max_tags: Option<usize>,
pub max_tag_length: Option<usize>,
pub max_id_length: Option<usize>,
pub max_device_id_length: Option<usize>,
pub max_api_key_length: Option<usize>,
pub request_timeout_secs: Option<u64>,
pub grpc_max_message_size: Option<u32>,
}
#[derive(Deserialize, Default)]
pub struct RateLimitConfig {
pub requests_per_minute: Option<u32>,
pub register_per_minute: Option<u32>,
pub metrics_auth_failures_per_minute: Option<u32>,
pub trusted_proxies: Option<Vec<String>>,
}
#[derive(Deserialize, Default)]
pub struct MetricsConfig {
pub username: Option<String>,
pub password: Option<String>,
}
#[derive(Deserialize, Default)]
pub struct CorsConfig {
pub allowed_origins: Option<String>,
}
#[derive(Clone, Debug)]
pub struct Config {
pub grpc_host: String,
pub grpc_port: u16,
pub http_host: String,
pub http_port: u16,
pub db_path: String,
pub db_max_connections: u32,
pub premade_dir: PathBuf,
pub max_command_length: usize,
pub max_encrypted_payload_length: usize,
pub max_description_length: usize,
pub max_tags: usize,
pub max_tag_length: usize,
pub max_id_length: usize,
pub max_device_id_length: usize,
pub max_api_key_length: usize,
pub request_timeout_secs: u64,
pub grpc_max_message_size: u32,
pub rate_limit_per_minute: u32,
pub register_per_minute: u32,
pub metrics_auth_failures_per_minute: u32,
pub trusted_proxies: Vec<String>,
pub metrics_username: Option<String>,
pub metrics_password: Option<String>,
pub cors_allowed_origins: Vec<String>,
}
#[derive(Debug, thiserror::Error)]
pub enum ConfigLoadError {
#[error("failed to read configuration file {path}: {source}")]
Read {
path: PathBuf,
source: std::io::Error,
},
#[error("failed to parse configuration file {path}: {source}")]
Parse {
path: PathBuf,
source: toml::de::Error,
},
#[error("invalid environment variable {name}={value:?}: {reason}")]
InvalidEnvironment {
name: &'static str,
value: String,
reason: String,
},
#[error("invalid configuration value {name}={value:?}: {reason}")]
InvalidRange {
name: &'static str,
value: String,
reason: String,
},
}
pub fn parse_env<T>(
env: &impl Fn(&str) -> Option<String>,
name: &'static str,
) -> Result<Option<T>, ConfigLoadError>
where
T: std::str::FromStr,
T::Err: std::fmt::Display,
{
match env(name) {
Some(val) => match val.parse::<T>() {
Ok(parsed) => Ok(Some(parsed)),
Err(e) => Err(ConfigLoadError::InvalidEnvironment {
name,
value: val,
reason: e.to_string(),
}),
},
None => Ok(None),
}
}
pub fn parse_bool_env(
env: &impl Fn(&str) -> Option<String>,
name: &'static str,
) -> Result<Option<bool>, ConfigLoadError> {
match env(name) {
Some(val) => match val.to_lowercase().as_str() {
"true" | "1" | "yes" | "on" => Ok(Some(true)),
"false" | "0" | "no" | "off" => Ok(Some(false)),
_ => Err(ConfigLoadError::InvalidEnvironment {
name,
value: val,
reason: "expected one of: true, 1, yes, on, false, 0, no, off".to_string(),
}),
},
None => Ok(None),
}
}
#[cfg(unix)]
fn check_config_permissions(path: &std::path::Path) {
use std::os::unix::fs::PermissionsExt;
match std::fs::metadata(path) {
Ok(meta) => {
let mode = meta.permissions().mode() & 0o777;
if mode & 0o004 != 0 {
tracing::warn!(
"Config file {} is world-readable (mode {:#05o}); \
other local users can read metrics credentials. \
Run: chmod 600 {}",
path.display(),
mode,
path.display()
);
}
}
Err(e) => {
tracing::debug!("Unable to check permissions on {}: {}", path.display(), e);
}
}
}
impl Config {
pub fn load() -> Result<Self, ConfigLoadError> {
let config_path = paths::config_path();
Self::load_from(&config_path, &|name| std::env::var(name).ok())
}
fn load_from(
config_path: &std::path::Path,
env: &impl Fn(&str) -> Option<String>,
) -> Result<Self, ConfigLoadError> {
let config_file = match std::fs::read_to_string(config_path) {
Ok(content) => {
let parsed: ConfigFile =
toml::from_str(&content).map_err(|source| ConfigLoadError::Parse {
path: config_path.to_path_buf(),
source,
})?;
#[cfg(unix)]
if let Some(server) = &parsed.server
&& server
.metrics
.as_ref()
.is_some_and(|m| m.username.is_some() || m.password.is_some())
{
check_config_permissions(config_path);
}
parsed
}
Err(e) if e.kind() == std::io::ErrorKind::NotFound => ConfigFile::default(),
Err(source) => {
return Err(ConfigLoadError::Read {
path: config_path.to_path_buf(),
source,
});
}
};
let server = config_file.server.unwrap_or_default();
let config = Self {
grpc_host: env("GRPC_HOST")
.or_else(|| server.grpc_host.clone())
.unwrap_or_else(|| "127.0.0.1".to_string()),
grpc_port: parse_env(env, "GRPC_PORT")?
.or(server.grpc_port)
.unwrap_or(50051),
http_host: env("HTTP_HOST")
.or_else(|| server.http_host.clone())
.unwrap_or_else(|| "127.0.0.1".to_string()),
http_port: parse_env(env, "HTTP_PORT")?
.or(server.http_port)
.unwrap_or(50050),
db_path: env("DATABASE_URL")
.or_else(|| server.database.as_ref().and_then(|d| d.path.clone()))
.unwrap_or_else(|| paths::default_db_path().to_string_lossy().into_owned()),
db_max_connections: parse_env(env, "DB_MAX_CONNECTIONS")?
.or(server.database.as_ref().and_then(|d| d.max_connections))
.unwrap_or(DEFAULT_DB_MAX_CONNECTIONS),
premade_dir: env("PREMADE_DIR")
.map(PathBuf::from)
.or_else(|| {
server
.premade
.as_ref()
.and_then(|p| p.directory.clone())
.map(PathBuf::from)
})
.unwrap_or_else(paths::default_premade_dir),
max_command_length: parse_env(env, "MAX_COMMAND_LENGTH")?
.or(server.limits.as_ref().and_then(|l| l.max_command_length))
.unwrap_or(DEFAULT_MAX_COMMAND_LENGTH),
max_encrypted_payload_length: parse_env(env, "MAX_ENCRYPTED_PAYLOAD_LENGTH")?
.or(server
.limits
.as_ref()
.and_then(|l| l.max_encrypted_payload_length))
.unwrap_or(DEFAULT_MAX_ENCRYPTED_PAYLOAD_LENGTH),
max_description_length: parse_env(env, "MAX_DESCRIPTION_LENGTH")?
.or(server
.limits
.as_ref()
.and_then(|l| l.max_description_length))
.unwrap_or(DEFAULT_MAX_DESCRIPTION_LENGTH),
max_tags: parse_env(env, "MAX_TAGS")?
.or(server.limits.as_ref().and_then(|l| l.max_tags))
.unwrap_or(DEFAULT_MAX_TAGS),
max_tag_length: parse_env(env, "MAX_TAG_LENGTH")?
.or(server.limits.as_ref().and_then(|l| l.max_tag_length))
.unwrap_or(DEFAULT_MAX_TAG_LENGTH),
max_id_length: parse_env(env, "MAX_ID_LENGTH")?
.or(server.limits.as_ref().and_then(|l| l.max_id_length))
.unwrap_or(DEFAULT_MAX_ID_LENGTH),
max_device_id_length: parse_env(env, "MAX_DEVICE_ID_LENGTH")?
.or(server.limits.as_ref().and_then(|l| l.max_device_id_length))
.unwrap_or(DEFAULT_MAX_DEVICE_ID_LENGTH),
max_api_key_length: parse_env(env, "MAX_API_KEY_LENGTH")?
.or(server.limits.as_ref().and_then(|l| l.max_api_key_length))
.unwrap_or(DEFAULT_MAX_API_KEY_LENGTH),
request_timeout_secs: parse_env(env, "REQUEST_TIMEOUT_SECS")?
.or(server.limits.as_ref().and_then(|l| l.request_timeout_secs))
.unwrap_or(DEFAULT_REQUEST_TIMEOUT_SECS),
grpc_max_message_size: parse_env(env, "GRPC_MAX_MESSAGE_SIZE")?
.or(server.limits.as_ref().and_then(|l| l.grpc_max_message_size))
.unwrap_or(DEFAULT_GRPC_MAX_MESSAGE_SIZE),
rate_limit_per_minute: parse_env(env, "RATE_LIMIT_PER_MINUTE")?
.or(server
.rate_limit
.as_ref()
.and_then(|r| r.requests_per_minute))
.unwrap_or(DEFAULT_RATE_LIMIT_PER_MINUTE),
register_per_minute: parse_env(env, "REGISTER_PER_MINUTE")?
.or(server
.rate_limit
.as_ref()
.and_then(|r| r.register_per_minute))
.unwrap_or(DEFAULT_REGISTER_PER_MINUTE),
metrics_auth_failures_per_minute: parse_env(env, "METRICS_AUTH_FAILURES_PER_MINUTE")?
.or(server
.rate_limit
.as_ref()
.and_then(|r| r.metrics_auth_failures_per_minute))
.unwrap_or(DEFAULT_METRICS_AUTH_FAILURES_PER_MINUTE),
trusted_proxies: env("TRUSTED_PROXIES")
.map(|v| {
v.split(',')
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty() && s.parse::<std::net::IpAddr>().is_ok())
.collect()
})
.or_else(|| server.rate_limit.as_ref()?.trusted_proxies.clone())
.unwrap_or_default(),
metrics_username: env("METRICS_USERNAME")
.or_else(|| server.metrics.as_ref().and_then(|m| m.username.clone())),
metrics_password: env("METRICS_PASSWORD")
.or_else(|| server.metrics.as_ref().and_then(|m| m.password.clone())),
cors_allowed_origins: env("CORS_ALLOWED_ORIGINS")
.or_else(|| server.cors.as_ref().and_then(|c| c.allowed_origins.clone()))
.map(|v| {
v.split(',')
.map(str::trim)
.filter(|origin| !origin.is_empty())
.map(ToOwned::to_owned)
.collect()
})
.unwrap_or_default(),
};
config.validate()?;
Ok(config)
}
fn validate(&self) -> Result<(), ConfigLoadError> {
if self.grpc_port == 0 {
return Err(ConfigLoadError::InvalidRange {
name: "GRPC_PORT",
value: self.grpc_port.to_string(),
reason: "port must be nonzero".into(),
});
}
if self.http_port == 0 {
return Err(ConfigLoadError::InvalidRange {
name: "HTTP_PORT",
value: self.http_port.to_string(),
reason: "port must be nonzero".into(),
});
}
if self.db_max_connections == 0 {
return Err(ConfigLoadError::InvalidRange {
name: "DB_MAX_CONNECTIONS",
value: self.db_max_connections.to_string(),
reason: "must be at least 1".into(),
});
}
if self.request_timeout_secs == 0 {
return Err(ConfigLoadError::InvalidRange {
name: "REQUEST_TIMEOUT_SECS",
value: self.request_timeout_secs.to_string(),
reason: "must be at least 1".into(),
});
}
if self.grpc_max_message_size == 0 {
return Err(ConfigLoadError::InvalidRange {
name: "GRPC_MAX_MESSAGE_SIZE",
value: self.grpc_max_message_size.to_string(),
reason: "must be greater than 0".into(),
});
}
if self.max_command_length == 0 {
return Err(ConfigLoadError::InvalidRange {
name: "MAX_COMMAND_LENGTH",
value: self.max_command_length.to_string(),
reason: "must be nonzero".into(),
});
}
if self.max_encrypted_payload_length == 0 {
return Err(ConfigLoadError::InvalidRange {
name: "MAX_ENCRYPTED_PAYLOAD_LENGTH",
value: self.max_encrypted_payload_length.to_string(),
reason: "must be nonzero".into(),
});
}
if self.max_description_length == 0 {
return Err(ConfigLoadError::InvalidRange {
name: "MAX_DESCRIPTION_LENGTH",
value: self.max_description_length.to_string(),
reason: "must be nonzero".into(),
});
}
if self.max_tags == 0 {
return Err(ConfigLoadError::InvalidRange {
name: "MAX_TAGS",
value: self.max_tags.to_string(),
reason: "must be nonzero".into(),
});
}
if self.max_tag_length == 0 {
return Err(ConfigLoadError::InvalidRange {
name: "MAX_TAG_LENGTH",
value: self.max_tag_length.to_string(),
reason: "must be nonzero".into(),
});
}
if self.max_id_length == 0 {
return Err(ConfigLoadError::InvalidRange {
name: "MAX_ID_LENGTH",
value: self.max_id_length.to_string(),
reason: "must be nonzero".into(),
});
}
if self.max_device_id_length == 0 {
return Err(ConfigLoadError::InvalidRange {
name: "MAX_DEVICE_ID_LENGTH",
value: self.max_device_id_length.to_string(),
reason: "must be nonzero".into(),
});
}
if self.max_api_key_length == 0 {
return Err(ConfigLoadError::InvalidRange {
name: "MAX_API_KEY_LENGTH",
value: self.max_api_key_length.to_string(),
reason: "must be nonzero".into(),
});
}
if self.rate_limit_per_minute == 0 {
return Err(ConfigLoadError::InvalidRange {
name: "RATE_LIMIT_PER_MINUTE",
value: self.rate_limit_per_minute.to_string(),
reason: "must be nonzero".into(),
});
}
if self.register_per_minute == 0 {
return Err(ConfigLoadError::InvalidRange {
name: "REGISTER_PER_MINUTE",
value: self.register_per_minute.to_string(),
reason: "must be nonzero".into(),
});
}
if self.metrics_auth_failures_per_minute == 0 {
return Err(ConfigLoadError::InvalidRange {
name: "METRICS_AUTH_FAILURES_PER_MINUTE",
value: self.metrics_auth_failures_per_minute.to_string(),
reason: "must be nonzero".into(),
});
}
Ok(())
}
pub fn ensure_config_file() {
if let Err(e) = bootstrap::ensure_config_file() {
tracing::warn!("{}", e);
}
}
}
#[derive(Clone)]
pub struct AppState {
pub config: Config,
pub metrics: Metrics,
pub db: Arc<Database>,
pub rate_limiter: Arc<RateLimiter>,
}
pub struct SnipSyncService {
pub db: Arc<Database>,
pub rate_limiter: Arc<RateLimiter>,
pub config: Config,
pub metrics: Metrics,
pub premade_manager: PremadeManager,
#[cfg(any(test, feature = "test-helpers"))]
pub captured_auth_header: Arc<std::sync::Mutex<Option<String>>>,
#[cfg(any(test, feature = "test-helpers"))]
pub test_observer: Option<Arc<dyn crate::test_observer::TestRequestObserver>>,
#[cfg(any(test, feature = "test-helpers"))]
pub push_fail_after: Arc<std::sync::atomic::AtomicU32>,
#[cfg(any(test, feature = "test-helpers"))]
pub push_fail_counter: Arc<std::sync::atomic::AtomicU32>,
}
impl SnipSyncService {
pub fn record_request(&self, method: &str) {
self.metrics
.requests_total
.with_label_values(&[method])
.inc();
tracing::trace!("Request: {}", method);
#[cfg(feature = "test-helpers")]
if let Some(ref obs) = self.test_observer {
use crate::test_observer::{RequestStarted, now_millis, operation_name_for_method};
let sequence = obs.allocate_sequence();
let concurrent = obs.current_concurrent();
obs.request_started(RequestStarted {
sequence,
started_at_unix_ms: now_millis(),
method: method.to_string(),
operation: operation_name_for_method(method).to_string(),
authenticated_user_id: None,
authenticated_device_id: None,
target_library_id: None,
request_revision: None,
payload_len: 0,
payload_sha256: String::new(),
payload_contains_plaintext_sentinel: false,
concurrent_at_start: concurrent,
});
}
}
#[cfg_attr(not(feature = "test-helpers"), allow(unused_variables))]
pub fn record_request_finished(&self, method: &str, success: bool) {
#[cfg(feature = "test-helpers")]
if let Some(ref obs) = self.test_observer {
use crate::test_observer::RequestFinished;
let sequence = obs.last_started_sequence_for_method(method);
obs.request_finished(RequestFinished {
sequence,
finished_at_unix_ms: crate::test_observer::now_millis(),
success,
response_revision: None,
});
}
}
#[cfg_attr(not(feature = "test-helpers"), allow(unused_variables))]
pub fn update_request_ids(
&self,
method: &str,
user_id: Option<String>,
device_id: Option<String>,
library_id: Option<String>,
) {
#[cfg(feature = "test-helpers")]
if let Some(ref obs) = self.test_observer {
obs.update_ids_for_last_method(method, user_id, device_id, library_id);
}
}
pub fn record_request_duration(&self, method: &str, start: std::time::Instant) {
let duration = start.elapsed().as_secs_f64();
self.metrics
.request_duration_seconds
.with_label_values(&[method])
.observe(duration);
tracing::debug!("Request {} completed in {:.3}s", method, duration);
}
pub fn record_rate_limit(&self) {
self.metrics.rate_limit_hits.inc();
}
pub fn record_auth_failure(&self) {
self.metrics.auth_failures.inc();
}
pub fn record_db_error(&self) {
self.metrics.db_errors_total.inc();
}
pub fn record_sync(&self, direction: &str) {
self.metrics
.sync_operations_total
.with_label_values(&[direction])
.inc();
}
pub fn record_library_op(&self, operation: &str) {
self.metrics
.library_operations_total
.with_label_values(&[operation])
.inc();
}
fn request_api_key<T>(&self, request: &Request<T>, body_api_key: &str) -> String {
let api_key = extract_api_key(request, body_api_key);
#[cfg(any(test, feature = "test-helpers"))]
self.capture_test_auth_header(&api_key);
api_key
}
#[cfg(any(test, feature = "test-helpers"))]
fn capture_test_auth_header(&self, api_key: &str) {
if !api_key.is_empty() {
let mut slot = self
.captured_auth_header
.lock()
.unwrap_or_else(|e| e.into_inner());
if slot.is_none() {
*slot = Some(format!("Bearer {api_key}"));
}
}
}
fn peer_rate_limit_key<T>(&self, request: &Request<T>) -> String {
let peer_ip = request
.extensions()
.get::<tonic::transport::server::TcpConnectInfo>()
.and_then(|info| info.remote_addr())
.map(|addr| addr.ip().to_string());
match peer_ip {
Some(ref ip) if self.config.trusted_proxies.contains(ip) => request
.metadata()
.get("x-forwarded-for")
.and_then(|v| v.to_str().ok())
.and_then(|header| header.split(',').next())
.map(|s| strip_port(s.trim()))
.filter(|s| !s.is_empty())
.unwrap_or_else(|| ip.clone()),
Some(ip) => ip,
None => "unknown".to_string(),
}
}
pub async fn authenticate_and_rate_limit(
&self,
api_key: &str,
rate_limit_key: &str,
) -> Result<String, Status> {
self.authenticate_and_rate_limit_with_duration(api_key, rate_limit_key, None)
.await
}
pub async fn authenticate_and_rate_limit_with_duration(
&self,
api_key: &str,
rate_limit_key: &str,
start: Option<std::time::Instant>,
) -> Result<String, Status> {
if api_key.is_empty() {
if let Some(s) = start {
self.record_request_duration("auth", s);
}
return Err(Status::unauthenticated("API key is required"));
}
if api_key.len() > self.config.max_api_key_length {
if let Some(s) = start {
self.record_request_duration("auth", s);
}
return Err(Status::invalid_argument(format!(
"API key exceeds maximum length of {} bytes",
self.config.max_api_key_length
)));
}
let pre_auth_key = format!("pre-auth:{rate_limit_key}");
let pre_auth_limit = self
.config
.rate_limit_per_minute
.saturating_mul(PRE_AUTH_RATE_LIMIT_MULTIPLIER) as usize;
if !self
.rate_limiter
.allow(&pre_auth_key, pre_auth_limit, Duration::from_secs(60))
.await
{
self.record_rate_limit();
if let Some(s) = start {
self.record_request_duration("auth", s);
}
return Err(Status::resource_exhausted("Rate limit exceeded"));
}
let user_id = self
.db
.get_user_by_api_key(api_key)
.await
.map_err(|_| {
if let Some(s) = start {
self.record_request_duration("auth", s);
}
Status::internal("Internal error")
})?
.ok_or_else(|| {
self.record_auth_failure();
if let Some(s) = start {
self.record_request_duration("auth", s);
}
Status::unauthenticated("Invalid API key")
})?;
if !self
.rate_limiter
.allow(
rate_limit_key,
self.config.rate_limit_per_minute as usize,
Duration::from_secs(60),
)
.await
{
self.record_rate_limit();
if let Some(s) = start {
self.record_request_duration("auth", s);
}
return Err(Status::resource_exhausted("Rate limit exceeded"));
}
Ok(user_id)
}
pub fn validate_snippet(&self, snippet: &ProtoSnippet) -> Result<(), Status> {
if snippet.id.is_empty() {
return Err(Status::invalid_argument("Snippet ID is required"));
}
if snippet.id.len() > self.config.max_id_length {
return Err(Status::invalid_argument(format!(
"Snippet ID exceeds maximum length of {} bytes",
self.config.max_id_length
)));
}
if snippet.device_id.is_empty() {
return Err(Status::invalid_argument("Device ID is required"));
}
if snippet.device_id.len() > self.config.max_device_id_length {
return Err(Status::invalid_argument(format!(
"Device ID exceeds maximum length of {} bytes",
self.config.max_device_id_length
)));
}
if !snippet.encrypted && snippet.command.len() > self.config.max_command_length {
return Err(Status::invalid_argument(format!(
"Command exceeds maximum length of {} bytes",
self.config.max_command_length
)));
}
if !snippet.encrypted && snippet.command.trim().is_empty() {
return Err(Status::invalid_argument("Snippet command is required"));
}
if snippet.encrypted && snippet.command.len() > self.config.max_encrypted_payload_length {
return Err(Status::invalid_argument(format!(
"Encrypted payload exceeds maximum length of {} bytes",
self.config.max_encrypted_payload_length
)));
}
if snippet.encrypted && (snippet.command.is_empty() || snippet.command.trim().is_empty()) {
return Err(Status::invalid_argument(
"Encrypted snippet payload is required",
));
}
if snippet.description.len() > self.config.max_description_length {
return Err(Status::invalid_argument(format!(
"Description exceeds maximum length of {} bytes",
self.config.max_description_length
)));
}
if snippet.tags.len() > self.config.max_tags {
return Err(Status::invalid_argument(format!(
"Too many tags (max {})",
self.config.max_tags
)));
}
for tag in &snippet.tags {
if tag.len() > self.config.max_tag_length {
return Err(Status::invalid_argument(format!(
"Tag '{}' exceeds maximum length of {} bytes",
tag, self.config.max_tag_length
)));
}
}
let now = time::OffsetDateTime::now_utc().unix_timestamp();
let tolerance = 300;
if snippet.updated_at > now + tolerance {
let skew = snippet.updated_at - now;
return Err(Status::invalid_argument(format!(
"CLOCK_SKEW: updated_at is {} seconds ahead of server time; \
synchronize the client clock and retry",
skew
)));
}
if snippet.created_at > now + tolerance {
let skew = snippet.created_at - now;
return Err(Status::invalid_argument(format!(
"CLOCK_SKEW: created_at is {} seconds ahead of server time; \
synchronize the client clock and retry",
skew
)));
}
if snippet.created_at < 0 || snippet.updated_at < 0 {
return Err(Status::invalid_argument("Timestamps must be non-negative"));
}
if snippet.created_at == 0 || snippet.updated_at == 0 {
return Err(Status::invalid_argument(
"Timestamps must be positive; zero indicates an unset client clock",
));
}
if snippet.created_at > snippet.updated_at {
return Err(Status::invalid_argument(
"created_at must not be greater than updated_at",
));
}
Ok(())
}
}
#[tonic::async_trait]
impl SnippetSync for SnipSyncService {
async fn health(
&self,
_request: Request<HealthRequest>,
) -> Result<Response<HealthResponse>, Status> {
let request_id = uuid::Uuid::new_v4();
let start = std::time::Instant::now();
self.record_request("health");
tracing::debug!(request_id = %request_id, "Health check");
let healthy = self.db.ping().await.is_ok();
self.record_request_duration("health", start);
self.record_request_finished("health", healthy);
Ok(Response::new(HealthResponse {
healthy,
version: env!("CARGO_PKG_VERSION").to_string(),
}))
}
async fn register(
&self,
request: Request<RegisterRequest>,
) -> Result<Response<RegisterResponse>, Status> {
let request_id = uuid::Uuid::new_v4();
let start = std::time::Instant::now();
self.record_request("register");
tracing::info!(request_id = %request_id, "Register request");
let rate_limit_key = self.peer_rate_limit_key(&request);
let register_limit_key = format!("register:{rate_limit_key}");
if !self
.rate_limiter
.allow(
®ister_limit_key,
self.config.rate_limit_per_minute as usize,
Duration::from_secs(60),
)
.await
{
self.record_rate_limit();
self.record_request_duration("register", start);
self.record_request_finished("register", false);
return Err(Status::resource_exhausted(
"Rate limit exceeded for registration",
));
}
if !self
.rate_limiter
.allow(
"register-global",
self.config.register_per_minute as usize,
Duration::from_secs(60),
)
.await
{
self.record_rate_limit();
self.record_request_duration("register", start);
self.record_request_finished("register", false);
tracing::warn!(
request_id = %request_id,
"Rejected registration: global per-minute ceiling reached"
);
return Err(Status::resource_exhausted(
"Registration is temporarily unavailable: global account-creation limit reached",
));
}
let _req = request.into_inner();
let api_key = uuid::Uuid::new_v4().to_string();
match self.db.create_user(&api_key).await {
Ok(device_id) => {
if uuid::Uuid::parse_str(&device_id).is_err() {
tracing::error!(
request_id = %request_id,
"Generated device_id is not a valid UUID: {}",
device_id
);
self.record_request_duration("register", start);
self.record_request_finished("register", false);
return Err(Status::internal(
"Internal error: invalid device ID generated",
));
}
tracing::info!(
request_id = %request_id,
device_id = %device_id,
"Created new user"
);
self.record_request_duration("register", start);
self.record_request_finished("register", true);
Ok(Response::new(RegisterResponse {
success: true,
api_key,
message: "Account created successfully".to_string(),
device_id,
}))
}
Err(e) => {
tracing::error!(request_id = %request_id, "Failed to create user: {}", e);
self.record_request_duration("register", start);
self.record_request_finished("register", false);
Err(Status::internal("Internal error"))
}
}
}
async fn get_snippets(
&self,
request: Request<GetSnippetsRequest>,
) -> Result<Response<SnippetList>, Status> {
let request_id = uuid::Uuid::new_v4();
let start = std::time::Instant::now();
self.record_request("get_snippets");
tracing::info!(request_id = %request_id, "GetSnippets request");
let rate_limit_key = self.peer_rate_limit_key(&request);
let api_key = self.request_api_key(&request, &request.get_ref().api_key);
let req = request.into_inner();
let user_id = self
.authenticate_and_rate_limit_with_duration(&api_key, &rate_limit_key, Some(start))
.await
.inspect_err(|_| {
self.record_request_finished("get_snippets", false);
})?;
let library_id = if req.library_id.is_empty() {
self.db.get_default_library(&user_id).await.map_err(|e| {
self.record_request_duration("get_snippets", start);
self.record_request_finished("get_snippets", false);
tracing::error!("Internal error: {}", e);
Status::internal("Internal error")
})?
} else {
if !self
.db
.verify_library_ownership(&user_id, &req.library_id)
.await
.map_err(|e| {
self.record_request_duration("get_snippets", start);
self.record_request_finished("get_snippets", false);
tracing::error!("Internal error: {}", e);
Status::internal("Internal error")
})?
{
tracing::warn!(
"User {} attempted to access library {} without ownership",
user_id,
req.library_id
);
self.record_request_duration("get_snippets", start);
self.record_request_finished("get_snippets", false);
return Err(Status::not_found("Library not found"));
}
req.library_id
};
self.update_request_ids(
"get_snippets",
Some(user_id.clone()),
None,
Some(library_id.clone()),
);
let limit = if req.limit > 0 {
req.limit.clamp(1, MAX_REQUEST_LIMIT)
} else {
100
};
let offset = if req.offset > 0 { req.offset } else { 0 };
let (snippets, total) = self
.db
.get_snippets(&user_id, &library_id, req.since, limit, offset, false)
.await
.map_err(|e| {
self.record_request_duration("get_snippets", start);
self.record_request_finished("get_snippets", false);
tracing::error!("Internal error: {}", e);
Status::internal("Internal error")
})?;
let page_len = snippets.len() as i32;
let has_more_by_rows = offset.saturating_add(page_len) < total;
let mut proto_snippets: Vec<ProtoSnippet> = snippets
.into_iter()
.map(|s| ProtoSnippet {
id: s.id,
description: s.description,
command: s.command,
tags: s.tags,
created_at: s.created_at,
updated_at: s.updated_at,
device_id: s.device_id,
deleted: s.deleted,
encrypted: s.encrypted,
})
.collect();
let truncated = fit_page_to_byte_ceiling(
&mut proto_snippets,
page_byte_ceiling(self.config.grpc_max_message_size as usize, 0),
);
let has_more = has_more_by_rows || truncated;
self.record_request_duration("get_snippets", start);
let result = Ok(Response::new(SnippetList {
snippets: proto_snippets,
total_count: total,
has_more,
}));
self.record_request_finished("get_snippets", result.is_ok());
result
}
async fn push_snippets(
&self,
request: Request<PushSnippetsRequest>,
) -> Result<Response<PushSnippetsResponse>, Status> {
let request_id = uuid::Uuid::new_v4();
let start = std::time::Instant::now();
self.record_request("push_snippets");
tracing::info!(request_id = %request_id, "PushSnippets request");
let rate_limit_key = self.peer_rate_limit_key(&request);
let api_key = self.request_api_key(&request, &request.get_ref().api_key);
let req = request.into_inner();
let user_id = self
.authenticate_and_rate_limit_with_duration(&api_key, &rate_limit_key, Some(start))
.await
.inspect_err(|_| {
self.record_request_finished("push_snippets", false);
})?;
let library_id = if req.library_id.is_empty() {
self.db.get_default_library(&user_id).await.map_err(|e| {
self.record_request_duration("push_snippets", start);
self.record_request_finished("push_snippets", false);
tracing::error!("Internal error: {}", e);
Status::internal("Internal error")
})?
} else {
if !self
.db
.verify_library_ownership(&user_id, &req.library_id)
.await
.map_err(|e| {
self.record_request_duration("push_snippets", start);
self.record_request_finished("push_snippets", false);
tracing::error!("Internal error: {}", e);
Status::internal("Internal error")
})?
{
tracing::warn!(
"User {} attempted to push to library {} without ownership",
user_id,
req.library_id
);
self.record_request_duration("push_snippets", start);
self.record_request_finished("push_snippets", false);
return Err(Status::not_found("Library not found"));
}
req.library_id
};
self.update_request_ids(
"push_snippets",
Some(user_id.clone()),
req.snippets.first().map(|s| s.device_id.clone()),
Some(library_id.clone()),
);
if req.snippets.len() > DEFAULT_MAX_SYNC_SNIPPETS {
self.record_request_duration("push_snippets", start);
self.record_request_finished("push_snippets", false);
return Err(Status::invalid_argument(format!(
"Too many snippets in push request (max {}), got {}",
DEFAULT_MAX_SYNC_SNIPPETS,
req.snippets.len()
)));
}
#[cfg(feature = "test-helpers")]
{
let threshold = self
.push_fail_after
.load(std::sync::atomic::Ordering::SeqCst);
if threshold != u32::MAX {
let count = self
.push_fail_counter
.fetch_add(1, std::sync::atomic::Ordering::SeqCst)
+ 1;
if count >= threshold {
self.record_request_duration("push_snippets", start);
self.record_request_finished("push_snippets", false);
return Err(Status::internal("test-injected push failure"));
}
}
}
let mut accepted = 0;
let mut rejected = 0;
let mut tx = self.db.pool().begin().await.map_err(|e| {
self.record_request_duration("push_snippets", start);
self.record_request_finished("push_snippets", false);
tracing::error!(request_id = %request_id, "Failed to begin transaction: {}", e);
Status::internal("Internal error")
})?;
for snippet in req.snippets {
if let Err(e) = self.validate_snippet(&snippet) {
rejected += 1;
tracing::warn!(request_id = %request_id, snippet_id = %snippet.id, reason = %e, "Snippet validation failed");
continue;
}
let db_snippet = db::Snippet {
id: snippet.id.clone(),
description: snippet.description,
command: snippet.command,
tags: snippet.tags,
created_at: snippet.created_at,
updated_at: snippet.updated_at,
device_id: snippet.device_id,
deleted: snippet.deleted,
encrypted: snippet.encrypted,
};
match self
.db
.upsert_snippet_in_tx(&mut tx, &db_snippet, &user_id, &library_id)
.await
{
Ok(db::UpsertOutcome::Written | db::UpsertOutcome::Stale) => accepted += 1,
Ok(db::UpsertOutcome::ForeignScope) => {
rejected += 1;
tracing::error!(
request_id = %request_id,
snippet_id = %snippet.id,
user_id = %user_id,
library_id = %library_id,
"Snippet rejected: id already exists under a different user or library"
);
}
Err(e) => {
tracing::warn!(
request_id = %request_id,
snippet_id = %snippet.id,
reason = %e,
"Snippet upsert failed"
);
self.record_db_error();
if let Err(rollback_error) = tx.rollback().await {
tracing::error!(
request_id = %request_id,
error = %rollback_error,
"Failed to roll back push transaction"
);
}
self.record_request_duration("push_snippets", start);
self.record_request_finished("push_snippets", false);
return Err(Status::internal("Internal error"));
}
}
}
tx.commit().await.map_err(|e| {
self.record_request_duration("push_snippets", start);
self.record_request_finished("push_snippets", false);
tracing::error!(request_id = %request_id, "Failed to commit transaction: {}", e);
Status::internal("Internal error")
})?;
self.record_request_duration("push_snippets", start);
let result = Ok(Response::new(PushSnippetsResponse {
success: rejected == 0,
message: format!("Accepted {}, rejected {}", accepted, rejected),
accepted_count: accepted,
rejected_count: rejected,
}));
self.record_request_finished("push_snippets", result.is_ok());
result
}
async fn sync(&self, request: Request<SyncRequest>) -> Result<Response<SyncResponse>, Status> {
let request_id = uuid::Uuid::new_v4();
let start = std::time::Instant::now();
self.record_request("sync");
tracing::info!(request_id = %request_id, "Sync request");
let rate_limit_key = self.peer_rate_limit_key(&request);
let api_key = self.request_api_key(&request, &request.get_ref().api_key);
let req = request.into_inner();
let user_id = self
.authenticate_and_rate_limit_with_duration(&api_key, &rate_limit_key, Some(start))
.await
.inspect_err(|_| {
self.record_request_finished("sync", false);
})?;
if req.local_snippets.len() > DEFAULT_MAX_SYNC_SNIPPETS {
self.record_request_duration("sync", start);
self.record_request_finished("sync", false);
return Err(Status::invalid_argument(format!(
"Too many snippets in sync request (max {}), got {}",
DEFAULT_MAX_SYNC_SNIPPETS,
req.local_snippets.len()
)));
}
self.record_sync("bidirectional");
let library_id = if req.library_id.is_empty() {
self.db.get_default_library(&user_id).await.map_err(|e| {
self.record_request_duration("sync", start);
self.record_request_finished("sync", false);
tracing::error!("Internal error: {}", e);
Status::internal("Internal error")
})?
} else {
if !self
.db
.verify_library_ownership(&user_id, &req.library_id)
.await
.map_err(|e| {
self.record_request_duration("sync", start);
self.record_request_finished("sync", false);
tracing::error!("Internal error: {}", e);
Status::internal("Internal error")
})?
{
tracing::warn!(
"User {} attempted to sync with library {} without ownership",
user_id,
req.library_id
);
self.record_request_duration("sync", start);
self.record_request_finished("sync", false);
return Err(Status::not_found("Library not found"));
}
req.library_id
};
self.update_request_ids(
"sync",
Some(user_id.clone()),
req.local_snippets.first().map(|s| s.device_id.clone()),
Some(library_id.clone()),
);
let mut skipped_ids = Vec::new();
let mut tx = self.db.pool().begin().await.map_err(|e| {
self.record_request_duration("sync", start);
self.record_request_finished("sync", false);
tracing::error!(request_id = %request_id, "Failed to begin transaction: {}", e);
Status::internal("Internal error")
})?;
for snippet in &req.local_snippets {
if let Err(e) = self.validate_snippet(snippet) {
tracing::warn!(
request_id = %request_id,
snippet_id = %snippet.id,
reason = %e,
"Snippet skipped: validation failed"
);
skipped_ids.push(snippet.id.clone());
continue;
}
let db_snippet = db::Snippet {
id: snippet.id.clone(),
description: snippet.description.clone(),
command: snippet.command.clone(),
tags: snippet.tags.clone(),
created_at: snippet.created_at,
updated_at: snippet.updated_at,
device_id: snippet.device_id.clone(),
deleted: snippet.deleted,
encrypted: snippet.encrypted,
};
match self
.db
.upsert_snippet_in_tx(&mut tx, &db_snippet, &user_id, &library_id)
.await
{
Ok(db::UpsertOutcome::Written | db::UpsertOutcome::Stale) => {}
Ok(db::UpsertOutcome::ForeignScope) => {
tracing::error!(
request_id = %request_id,
snippet_id = %snippet.id,
user_id = %user_id,
library_id = %library_id,
"Snippet skipped: id already exists under a different user or library"
);
skipped_ids.push(snippet.id.clone());
}
Err(e) => {
tracing::error!(
request_id = %request_id,
snippet_id = %snippet.id,
reason = %e,
"Snippet upsert failed: rolling back the sync transaction"
);
self.record_db_error();
if let Err(rollback_error) = tx.rollback().await {
tracing::error!(
request_id = %request_id,
error = %rollback_error,
"Failed to roll back sync transaction"
);
}
self.record_request_duration("sync", start);
self.record_request_finished("sync", false);
return Err(Status::internal("Internal error"));
}
}
}
tx.commit().await.map_err(|e| {
self.record_request_duration("sync", start);
self.record_request_finished("sync", false);
tracing::error!(request_id = %request_id, "Failed to commit transaction: {}", e);
Status::internal("Internal error")
})?;
let limit = if req.limit > 0 {
req.limit.clamp(1, MAX_REQUEST_LIMIT)
} else {
1000
};
let offset = if req.offset > 0 { req.offset } else { 0 };
let sequence_cursor = req.last_sync_sequence;
let cursor = if sequence_cursor != 0 {
db::DeltaCursor::Sequence(sequence_cursor)
} else {
db::DeltaCursor::Timestamp(req.last_sync_timestamp)
};
let page = self
.db
.get_snippets_page(&user_id, &library_id, cursor, limit, offset, true)
.await
.map_err(|e| {
self.record_request_duration("sync", start);
self.record_request_finished("sync", false);
tracing::error!("Internal error: {}", e);
Status::internal("Internal error")
})?;
let total = page.total;
let has_more_by_rows = page.has_more;
let mut proto_snippets: Vec<ProtoSnippet> = page
.snippets
.into_iter()
.map(|s| ProtoSnippet {
id: s.id,
description: s.description,
command: s.command,
tags: s.tags,
created_at: s.created_at,
updated_at: s.updated_at,
device_id: s.device_id,
deleted: s.deleted,
encrypted: s.encrypted,
})
.collect();
let skipped_bytes: usize = skipped_ids.iter().map(|id| id.len() + 8).sum();
let truncated = fit_page_to_byte_ceiling(
&mut proto_snippets,
page_byte_ceiling(self.config.grpc_max_message_size as usize, skipped_bytes),
);
let has_more = has_more_by_rows || truncated;
let timestamp = if has_more {
req.last_sync_timestamp
} else {
self.db
.get_latest_timestamp(&user_id, &library_id)
.await
.map_err(|e| {
self.record_request_duration("sync", start);
self.record_request_finished("sync", false);
tracing::error!("Internal error: {}", e);
Status::internal("Internal error")
})?
};
let sequence = if has_more {
sequence_cursor
} else if sequence_cursor != 0 || req.last_sync_timestamp == 0 {
self.db
.get_latest_sequence(&user_id, &library_id)
.await
.map_err(|e| {
self.record_request_duration("sync", start);
self.record_request_finished("sync", false);
tracing::error!("Internal error: {}", e);
Status::internal("Internal error")
})?
.max(1)
} else {
0
};
let skipped_count = skipped_ids.len() as i32;
tracing::info!(
request_id = %request_id,
snippets_synced = proto_snippets.len(),
skipped_count = skipped_count,
has_more = has_more,
"Sync completed"
);
self.record_request_duration("sync", start);
let result = Ok(Response::new(SyncResponse {
success: true,
message: if skipped_count > 0 {
format!("Sync completed, {} snippets skipped", skipped_count)
} else {
"Sync completed".to_string()
},
snippets: proto_snippets,
server_timestamp: timestamp,
server_sequence: sequence,
skipped_count,
skipped_ids,
has_more,
total_count: total,
}));
self.record_request_finished("sync", result.is_ok());
result
}
async fn create_library(
&self,
request: Request<CreateLibraryRequest>,
) -> Result<Response<CreateLibraryResponse>, Status> {
let request_id = uuid::Uuid::new_v4();
let start = std::time::Instant::now();
self.record_request("create_library");
self.record_library_op("create");
tracing::info!(request_id = %request_id, "CreateLibrary request");
let rate_limit_key = self.peer_rate_limit_key(&request);
let api_key = self.request_api_key(&request, &request.get_ref().api_key);
let req = request.into_inner();
let user_id = self
.authenticate_and_rate_limit_with_duration(&api_key, &rate_limit_key, Some(start))
.await
.inspect_err(|_| {
self.record_request_finished("create_library", false);
})?;
let result = match self.db.create_library(&user_id, &req.name).await {
Ok(lib_id) => {
tracing::info!("Created library '{}' for user {}", req.name, user_id);
self.record_request_duration("create_library", start);
Ok(Response::new(CreateLibraryResponse {
success: true,
library_id: lib_id,
message: format!("Library '{}' created successfully", req.name),
}))
}
Err(db::DbError::Conflict(msg)) => {
self.record_request_duration("create_library", start);
Err(Status::already_exists(msg))
}
Err(db::DbError::Validation(msg)) => {
self.record_request_duration("create_library", start);
Err(Status::invalid_argument(msg))
}
Err(db::DbError::NotFound(msg)) => {
self.record_request_duration("create_library", start);
Err(Status::invalid_argument(msg))
}
Err(db::DbError::Internal(msg)) => {
tracing::error!("Internal error creating library: {}", msg);
self.record_request_duration("create_library", start);
Err(Status::internal("Internal error"))
}
Err(db::DbError::Database(e)) => {
tracing::error!("Database error creating library: {}", e);
self.record_request_duration("create_library", start);
Err(Status::internal("Internal error"))
}
};
self.record_request_finished("create_library", result.is_ok());
result
}
async fn list_libraries(
&self,
request: Request<ListLibrariesRequest>,
) -> Result<Response<ListLibrariesResponse>, Status> {
let request_id = uuid::Uuid::new_v4();
let start = std::time::Instant::now();
self.record_request("list_libraries");
self.record_library_op("list");
tracing::info!(request_id = %request_id, "ListLibraries request");
let rate_limit_key = self.peer_rate_limit_key(&request);
let api_key = self.request_api_key(&request, &request.get_ref().api_key);
let req = request.into_inner();
let user_id = self
.authenticate_and_rate_limit_with_duration(&api_key, &rate_limit_key, Some(start))
.await
.inspect_err(|_| {
self.record_request_finished("list_libraries", false);
})?;
let limit = if req.limit > 0 {
req.limit.clamp(1, MAX_REQUEST_LIMIT)
} else {
50
};
let offset = if req.offset > 0 { req.offset } else { 0 };
let (libraries, total) = self
.db
.list_libraries(&user_id, limit, offset)
.await
.map_err(|e| {
self.record_request_duration("list_libraries", start);
self.record_request_finished("list_libraries", false);
tracing::error!("Internal error: {}", e);
Status::internal("Internal error")
})?;
let has_more = offset.saturating_add(libraries.len() as i32) < total;
let proto_libraries: Vec<Library> = libraries
.into_iter()
.map(|l| Library {
id: l.id,
name: l.name,
created_at: l.created_at,
snippet_count: l.snippet_count,
})
.collect();
self.record_request_duration("list_libraries", start);
let result = Ok(Response::new(ListLibrariesResponse {
libraries: proto_libraries,
total_count: total,
has_more,
}));
self.record_request_finished("list_libraries", result.is_ok());
result
}
async fn delete_library(
&self,
request: Request<DeleteLibraryRequest>,
) -> Result<Response<DeleteLibraryResponse>, Status> {
let request_id = uuid::Uuid::new_v4();
let start = std::time::Instant::now();
self.record_request("delete_library");
self.record_library_op("delete");
tracing::info!(request_id = %request_id, "DeleteLibrary request");
let rate_limit_key = self.peer_rate_limit_key(&request);
let api_key = self.request_api_key(&request, &request.get_ref().api_key);
let req = request.into_inner();
let user_id = self
.authenticate_and_rate_limit_with_duration(&api_key, &rate_limit_key, Some(start))
.await
.inspect_err(|_| {
self.record_request_finished("delete_library", false);
})?;
if req.library_id.is_empty() || req.library_id == "default" {
self.record_request_duration("delete_library", start);
self.record_request_finished("delete_library", false);
return Err(Status::invalid_argument("Cannot delete default library"));
}
if let Ok(default_id) = self.db.get_default_library(&user_id).await
&& req.library_id == default_id
{
self.record_request_duration("delete_library", start);
self.record_request_finished("delete_library", false);
return Err(Status::invalid_argument("Cannot delete default library"));
}
let result = match self.db.delete_library(&user_id, &req.library_id).await {
Ok(_) => {
tracing::info!("Deleted library {} for user {}", req.library_id, user_id);
Ok(Response::new(DeleteLibraryResponse {
success: true,
message: "Library deleted successfully".to_string(),
}))
}
Err(db::DbError::NotFound(msg)) => Err(Status::not_found(msg)),
Err(db::DbError::Conflict(msg)) => Err(Status::failed_precondition(msg)),
Err(db::DbError::Validation(msg)) => Err(Status::invalid_argument(msg)),
Err(db::DbError::Internal(msg)) => {
tracing::error!("Internal error deleting library: {}", msg);
Err(Status::internal("Internal error"))
}
Err(db::DbError::Database(e)) => {
tracing::error!("Failed to delete library: {}", e);
Err(Status::internal("Internal error"))
}
};
self.record_request_duration("delete_library", start);
self.record_request_finished("delete_library", result.is_ok());
result
}
async fn list_premade_libraries(
&self,
request: Request<ListPremadeLibrariesRequest>,
) -> Result<Response<ListPremadeLibrariesResponse>, Status> {
let request_id = uuid::Uuid::new_v4();
let start = std::time::Instant::now();
self.record_request("list_premade_libraries");
tracing::info!(request_id = %request_id, "ListPremadeLibraries request");
let rate_limit_key = self.peer_rate_limit_key(&request);
let api_key = self.request_api_key(&request, &request.get_ref().api_key);
let _req = request.into_inner();
let user_id = self
.authenticate_and_rate_limit_with_duration(&api_key, &rate_limit_key, Some(start))
.await
.inspect_err(|_| {
self.record_request_finished("list_premade_libraries", false);
})?;
let libraries = self.premade_manager.list();
let proto_libraries: Vec<ProtoPremadeLibrary> = libraries
.into_iter()
.map(|l| ProtoPremadeLibrary {
name: l.name,
filename: l.filename,
description: l.description,
snippet_count: l.snippet_count,
tags: l.tags,
})
.collect();
tracing::info!(
request_id = %request_id,
user_id = %user_id,
count = proto_libraries.len(),
"ListPremadeLibraries completed"
);
let count = proto_libraries.len() as i32;
self.record_request_duration("list_premade_libraries", start);
let result = Ok(Response::new(ListPremadeLibrariesResponse {
libraries: proto_libraries,
has_more: false,
total_count: count,
}));
self.record_request_finished("list_premade_libraries", result.is_ok());
result
}
async fn get_premade_library(
&self,
request: Request<GetPremadeLibraryRequest>,
) -> Result<Response<GetPremadeLibraryResponse>, Status> {
let request_id = uuid::Uuid::new_v4();
let start = std::time::Instant::now();
self.record_request("get_premade_library");
tracing::info!(request_id = %request_id, "GetPremadeLibrary request");
let rate_limit_key = self.peer_rate_limit_key(&request);
let api_key = self.request_api_key(&request, &request.get_ref().api_key);
let req = request.into_inner();
let user_id = self
.authenticate_and_rate_limit_with_duration(&api_key, &rate_limit_key, Some(start))
.await
.inspect_err(|_| {
self.record_request_finished("get_premade_library", false);
})?;
if req.filename.is_empty() {
self.record_request_duration("get_premade_library", start);
self.record_request_finished("get_premade_library", false);
return Err(Status::invalid_argument("Filename is required"));
}
if req.filename.contains("..") || req.filename.contains('/') || req.filename.contains('\\')
{
self.record_request_duration("get_premade_library", start);
self.record_request_finished("get_premade_library", false);
return Err(Status::invalid_argument("Invalid filename"));
}
let sanitized: String = req
.filename
.chars()
.filter(|c| c.is_alphanumeric() || *c == '-' || *c == '_' || *c == '.')
.collect();
if sanitized.is_empty() || sanitized.len() > 64 {
self.record_request_duration("get_premade_library", start);
self.record_request_finished("get_premade_library", false);
return Err(Status::invalid_argument("Invalid filename"));
}
if sanitized != req.filename {
self.record_request_duration("get_premade_library", start);
self.record_request_finished("get_premade_library", false);
return Err(Status::invalid_argument("Invalid filename"));
}
let content = match self.premade_manager.get(&sanitized) {
Ok(c) => c,
Err(e) => {
self.record_request_duration("get_premade_library", start);
self.record_request_finished("get_premade_library", false);
return Err(e);
}
};
tracing::info!("User {} fetched premade library '{}'", user_id, sanitized);
self.record_request_duration("get_premade_library", start);
let result = Ok(Response::new(GetPremadeLibraryResponse {
success: true,
name: sanitized.clone(),
content,
message: "Library fetched successfully".to_string(),
}));
self.record_request_finished("get_premade_library", result.is_ok());
result
}
async fn search_premade_libraries(
&self,
request: Request<SearchPremadeLibrariesRequest>,
) -> Result<Response<SearchPremadeLibrariesResponse>, Status> {
let request_id = uuid::Uuid::new_v4();
let start = std::time::Instant::now();
self.record_request("search_premade_libraries");
tracing::info!(request_id = %request_id, "SearchPremadeLibraries request");
let rate_limit_key = self.peer_rate_limit_key(&request);
let api_key = self.request_api_key(&request, &request.get_ref().api_key);
let req = request.into_inner();
let _user_id = self
.authenticate_and_rate_limit_with_duration(&api_key, &rate_limit_key, Some(start))
.await
.inspect_err(|_| {
self.record_request_finished("search_premade_libraries", false);
})?;
if req.query.is_empty() {
self.record_request_duration("search_premade_libraries", start);
self.record_request_finished("search_premade_libraries", false);
return Err(Status::invalid_argument("Query is required"));
}
let results = self.premade_manager.search(&req.query);
let proto_libraries: Vec<ProtoPremadeLibrary> = results
.into_iter()
.map(|l| ProtoPremadeLibrary {
name: l.name,
filename: l.filename,
description: l.description,
snippet_count: l.snippet_count,
tags: l.tags,
})
.collect();
let count = proto_libraries.len() as i32;
tracing::info!(
request_id = %request_id,
query = %req.query,
count = count,
"SearchPremadeLibraries completed"
);
self.record_request_duration("search_premade_libraries", start);
let result = Ok(Response::new(SearchPremadeLibrariesResponse {
libraries: proto_libraries,
total_count: count,
}));
self.record_request_finished("search_premade_libraries", result.is_ok());
result
}
}
#[cfg(test)]
mod tests {
use super::*;
use snip_proto::{
CreateLibraryRequest, GetPremadeLibraryRequest, GetSnippetsRequest, HealthRequest,
ListLibrariesRequest, PushSnippetsRequest, RegisterRequest, Snippet as ProtoSnippet,
SyncRequest,
};
pub async fn setup_test_service() -> SnipSyncService {
setup_test_service_with_rate_limit(DEFAULT_RATE_LIMIT_PER_MINUTE).await
}
async fn setup_test_service_with_rate_limit(rate_limit_per_minute: u32) -> SnipSyncService {
let db = Arc::new(Database::connect("sqlite::memory:", 5).await.unwrap());
let config = Config {
grpc_host: "127.0.0.1".to_string(),
grpc_port: 50051,
http_host: "127.0.0.1".to_string(),
http_port: 50050,
db_path: "sqlite::memory:".to_string(),
db_max_connections: 5,
premade_dir: PathBuf::from("premade-libraries"),
max_command_length: 1024,
max_encrypted_payload_length: DEFAULT_MAX_ENCRYPTED_PAYLOAD_LENGTH,
max_description_length: 1024,
max_tags: 50,
max_tag_length: 100,
max_id_length: 128,
max_device_id_length: 128,
max_api_key_length: 512,
request_timeout_secs: 30,
grpc_max_message_size: 4 * 1024 * 1024,
rate_limit_per_minute,
register_per_minute: DEFAULT_REGISTER_PER_MINUTE,
metrics_auth_failures_per_minute: DEFAULT_METRICS_AUTH_FAILURES_PER_MINUTE,
trusted_proxies: vec![],
metrics_username: None,
metrics_password: None,
cors_allowed_origins: vec![],
};
let metrics = Metrics::fallback();
let rate_limiter = Arc::new(RateLimiter::new());
let premade_manager = PremadeManager::new(PathBuf::from("premade-libraries"));
SnipSyncService {
db,
rate_limiter,
config,
metrics,
premade_manager,
#[cfg(any(test, feature = "test-helpers"))]
captured_auth_header: Arc::new(std::sync::Mutex::new(None)),
test_observer: None,
push_fail_after: Arc::new(std::sync::atomic::AtomicU32::new(u32::MAX)),
push_fail_counter: Arc::new(std::sync::atomic::AtomicU32::new(0)),
}
}
pub async fn register_test_user(service: &SnipSyncService) -> String {
let req = Request::new(RegisterRequest {
device_id: "test-device".to_string(),
});
let resp = service.register(req).await.unwrap();
resp.into_inner().api_key
}
#[tokio::test]
async fn test_health_check() {
let service = setup_test_service().await;
let req = Request::new(HealthRequest {});
let resp = service.health(req).await.unwrap();
let health = resp.into_inner();
assert!(health.healthy);
assert_eq!(health.version, env!("CARGO_PKG_VERSION"));
}
#[tokio::test]
async fn test_register_creates_user() {
let service = setup_test_service().await;
let req = Request::new(RegisterRequest {
device_id: "test-device".to_string(),
});
let resp = service.register(req).await.unwrap();
let reg = resp.into_inner();
assert!(reg.success);
assert!(!reg.api_key.is_empty());
assert!(!reg.device_id.is_empty());
assert!(uuid::Uuid::parse_str(®.device_id).is_ok());
}
#[tokio::test]
async fn test_register_rate_limiting() {
let service = setup_test_service_with_rate_limit(3).await;
for _ in 0..3 {
let req = Request::new(RegisterRequest {
device_id: "test-device".to_string(),
});
let _ = service.register(req).await;
}
let req = Request::new(RegisterRequest {
device_id: "test-device".to_string(),
});
let resp = service.register(req).await;
assert!(resp.is_err());
assert_eq!(resp.unwrap_err().code(), tonic::Code::ResourceExhausted);
}
#[tokio::test]
async fn peer_rate_limit_key_uses_the_peer_socket_address() {
let service = setup_test_service().await;
let mut req = Request::new(RegisterRequest {
device_id: "test-device".to_string(),
});
assert_eq!(service.peer_rate_limit_key(&req), "unknown");
req.extensions_mut()
.insert(tonic::transport::server::TcpConnectInfo {
local_addr: None,
remote_addr: Some("203.0.113.7:44321".parse().unwrap()),
});
assert_eq!(service.peer_rate_limit_key(&req), "203.0.113.7");
}
#[tokio::test]
async fn peer_rate_limit_key_honours_x_forwarded_for_from_a_trusted_proxy() {
let mut service = setup_test_service().await;
service.config.trusted_proxies = vec!["198.51.100.1".to_string()];
let mut req = Request::new(RegisterRequest {
device_id: "test-device".to_string(),
});
req.extensions_mut()
.insert(tonic::transport::server::TcpConnectInfo {
local_addr: None,
remote_addr: Some("198.51.100.1:44321".parse().unwrap()),
});
req.metadata_mut()
.insert("x-forwarded-for", "203.0.113.9:5555".parse().unwrap());
assert_eq!(service.peer_rate_limit_key(&req), "203.0.113.9");
}
#[test]
fn strip_port_handles_malformed_input_without_panicking() {
assert_eq!(strip_port("]:"), "]:");
assert_eq!(strip_port("1.2.3.4]:80"), "1.2.3.4]:80");
assert_eq!(strip_port("[::1]:443"), "::1");
assert_eq!(strip_port("[::1]"), "[::1]");
assert_eq!(strip_port("1.2.3.4:80"), "1.2.3.4");
assert_eq!(strip_port("::1"), "::1");
assert_eq!(strip_port(""), "");
}
#[tokio::test]
async fn test_create_and_list_libraries() {
let service = setup_test_service().await;
let api_key = register_test_user(&service).await;
let req = Request::new(CreateLibraryRequest {
api_key: api_key.clone(),
name: "test-lib".to_string(),
});
let resp = service.create_library(req).await.unwrap();
let create = resp.into_inner();
assert!(create.success);
assert!(!create.library_id.is_empty());
let req = Request::new(ListLibrariesRequest {
api_key: api_key.clone(),
limit: 100,
offset: 0,
});
let resp = service.list_libraries(req).await.unwrap();
let list = resp.into_inner();
assert_eq!(list.libraries.len(), 2);
assert!(list.libraries.iter().any(|l| l.name == "test-lib"));
}
#[tokio::test]
async fn test_create_duplicate_library_name() {
let service = setup_test_service().await;
let api_key = register_test_user(&service).await;
let req = Request::new(CreateLibraryRequest {
api_key: api_key.clone(),
name: "test-lib".to_string(),
});
let _ = service.create_library(req).await.unwrap();
let req = Request::new(CreateLibraryRequest {
api_key: api_key.clone(),
name: "test-lib".to_string(),
});
let resp = service.create_library(req).await;
assert!(resp.is_err());
assert_eq!(resp.unwrap_err().code(), tonic::Code::AlreadyExists);
}
#[tokio::test]
async fn test_invalid_api_key() {
let service = setup_test_service().await;
let req = Request::new(GetSnippetsRequest {
api_key: "invalid-key".to_string(),
library_id: String::new(),
limit: 100,
offset: 0,
since: 0,
});
let resp = service.get_snippets(req).await;
assert!(resp.is_err());
assert_eq!(resp.unwrap_err().code(), tonic::Code::Unauthenticated);
}
#[tokio::test]
async fn test_validate_snippet_empty_id() {
let service = setup_test_service().await;
let snippet = ProtoSnippet {
id: String::new(),
description: "test".to_string(),
command: "echo hello".to_string(),
tags: vec![],
created_at: 0,
updated_at: 0,
device_id: "device".to_string(),
deleted: false,
encrypted: false,
};
let result = service.validate_snippet(&snippet);
assert!(result.is_err());
assert!(result.unwrap_err().message().contains("ID is required"));
}
#[tokio::test]
async fn test_validate_snippet_oversized_command() {
let service = setup_test_service().await;
let snippet = ProtoSnippet {
id: "test-id".to_string(),
description: "test".to_string(),
command: "x".repeat(2000),
tags: vec![],
created_at: 0,
updated_at: 0,
device_id: "device".to_string(),
deleted: false,
encrypted: false,
};
let result = service.validate_snippet(&snippet);
assert!(result.is_err());
assert!(result.unwrap_err().message().contains("maximum length"));
}
#[tokio::test]
async fn test_validate_snippet_future_timestamp() {
let service = setup_test_service().await;
let future = time::OffsetDateTime::now_utc().unix_timestamp() + 600;
let snippet = ProtoSnippet {
id: "test-id".to_string(),
description: "test".to_string(),
command: "echo hello".to_string(),
tags: vec![],
created_at: future,
updated_at: future,
device_id: "device".to_string(),
deleted: false,
encrypted: false,
};
let result = service.validate_snippet(&snippet);
assert!(result.is_err());
let msg = result.unwrap_err().message().to_string();
assert!(
msg.contains("ahead of server time"),
"Expected clock skew message, got: {msg}"
);
}
#[tokio::test]
async fn test_validate_snippet_negative_timestamp() {
let service = setup_test_service().await;
let snippet = ProtoSnippet {
id: "test-id".to_string(),
description: "test".to_string(),
command: "echo hello".to_string(),
tags: vec![],
created_at: -1,
updated_at: -1,
device_id: "device".to_string(),
deleted: false,
encrypted: false,
};
let result = service.validate_snippet(&snippet);
assert!(result.is_err());
assert!(result.unwrap_err().message().contains("non-negative"));
}
#[tokio::test]
async fn test_validate_snippet_clock_skew_reports_magnitude() {
let service = setup_test_service().await;
let now = time::OffsetDateTime::now_utc().unix_timestamp();
let snippet = ProtoSnippet {
id: "skew-id".to_string(),
description: "test".to_string(),
command: "echo hello".to_string(),
tags: vec![],
created_at: now,
updated_at: now + 742, device_id: "device".to_string(),
deleted: false,
encrypted: false,
};
let result = service.validate_snippet(&snippet);
assert!(result.is_err());
let msg = result.unwrap_err().message().to_string();
assert!(
msg.contains("742"),
"Clock skew message should contain magnitude, got: {msg}"
);
assert!(
msg.contains("synchronize the client clock"),
"Clock skew message should contain corrective action, got: {msg}"
);
}
#[tokio::test]
async fn test_validate_snippet_created_ahead_reports_skew() {
let service = setup_test_service().await;
let now = time::OffsetDateTime::now_utc().unix_timestamp();
let snippet = ProtoSnippet {
id: "skew-created".to_string(),
description: "test".to_string(),
command: "echo hello".to_string(),
tags: vec![],
created_at: now + 500,
updated_at: now, device_id: "device".to_string(),
deleted: false,
encrypted: false,
};
let result = service.validate_snippet(&snippet);
assert!(result.is_err());
let msg = result.unwrap_err().message().to_string();
assert!(
msg.contains("created_at"),
"Should mention created_at: {msg}"
);
assert!(msg.contains("500"), "Should contain skew magnitude: {msg}");
}
#[tokio::test]
async fn test_validate_snippet_too_many_tags() {
let service = setup_test_service().await;
let snippet = ProtoSnippet {
id: "test-id".to_string(),
description: "test".to_string(),
command: "echo hello".to_string(),
tags: (0..100).map(|i| format!("tag{}", i)).collect(),
created_at: 0,
updated_at: 0,
device_id: "device".to_string(),
deleted: false,
encrypted: false,
};
let result = service.validate_snippet(&snippet);
assert!(result.is_err());
assert!(result.unwrap_err().message().contains("Too many tags"));
}
#[tokio::test]
async fn test_validate_snippet_valid() {
let service = setup_test_service().await;
let now = time::OffsetDateTime::now_utc().unix_timestamp();
let snippet = ProtoSnippet {
id: "test-id".to_string(),
description: "test".to_string(),
command: "echo hello".to_string(),
tags: vec!["bash".to_string()],
created_at: now,
updated_at: now,
device_id: "device".to_string(),
deleted: false,
encrypted: false,
};
assert!(service.validate_snippet(&snippet).is_ok());
}
#[tokio::test]
async fn test_validate_snippet_zero_timestamp_rejected() {
let service = setup_test_service().await;
let snippet = ProtoSnippet {
id: "epoch-id".to_string(),
description: "test".to_string(),
command: "echo hello".to_string(),
tags: vec![],
created_at: 0,
updated_at: 0,
device_id: "device".to_string(),
deleted: false,
encrypted: false,
};
let result = service.validate_snippet(&snippet);
assert!(result.is_err());
let msg = result.unwrap_err().message().to_string();
assert!(
msg.contains("unset client clock"),
"Expected zero-timestamp message, got: {msg}"
);
}
#[tokio::test]
async fn test_cross_user_library_access_denied() {
let service = setup_test_service().await;
let api_key1 = register_test_user(&service).await;
let req = Request::new(CreateLibraryRequest {
api_key: api_key1.clone(),
name: "user1-lib".to_string(),
});
let resp = service.create_library(req).await.unwrap();
let library_id = resp.into_inner().library_id;
let api_key2 = register_test_user(&service).await;
let req = Request::new(GetSnippetsRequest {
api_key: api_key2,
library_id,
limit: 100,
offset: 0,
since: 0,
});
let resp = service.get_snippets(req).await;
assert!(resp.is_err());
assert_eq!(resp.unwrap_err().code(), tonic::Code::NotFound);
}
#[tokio::test]
async fn test_duplicate_id_across_libraries_is_rejected_not_silently_dropped() {
let service = setup_test_service().await;
let api_key = register_test_user(&service).await;
let work = service
.create_library(Request::new(CreateLibraryRequest {
api_key: api_key.clone(),
name: "work".to_string(),
}))
.await
.unwrap()
.into_inner()
.library_id;
let personal = service
.create_library(Request::new(CreateLibraryRequest {
api_key: api_key.clone(),
name: "personal".to_string(),
}))
.await
.unwrap()
.into_inner()
.library_id;
let snippet = ProtoSnippet {
id: "legacy-abc123".to_string(),
description: "git status".to_string(),
command: "git status".to_string(),
tags: vec![],
created_at: time::OffsetDateTime::now_utc().unix_timestamp(),
updated_at: time::OffsetDateTime::now_utc().unix_timestamp(),
device_id: "device-1".to_string(),
deleted: false,
encrypted: false,
};
let first = service
.push_snippets(Request::new(PushSnippetsRequest {
api_key: api_key.clone(),
library_id: work.clone(),
snippets: vec![snippet.clone()],
}))
.await
.unwrap()
.into_inner();
assert_eq!(first.accepted_count, 1);
assert_eq!(first.rejected_count, 0);
let second = service
.push_snippets(Request::new(PushSnippetsRequest {
api_key: api_key.clone(),
library_id: personal.clone(),
snippets: vec![snippet],
}))
.await
.unwrap()
.into_inner();
assert_eq!(
second.rejected_count, 1,
"cross-library id collision must be rejected, not accepted"
);
assert_eq!(
second.accepted_count, 0,
"the dropped write must not be counted as accepted"
);
assert!(!second.success, "a partial upload must not report success");
let other = service
.get_snippets(Request::new(GetSnippetsRequest {
api_key: api_key.clone(),
library_id: personal.clone(),
limit: 100,
offset: 0,
since: 0,
}))
.await
.unwrap()
.into_inner();
assert!(other.snippets.is_empty());
let sync = service
.sync(Request::new(SyncRequest {
api_key: api_key.clone(),
local_snippets: vec![ProtoSnippet {
id: "legacy-abc123".to_string(),
description: "git status".to_string(),
command: "git status".to_string(),
tags: vec![],
created_at: time::OffsetDateTime::now_utc().unix_timestamp(),
updated_at: time::OffsetDateTime::now_utc().unix_timestamp(),
device_id: "device-1".to_string(),
deleted: false,
encrypted: false,
}],
last_sync_timestamp: 0,
last_sync_sequence: 0,
library_id: personal,
limit: 100,
offset: 0,
}))
.await
.unwrap()
.into_inner();
assert_eq!(
sync.skipped_ids,
vec!["legacy-abc123".to_string()],
"sync must surface the skipped id instead of reporting a clean run"
);
assert_eq!(sync.skipped_count, 1);
}
#[tokio::test]
async fn test_older_version_in_same_library_is_accepted_as_stale() {
let service = setup_test_service().await;
let api_key = register_test_user(&service).await;
let library_id = service
.create_library(Request::new(CreateLibraryRequest {
api_key: api_key.clone(),
name: "work".to_string(),
}))
.await
.unwrap()
.into_inner()
.library_id;
let now = time::OffsetDateTime::now_utc().unix_timestamp();
let newer = ProtoSnippet {
id: "snippet-1".to_string(),
description: "newer".to_string(),
command: "echo newer".to_string(),
tags: vec![],
created_at: now,
updated_at: now,
device_id: "device-1".to_string(),
deleted: false,
encrypted: false,
};
let older = ProtoSnippet {
description: "older".to_string(),
command: "echo older".to_string(),
created_at: now - 500,
updated_at: now - 500,
..newer.clone()
};
for snippet in [newer, older] {
let push = service
.push_snippets(Request::new(PushSnippetsRequest {
api_key: api_key.clone(),
library_id: library_id.clone(),
snippets: vec![snippet],
}))
.await
.unwrap()
.into_inner();
assert_eq!(push.accepted_count, 1);
assert_eq!(push.rejected_count, 0, "stale write is not a rejection");
}
let list = service
.get_snippets(Request::new(GetSnippetsRequest {
api_key,
library_id,
limit: 100,
offset: 0,
since: 0,
}))
.await
.unwrap()
.into_inner();
assert_eq!(list.snippets.len(), 1);
assert_eq!(list.snippets[0].command, "echo newer");
}
#[test]
fn test_fit_page_to_byte_ceiling_keeps_page_within_budget() {
let row = |i: usize| ProtoSnippet {
id: format!("snippet-{i}"),
description: "d".repeat(1024),
command: "c".repeat(1024),
tags: vec![],
created_at: 1,
updated_at: 1,
device_id: "dev".to_string(),
deleted: false,
encrypted: false,
};
let mut page: Vec<ProtoSnippet> = (0..10).map(row).collect();
let budget = 4 * 1024usize;
let truncated = fit_page_to_byte_ceiling(&mut page, budget);
assert!(truncated, "page must report that rows were dropped");
assert!(!page.is_empty(), "at least one row must always be kept");
assert!(
page.len() < 10,
"rows beyond the byte budget must be dropped, got {}",
page.len()
);
assert!(
page.iter().map(|s| s.encoded_len()).sum::<usize>() <= budget,
"kept rows must fit the budget"
);
assert_eq!(page[0].id, "snippet-0");
}
#[test]
fn test_fit_page_to_byte_ceiling_keeps_at_least_one_oversized_row() {
let mut page = vec![ProtoSnippet {
id: "huge".to_string(),
description: String::new(),
command: "x".repeat(64 * 1024),
tags: vec![],
created_at: 1,
updated_at: 1,
device_id: "dev".to_string(),
deleted: false,
encrypted: true,
}];
let truncated = fit_page_to_byte_ceiling(&mut page, 1024);
assert_eq!(page.len(), 1, "an oversized row must still be returned");
assert!(!truncated, "nothing was actually dropped");
}
#[test]
fn test_fit_page_to_byte_ceiling_noop_when_page_fits() {
let mut page = vec![ProtoSnippet {
id: "small".to_string(),
description: "d".to_string(),
command: "echo hi".to_string(),
tags: vec![],
created_at: 1,
updated_at: 1,
device_id: "dev".to_string(),
deleted: false,
encrypted: false,
}];
assert!(!fit_page_to_byte_ceiling(&mut page, 1024 * 1024));
assert_eq!(page.len(), 1);
}
#[test]
fn test_page_byte_ceiling_reserves_envelope_space() {
assert_eq!(
page_byte_ceiling(4 * 1024 * 1024, 0),
4 * 1024 * 1024 - RESPONSE_ENVELOPE_RESERVE_BYTES
);
assert_eq!(
page_byte_ceiling(4 * 1024 * 1024, 2048),
4 * 1024 * 1024 - RESPONSE_ENVELOPE_RESERVE_BYTES - 2048
);
assert_eq!(page_byte_ceiling(1024, 1024 * 1024), 0);
}
#[tokio::test]
async fn test_oversized_encrypted_payload_is_rejected() {
let service = setup_test_service().await;
let api_key = register_test_user(&service).await;
let library_id = service
.create_library(Request::new(CreateLibraryRequest {
api_key: api_key.clone(),
name: "work".to_string(),
}))
.await
.unwrap()
.into_inner()
.library_id;
let push = service
.push_snippets(Request::new(PushSnippetsRequest {
api_key,
library_id,
snippets: vec![ProtoSnippet {
id: "huge".to_string(),
description: String::new(),
command: "x".repeat(DEFAULT_MAX_ENCRYPTED_PAYLOAD_LENGTH + 1),
tags: vec![],
created_at: 1,
updated_at: 1,
device_id: "dev".to_string(),
deleted: false,
encrypted: true,
}],
}))
.await
.unwrap()
.into_inner();
assert_eq!(push.rejected_count, 1, "oversized payload must be rejected");
assert_eq!(push.accepted_count, 0);
}
#[tokio::test]
async fn test_push_and_get_snippets() {
let service = setup_test_service().await;
let api_key = register_test_user(&service).await;
let req = Request::new(CreateLibraryRequest {
api_key: api_key.clone(),
name: "test-lib".to_string(),
});
let resp = service.create_library(req).await.unwrap();
let library_id = resp.into_inner().library_id;
let snippet = ProtoSnippet {
id: "snippet-1".to_string(),
description: "Test snippet".to_string(),
command: "echo hello".to_string(),
tags: vec!["test".to_string()],
created_at: time::OffsetDateTime::now_utc().unix_timestamp(),
updated_at: time::OffsetDateTime::now_utc().unix_timestamp(),
device_id: "device-1".to_string(),
deleted: false,
encrypted: false,
};
let req = Request::new(PushSnippetsRequest {
api_key: api_key.clone(),
library_id: library_id.clone(),
snippets: vec![snippet],
});
let resp = service.push_snippets(req).await.unwrap();
let push = resp.into_inner();
assert_eq!(push.accepted_count, 1);
assert_eq!(push.rejected_count, 0);
let req = Request::new(GetSnippetsRequest {
api_key: api_key.clone(),
library_id,
limit: 100,
offset: 0,
since: 0,
});
let resp = service.get_snippets(req).await.unwrap();
let list = resp.into_inner();
assert_eq!(list.snippets.len(), 1);
assert_eq!(list.snippets[0].id, "snippet-1");
assert_eq!(list.snippets[0].command, "echo hello");
}
#[tokio::test]
async fn test_delete_library() {
let service = setup_test_service().await;
let api_key = register_test_user(&service).await;
let req = Request::new(CreateLibraryRequest {
api_key: api_key.clone(),
name: "to-delete".to_string(),
});
let resp = service.create_library(req).await.unwrap();
let library_id = resp.into_inner().library_id;
let req = Request::new(snip_proto::DeleteLibraryRequest {
api_key: api_key.clone(),
library_id: library_id.clone(),
});
let resp = service.delete_library(req).await.unwrap();
assert!(resp.into_inner().success);
let req = Request::new(ListLibrariesRequest {
api_key: api_key.clone(),
limit: 100,
offset: 0,
});
let resp = service.list_libraries(req).await.unwrap();
let list = resp.into_inner();
assert_eq!(list.libraries.len(), 1);
assert_eq!(list.libraries[0].name, "default");
}
#[tokio::test]
async fn test_delete_default_library_blocked() {
let service = setup_test_service().await;
let api_key = register_test_user(&service).await;
let req = Request::new(snip_proto::DeleteLibraryRequest {
api_key: api_key.clone(),
library_id: "default".to_string(),
});
let resp = service.delete_library(req).await;
assert!(resp.is_err());
assert!(resp.unwrap_err().message().contains("Cannot delete"));
}
#[tokio::test]
async fn test_sync_basic() {
let service = setup_test_service().await;
let api_key = register_test_user(&service).await;
let req = Request::new(CreateLibraryRequest {
api_key: api_key.clone(),
name: "sync-test".to_string(),
});
let resp = service.create_library(req).await.unwrap();
let library_id = resp.into_inner().library_id;
let req = Request::new(SyncRequest {
api_key: api_key.clone(),
local_snippets: vec![],
last_sync_timestamp: 0,
last_sync_sequence: 0,
library_id,
limit: 1000,
offset: 0,
});
let resp = service.sync(req).await.unwrap();
let sync = resp.into_inner();
assert_eq!(sync.snippets.len(), 0);
}
fn proto_snippet(id: &str, updated_at: i64) -> ProtoSnippet {
ProtoSnippet {
id: id.to_string(),
description: "Test snippet".to_string(),
command: "echo hello".to_string(),
tags: vec![],
created_at: updated_at,
updated_at,
device_id: "device-1".to_string(),
deleted: false,
encrypted: false,
}
}
#[tokio::test]
async fn test_sync_without_a_sequence_cursor_serves_the_timestamp_rows() {
let service = setup_test_service().await;
let api_key = register_test_user(&service).await;
let req = Request::new(CreateLibraryRequest {
api_key: api_key.clone(),
name: "cursor-lib".to_string(),
});
let library_id = service
.create_library(req)
.await
.unwrap()
.into_inner()
.library_id;
for (id, updated_at) in [("a", 100_i64), ("b", 200)] {
let req = Request::new(PushSnippetsRequest {
api_key: api_key.clone(),
library_id: library_id.clone(),
snippets: vec![proto_snippet(id, updated_at)],
});
service.push_snippets(req).await.unwrap();
}
let req = Request::new(SyncRequest {
api_key: api_key.clone(),
local_snippets: vec![],
last_sync_timestamp: 1,
last_sync_sequence: 0,
library_id: library_id.clone(),
limit: 1000,
offset: 0,
});
let sync = service.sync(req).await.unwrap().into_inner();
assert_eq!(sync.snippets.len(), 2);
assert_eq!(sync.server_sequence, 0);
assert!(sync.server_timestamp > 0);
}
#[tokio::test]
async fn test_sync_without_any_cursor_bootstraps_the_sequence_watermark() {
let service = setup_test_service().await;
let api_key = register_test_user(&service).await;
let req = Request::new(CreateLibraryRequest {
api_key: api_key.clone(),
name: "cursor-lib".to_string(),
});
let library_id = service
.create_library(req)
.await
.unwrap()
.into_inner()
.library_id;
for (id, updated_at) in [("a", 100_i64), ("b", 200)] {
let req = Request::new(PushSnippetsRequest {
api_key: api_key.clone(),
library_id: library_id.clone(),
snippets: vec![proto_snippet(id, updated_at)],
});
service.push_snippets(req).await.unwrap();
}
let req = Request::new(SyncRequest {
api_key: api_key.clone(),
local_snippets: vec![],
last_sync_timestamp: 0,
last_sync_sequence: 0,
library_id: library_id.clone(),
limit: 1000,
offset: 0,
});
let sync = service.sync(req).await.unwrap().into_inner();
assert_eq!(sync.snippets.len(), 2);
assert_eq!(
sync.server_sequence, 2,
"a cursorless request is the bootstrap and reports the watermark"
);
}
#[tokio::test]
async fn test_sync_bootstrap_on_an_empty_library_reports_a_sequence() {
let service = setup_test_service().await;
let api_key = register_test_user(&service).await;
let req = Request::new(CreateLibraryRequest {
api_key: api_key.clone(),
name: "empty-lib".to_string(),
});
let library_id = service
.create_library(req)
.await
.unwrap()
.into_inner()
.library_id;
let req = Request::new(SyncRequest {
api_key: api_key.clone(),
local_snippets: vec![],
last_sync_timestamp: 0,
last_sync_sequence: 0,
library_id: library_id.clone(),
limit: 1000,
offset: 0,
});
let sync = service.sync(req).await.unwrap().into_inner();
assert!(sync.snippets.is_empty());
assert_eq!(
sync.server_sequence, 1,
"an empty library must still report a sequence, so the client can \
tell a sequence-capable server from one that does not serve it"
);
let req = Request::new(PushSnippetsRequest {
api_key: api_key.clone(),
library_id: library_id.clone(),
snippets: vec![proto_snippet("first", 100)],
});
service.push_snippets(req).await.unwrap();
let req = Request::new(SyncRequest {
api_key: api_key.clone(),
local_snippets: vec![],
last_sync_timestamp: 0,
last_sync_sequence: 1,
library_id,
limit: 1000,
offset: 0,
});
let sync = service.sync(req).await.unwrap().into_inner();
assert_eq!(sync.snippets.len(), 1);
assert_eq!(sync.snippets[0].id, "first");
}
#[tokio::test]
async fn test_sync_with_a_sequence_cursor_serves_the_rows_after_it() {
let service = setup_test_service().await;
let api_key = register_test_user(&service).await;
let req = Request::new(CreateLibraryRequest {
api_key: api_key.clone(),
name: "cursor-lib".to_string(),
});
let library_id = service
.create_library(req)
.await
.unwrap()
.into_inner()
.library_id;
for (id, updated_at) in [("a", 100_i64), ("b", 200), ("c", 300)] {
let req = Request::new(PushSnippetsRequest {
api_key: api_key.clone(),
library_id: library_id.clone(),
snippets: vec![proto_snippet(id, updated_at)],
});
service.push_snippets(req).await.unwrap();
}
let req = Request::new(SyncRequest {
api_key: api_key.clone(),
local_snippets: vec![],
last_sync_timestamp: 0,
last_sync_sequence: 0,
library_id: library_id.clone(),
limit: 1000,
offset: 0,
});
let sync = service.sync(req).await.unwrap().into_inner();
assert_eq!(sync.snippets.len(), 3);
assert_eq!(sync.server_sequence, 3);
let user_id = service
.db
.get_user_by_api_key(&api_key)
.await
.unwrap()
.unwrap();
let watermark = service
.db
.get_latest_sequence(&user_id, &library_id)
.await
.unwrap();
assert_eq!(watermark, 3);
let req = Request::new(SyncRequest {
api_key: api_key.clone(),
local_snippets: vec![],
last_sync_timestamp: 0,
last_sync_sequence: watermark,
library_id: library_id.clone(),
limit: 1000,
offset: 0,
});
let sync = service.sync(req).await.unwrap().into_inner();
assert_eq!(sync.snippets.len(), 1);
assert_eq!(sync.snippets[0].id, "c");
assert_eq!(sync.server_sequence, watermark);
}
#[tokio::test]
async fn test_sync_accepts_local_record_older_than_pull_watermark() {
let service = setup_test_service().await;
let api_key = register_test_user(&service).await;
let req = Request::new(CreateLibraryRequest {
api_key: api_key.clone(),
name: "clock-skew-test".to_string(),
});
let library_id = service
.create_library(req)
.await
.unwrap()
.into_inner()
.library_id;
let req = Request::new(SyncRequest {
api_key: api_key.clone(),
local_snippets: vec![ProtoSnippet {
id: "clock-skewed".to_string(),
description: "local mutation".to_string(),
command: "echo local".to_string(),
tags: vec![],
created_at: 10,
updated_at: 10,
device_id: "device".to_string(),
deleted: false,
encrypted: false,
}],
last_sync_timestamp: 1_000,
last_sync_sequence: 0,
library_id: library_id.clone(),
limit: 100,
offset: 0,
});
service.sync(req).await.unwrap();
let response = service
.get_snippets(Request::new(GetSnippetsRequest {
api_key,
library_id,
limit: 100,
offset: 0,
since: 0,
}))
.await
.unwrap()
.into_inner();
assert_eq!(response.total_count, 1);
assert_eq!(response.snippets[0].id, "clock-skewed");
}
#[tokio::test]
async fn test_premade_filename_with_unsafe_characters_is_rejected() {
let service = setup_test_service().await;
let api_key = register_test_user(&service).await;
let req = Request::new(GetPremadeLibraryRequest {
api_key,
filename: "valid-name!.toml".to_string(),
});
let error = service.get_premade_library(req).await.unwrap_err();
assert_eq!(error.code(), tonic::Code::InvalidArgument);
assert_eq!(error.message(), "Invalid filename");
}
#[test]
fn config_load_missing_file_uses_defaults() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("missing.toml");
let config = Config::load_from(&path, &|_| None).unwrap();
assert_eq!(config.grpc_port, 50051);
assert_eq!(config.http_port, 50050);
}
#[test]
fn config_load_merges_file_and_environment_overrides() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("config.toml");
std::fs::write(
&path,
"[server]\ngrpc_port = 51000\nhttp_host = \"192.0.2.10\"\n",
)
.unwrap();
let config = Config::load_from(&path, &|name| {
(name == "GRPC_PORT").then(|| "52000".to_string())
})
.unwrap();
assert_eq!(config.grpc_port, 52000);
assert_eq!(config.http_host, "192.0.2.10");
}
#[test]
fn config_load_rejects_malformed_existing_file() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("config.toml");
std::fs::write(&path, "[server\n").unwrap();
let error = match Config::load_from(&path, &|_| None) {
Ok(_) => panic!("malformed config unexpectedly loaded"),
Err(error) => error,
};
let message = error.to_string();
assert!(message.contains(&path.display().to_string()));
assert!(message.contains("parse"));
}
#[test]
fn config_load_rejects_unreadable_existing_path() {
let dir = tempfile::tempdir().unwrap();
let error = match Config::load_from(dir.path(), &|_| None) {
Ok(_) => panic!("directory unexpectedly loaded as config"),
Err(error) => error,
};
assert!(
error
.to_string()
.contains(&dir.path().display().to_string())
);
}
#[test]
fn parse_env_valid_numeric_override() {
let env = |name: &str| match name {
"GRPC_PORT" => Some("60000".to_string()),
_ => None,
};
let val: Option<u16> = parse_env(&env, "GRPC_PORT").unwrap();
assert_eq!(val, Some(60000));
}
#[test]
fn parse_env_malformed_numeric_returns_invalid_environment() {
let env = |name: &str| match name {
"GRPC_PORT" => Some("not-a-number".to_string()),
_ => None,
};
let err = parse_env::<u16>(&env, "GRPC_PORT").unwrap_err();
match err {
ConfigLoadError::InvalidEnvironment { name, value, .. } => {
assert_eq!(name, "GRPC_PORT");
assert_eq!(value, "not-a-number");
}
other => panic!("expected InvalidEnvironment, got: {other}"),
}
}
#[test]
fn parse_env_missing_variable_returns_none() {
let env = |_name: &str| -> Option<String> { None };
let val: Option<u16> = parse_env(&env, "GRPC_PORT").unwrap();
assert_eq!(val, None);
}
#[test]
fn parse_bool_env_accepted_true_spellings() {
for input in &["true", "1", "yes", "on", "TRUE", "Yes", "ON"] {
let env = |_: &str| Some(input.to_string());
let val = parse_bool_env(&env, "FLAG").unwrap();
assert_eq!(val, Some(true), "expected true for {input:?}");
}
}
#[test]
fn parse_bool_env_accepted_false_spellings() {
for input in &["false", "0", "no", "off", "FALSE", "No", "OFF"] {
let env = |_: &str| Some(input.to_string());
let val = parse_bool_env(&env, "FLAG").unwrap();
assert_eq!(val, Some(false), "expected false for {input:?}");
}
}
#[test]
fn parse_bool_env_unknown_value_fails() {
let env = |_: &str| Some("maybe".to_string());
let err = parse_bool_env(&env, "FLAG").unwrap_err();
match err {
ConfigLoadError::InvalidEnvironment { name, value, .. } => {
assert_eq!(name, "FLAG");
assert_eq!(value, "maybe");
}
other => panic!("expected InvalidEnvironment, got: {other}"),
}
}
#[test]
fn parse_bool_env_missing_variable_returns_none() {
let env = |_name: &str| -> Option<String> { None };
let val = parse_bool_env(&env, "FLAG").unwrap();
assert_eq!(val, None);
}
#[test]
fn config_validate_rejects_zero_grpc_port() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("config.toml");
std::fs::write(&path, "[server]\ngrpc_port = 0\n").unwrap();
let err = Config::load_from(&path, &|_| None).unwrap_err();
match err {
ConfigLoadError::InvalidRange { name, .. } => assert_eq!(name, "GRPC_PORT"),
other => panic!("expected InvalidRange, got: {other}"),
}
}
#[test]
fn config_validate_rejects_zero_db_max_connections() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("config.toml");
std::fs::write(&path, "[server.database]\nmax_connections = 0\n").unwrap();
let err = Config::load_from(&path, &|_| None).unwrap_err();
match err {
ConfigLoadError::InvalidRange { name, .. } => assert_eq!(name, "DB_MAX_CONNECTIONS"),
other => panic!("expected InvalidRange, got: {other}"),
}
}
#[test]
fn config_validate_rejects_zero_request_timeout() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("config.toml");
std::fs::write(&path, "[server.limits]\nrequest_timeout_secs = 0\n").unwrap();
let err = Config::load_from(&path, &|_| None).unwrap_err();
match err {
ConfigLoadError::InvalidRange { name, .. } => assert_eq!(name, "REQUEST_TIMEOUT_SECS"),
other => panic!("expected InvalidRange, got: {other}"),
}
}
#[test]
fn config_validate_rejects_zero_register_per_minute() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("config.toml");
std::fs::write(&path, "[server.rate_limit]\nregister_per_minute = 0\n").unwrap();
let err = Config::load_from(&path, &|_| None).unwrap_err();
match err {
ConfigLoadError::InvalidRange { name, .. } => assert_eq!(name, "REGISTER_PER_MINUTE"),
other => panic!("expected InvalidRange, got: {other}"),
}
}
#[test]
fn config_validate_rejects_zero_metrics_auth_failures_per_minute() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("config.toml");
std::fs::write(
&path,
"[server.rate_limit]\nmetrics_auth_failures_per_minute = 0\n",
)
.unwrap();
let err = Config::load_from(&path, &|_| None).unwrap_err();
match err {
ConfigLoadError::InvalidRange { name, .. } => {
assert_eq!(name, "METRICS_AUTH_FAILURES_PER_MINUTE")
}
other => panic!("expected InvalidRange, got: {other}"),
}
}
#[test]
fn config_defaults_new_rate_limit_keys_when_absent() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("config.toml");
std::fs::write(&path, "[server.rate_limit]\nrequests_per_minute = 60\n").unwrap();
let config = Config::load_from(&path, &|_| None).unwrap();
assert_eq!(config.rate_limit_per_minute, 60);
assert_eq!(config.register_per_minute, DEFAULT_REGISTER_PER_MINUTE);
assert_eq!(
config.metrics_auth_failures_per_minute,
DEFAULT_METRICS_AUTH_FAILURES_PER_MINUTE
);
}
#[test]
fn config_reads_new_rate_limit_keys_from_file_and_env() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("config.toml");
std::fs::write(
&path,
"[server.rate_limit]\nregister_per_minute = 3\nmetrics_auth_failures_per_minute = 4\n",
)
.unwrap();
let config = Config::load_from(&path, &|_| None).unwrap();
assert_eq!(config.register_per_minute, 3);
assert_eq!(config.metrics_auth_failures_per_minute, 4);
let env = |name: &str| match name {
"REGISTER_PER_MINUTE" => Some("7".to_string()),
"METRICS_AUTH_FAILURES_PER_MINUTE" => Some("8".to_string()),
_ => None,
};
let config = Config::load_from(&path, &env).unwrap();
assert_eq!(config.register_per_minute, 7);
assert_eq!(config.metrics_auth_failures_per_minute, 8);
}
#[tokio::test]
async fn register_global_budget_rejects_without_writing_rows() {
let mut service = setup_test_service().await;
service.config.register_per_minute = 2;
let count_users = |db: Arc<Database>| async move {
let (count,): (i64,) = sqlx::query_as("SELECT COUNT(*) FROM users")
.fetch_one(db.pool())
.await
.expect("counting users must succeed");
count
};
for attempt in 1..=2 {
let response = service
.register(Request::new(RegisterRequest {
device_id: String::new(),
}))
.await
.unwrap_or_else(|status| {
panic!("registration {attempt} should succeed, got {status:?}")
});
assert!(response.get_ref().success);
}
assert_eq!(count_users(service.db.clone()).await, 2);
let rejection = service
.register(Request::new(RegisterRequest {
device_id: String::new(),
}))
.await
.expect_err("the third registration must exceed the global budget");
assert_eq!(rejection.code(), tonic::Code::ResourceExhausted);
assert!(
rejection.message().contains("global"),
"the rejection must be distinguishable from the per-peer budget: {}",
rejection.message()
);
assert_eq!(
count_users(service.db.clone()).await,
2,
"a rejected registration must not insert a user row"
);
}
#[test]
fn config_load_rejects_malformed_numeric_env() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("config.toml");
std::fs::write(&path, "").unwrap();
let env = |name: &str| match name {
"GRPC_PORT" => Some("abc".to_string()),
_ => None,
};
let err = Config::load_from(&path, &env).unwrap_err();
match err {
ConfigLoadError::InvalidEnvironment { name, .. } => assert_eq!(name, "GRPC_PORT"),
other => panic!("expected InvalidEnvironment, got: {other}"),
}
}
#[test]
fn config_validate_rejects_zero_max_id_length() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("config.toml");
std::fs::write(&path, "[server.limits]\nmax_id_length = 0\n").unwrap();
let err = Config::load_from(&path, &|_| None).unwrap_err();
match err {
ConfigLoadError::InvalidRange { name, .. } => assert_eq!(name, "MAX_ID_LENGTH"),
other => panic!("expected InvalidRange, got: {other}"),
}
}
#[test]
fn config_validate_rejects_zero_max_device_id_length() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("config.toml");
std::fs::write(&path, "[server.limits]\nmax_device_id_length = 0\n").unwrap();
let err = Config::load_from(&path, &|_| None).unwrap_err();
match err {
ConfigLoadError::InvalidRange { name, .. } => assert_eq!(name, "MAX_DEVICE_ID_LENGTH"),
other => panic!("expected InvalidRange, got: {other}"),
}
}
#[test]
fn config_validate_rejects_zero_max_api_key_length() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("config.toml");
std::fs::write(&path, "[server.limits]\nmax_api_key_length = 0\n").unwrap();
let err = Config::load_from(&path, &|_| None).unwrap_err();
match err {
ConfigLoadError::InvalidRange { name, .. } => assert_eq!(name, "MAX_API_KEY_LENGTH"),
other => panic!("expected InvalidRange, got: {other}"),
}
}
#[test]
fn config_validate_rejects_zero_rate_limit_per_minute() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("config.toml");
std::fs::write(&path, "[server.rate_limit]\nrequests_per_minute = 0\n").unwrap();
let err = Config::load_from(&path, &|_| None).unwrap_err();
match err {
ConfigLoadError::InvalidRange { name, .. } => {
assert_eq!(name, "RATE_LIMIT_PER_MINUTE")
}
other => panic!("expected InvalidRange, got: {other}"),
}
}
#[test]
fn config_validate_accepts_valid_boundary_values() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("config.toml");
std::fs::write(
&path,
"[server.limits]\nmax_id_length = 1\nmax_device_id_length = 1\nmax_api_key_length = 1\n[server.rate_limit]\nrequests_per_minute = 1\n",
)
.unwrap();
let config = Config::load_from(&path, &|_| None).unwrap();
assert_eq!(config.max_id_length, 1);
assert_eq!(config.max_device_id_length, 1);
assert_eq!(config.max_api_key_length, 1);
assert_eq!(config.rate_limit_per_minute, 1);
}
#[test]
fn authorization_scheme_is_matched_case_insensitively() {
for scheme in ["Bearer", "bearer", "BEARER", "BeArEr"] {
let mut request = Request::new(HealthRequest {});
request.metadata_mut().insert(
"authorization",
format!("{scheme} secret-key").parse().unwrap(),
);
assert_eq!(
extract_api_key(&request, ""),
"secret-key",
"scheme {scheme} must be accepted"
);
}
}
#[test]
fn authorization_falls_back_to_the_body_key_for_other_schemes() {
let mut request = Request::new(HealthRequest {});
request
.metadata_mut()
.insert("authorization", "Basic dXNlcjpwYXNz".parse().unwrap());
assert_eq!(extract_api_key(&request, "body-key"), "body-key");
let request = Request::new(HealthRequest {});
assert_eq!(extract_api_key(&request, "body-key"), "body-key");
}
fn snippet(id: &str, updated_at: i64) -> ProtoSnippet {
ProtoSnippet {
id: id.to_string(),
description: format!("description {id}"),
command: format!("echo {id}"),
tags: vec![],
created_at: updated_at,
updated_at,
device_id: "device".to_string(),
deleted: false,
encrypted: false,
}
}
#[tokio::test]
async fn sync_reports_a_database_failure_as_an_internal_error() {
let service = setup_test_service().await;
let api_key = register_test_user(&service).await;
sqlx::query(
"CREATE TRIGGER fail_second_insert BEFORE INSERT ON snippets \
WHEN NEW.id = 'boom' BEGIN SELECT RAISE(ABORT, 'injected failure'); END",
)
.execute(service.db.pool())
.await
.unwrap();
let request = Request::new(SyncRequest {
api_key: api_key.clone(),
local_snippets: vec![snippet("ok-1", 100), snippet("boom", 101)],
last_sync_timestamp: 0,
last_sync_sequence: 0,
library_id: String::new(),
limit: 100,
offset: 0,
});
let status = service
.sync(request)
.await
.expect_err("a database failure must not be reported as a successful sync");
assert_eq!(status.code(), tonic::Code::Internal);
assert_eq!(
service.metrics.db_errors_total.get(),
1,
"the database failure must be counted"
);
let stored: (i64,) = sqlx::query_as("SELECT COUNT(*) FROM snippets")
.fetch_one(service.db.pool())
.await
.unwrap();
assert_eq!(
stored.0, 0,
"the failed sync must not leave a partial write behind"
);
}
#[tokio::test]
async fn sync_reports_a_database_failure_without_a_skip_count() {
let service = setup_test_service().await;
let api_key = register_test_user(&service).await;
sqlx::query(
"CREATE TRIGGER fail_every_insert BEFORE INSERT ON snippets \
BEGIN SELECT RAISE(ABORT, 'injected failure'); END",
)
.execute(service.db.pool())
.await
.unwrap();
let request = Request::new(SyncRequest {
api_key: api_key.clone(),
local_snippets: vec![snippet("only", 100)],
last_sync_timestamp: 0,
last_sync_sequence: 0,
library_id: String::new(),
limit: 100,
offset: 0,
});
let status = service
.sync(request)
.await
.expect_err("expected an internal error");
assert_eq!(status.code(), tonic::Code::Internal);
assert!(status.message().contains("Internal error"));
}
#[tokio::test]
async fn sync_total_and_has_more_are_unchanged_for_a_known_dataset() {
let service = setup_test_service().await;
let api_key = register_test_user(&service).await;
let library_id = service
.create_library(Request::new(CreateLibraryRequest {
api_key: api_key.clone(),
name: "paging".to_string(),
}))
.await
.unwrap()
.into_inner()
.library_id;
let local_snippets: Vec<ProtoSnippet> = (0..5)
.map(|index| snippet(&format!("row-{index}"), 100 + index))
.collect();
let first = service
.sync(Request::new(SyncRequest {
api_key: api_key.clone(),
local_snippets,
last_sync_timestamp: 0,
last_sync_sequence: 0,
library_id: library_id.clone(),
limit: 2,
offset: 0,
}))
.await
.unwrap()
.into_inner();
assert_eq!(first.snippets.len(), 2);
assert!(first.has_more);
assert_eq!(first.total_count, 5);
let last = service
.sync(Request::new(SyncRequest {
api_key: api_key.clone(),
local_snippets: vec![],
last_sync_timestamp: 0,
last_sync_sequence: 0,
library_id: library_id.clone(),
limit: 2,
offset: 4,
}))
.await
.unwrap()
.into_inner();
assert_eq!(last.snippets.len(), 1);
assert!(!last.has_more);
assert_eq!(last.total_count, 5);
let whole = service
.sync(Request::new(SyncRequest {
api_key: api_key.clone(),
local_snippets: vec![],
last_sync_timestamp: 0,
last_sync_sequence: 0,
library_id: library_id.clone(),
limit: 100,
offset: 0,
}))
.await
.unwrap()
.into_inner();
assert_eq!(whole.snippets.len(), 5);
assert!(!whole.has_more);
assert_eq!(whole.total_count, 5);
let listed = service
.get_snippets(Request::new(GetSnippetsRequest {
api_key,
library_id,
limit: 2,
offset: 0,
since: 0,
}))
.await
.unwrap()
.into_inner();
assert_eq!(listed.snippets.len(), 2);
assert_eq!(listed.total_count, 5);
assert!(listed.has_more);
}
}