1#![allow(clippy::uninlined_format_args, clippy::new_without_default)]
13
14pub mod bootstrap;
15pub mod cert;
16pub mod cli;
17pub mod db;
18pub mod editor;
19pub mod metrics;
20pub mod orchestration;
21pub mod paths;
22pub mod premade;
23pub mod process;
24pub mod rate_limiter;
25pub mod server_lock;
26#[cfg(any(test, feature = "test-helpers"))]
27pub mod test_helpers;
28#[cfg(any(test, feature = "test-helpers"))]
29pub mod test_observer;
30
31pub use db::Database;
32pub use metrics::Metrics;
33pub use premade::PremadeManager;
34pub use rate_limiter::RateLimiter;
35
36use serde::Deserialize;
37use snip_proto::{
38 CreateLibraryRequest, CreateLibraryResponse, DeleteLibraryRequest, DeleteLibraryResponse,
39 GetPremadeLibraryRequest, GetPremadeLibraryResponse, GetSnippetsRequest, HealthRequest,
40 HealthResponse, Library, ListLibrariesRequest, ListLibrariesResponse,
41 ListPremadeLibrariesRequest, ListPremadeLibrariesResponse,
42 PremadeLibrary as ProtoPremadeLibrary, PushSnippetsRequest, PushSnippetsResponse,
43 RegisterRequest, RegisterResponse, SearchPremadeLibrariesRequest,
44 SearchPremadeLibrariesResponse, Snippet as ProtoSnippet, SnippetList, SyncRequest,
45 SyncResponse, snippet_sync_server::SnippetSync,
46};
47use std::net::SocketAddr;
48use std::path::PathBuf;
49use std::sync::Arc;
50use std::time::Duration;
51use tonic::{Request, Response, Status};
52
53pub fn extract_api_key<T>(request: &Request<T>, body_api_key: &str) -> String {
56 request
57 .metadata()
58 .get("authorization")
59 .and_then(|v| v.to_str().ok())
60 .and_then(|v| v.strip_prefix("Bearer "))
61 .filter(|v| !v.is_empty())
62 .unwrap_or(body_api_key)
63 .to_string()
64}
65
66fn strip_port(addr: &str) -> String {
67 if let Some(close_bracket) = addr.find("]:") {
68 return addr[1..close_bracket].to_string();
69 }
70 if !addr.starts_with('[') && addr.matches(':').count() > 1 {
73 return addr.to_string();
74 }
75 if let Some(colon_pos) = addr.rfind(':')
76 && !addr.starts_with('[')
77 {
78 return addr[..colon_pos].to_string();
79 }
80 addr.to_string()
81}
82
83pub const DEFAULT_MAX_COMMAND_LENGTH: usize = 1024;
84pub const DEFAULT_MAX_DESCRIPTION_LENGTH: usize = 1024;
85pub const DEFAULT_MAX_TAGS: usize = 50;
86pub const DEFAULT_MAX_TAG_LENGTH: usize = 100;
87pub const DEFAULT_MAX_ID_LENGTH: usize = 128;
88pub const DEFAULT_MAX_DEVICE_ID_LENGTH: usize = 128;
89pub const DEFAULT_MAX_API_KEY_LENGTH: usize = 512;
90pub const DEFAULT_MAX_SYNC_SNIPPETS: usize = 10000;
91pub const DEFAULT_REQUEST_TIMEOUT_SECS: u64 = 30;
92pub const DEFAULT_RATE_LIMIT_PER_MINUTE: u32 = 120;
93pub const DEFAULT_DB_MAX_CONNECTIONS: u32 = 5;
94pub const DEFAULT_GRPC_MAX_MESSAGE_SIZE: u32 = 4 * 1024 * 1024; pub const MAX_REQUEST_LIMIT: i32 = 1000;
96
97#[derive(Deserialize, Default)]
98pub struct ConfigFile {
99 pub server: Option<ServerConfig>,
100}
101
102#[derive(Deserialize, Default)]
103pub struct ServerConfig {
104 pub grpc_host: Option<String>,
105 pub grpc_port: Option<u16>,
106 pub http_host: Option<String>,
107 pub http_port: Option<u16>,
108 pub database: Option<DatabaseConfig>,
109 pub premade: Option<PremadeConfig>,
110 pub limits: Option<LimitsConfig>,
111 pub rate_limit: Option<RateLimitConfig>,
112 pub metrics: Option<MetricsConfig>,
113 pub cors: Option<CorsConfig>,
114}
115
116#[derive(Deserialize, Default)]
117pub struct DatabaseConfig {
118 pub path: Option<String>,
119 pub max_connections: Option<u32>,
120}
121
122#[derive(Deserialize, Default)]
123pub struct PremadeConfig {
124 pub directory: Option<String>,
125}
126
127#[derive(Deserialize, Default)]
128pub struct LimitsConfig {
129 pub max_command_length: Option<usize>,
130 pub max_description_length: Option<usize>,
131 pub max_tags: Option<usize>,
132 pub max_tag_length: Option<usize>,
133 pub max_id_length: Option<usize>,
134 pub max_device_id_length: Option<usize>,
135 pub max_api_key_length: Option<usize>,
136 pub request_timeout_secs: Option<u64>,
137 pub grpc_max_message_size: Option<u32>,
138}
139
140#[derive(Deserialize, Default)]
141pub struct RateLimitConfig {
142 pub requests_per_minute: Option<u32>,
143 pub trusted_proxies: Option<Vec<String>>,
144}
145
146#[derive(Deserialize, Default)]
147pub struct MetricsConfig {
148 pub username: Option<String>,
149 pub password: Option<String>,
150}
151
152#[derive(Deserialize, Default)]
153pub struct CorsConfig {
154 pub allowed_origins: Option<String>,
155}
156
157#[derive(Clone, Debug)]
158pub struct Config {
159 pub grpc_host: String,
160 pub grpc_port: u16,
161 pub http_host: String,
162 pub http_port: u16,
163 pub db_path: String,
164 pub db_max_connections: u32,
165 pub premade_dir: PathBuf,
166 pub max_command_length: usize,
167 pub max_description_length: usize,
168 pub max_tags: usize,
169 pub max_tag_length: usize,
170 pub max_id_length: usize,
171 pub max_device_id_length: usize,
172 pub max_api_key_length: usize,
173 pub request_timeout_secs: u64,
174 pub grpc_max_message_size: u32,
175 pub rate_limit_per_minute: u32,
176 pub trusted_proxies: Vec<String>,
177 pub metrics_username: Option<String>,
178 pub metrics_password: Option<String>,
179 pub cors_allowed_origins: Vec<String>,
180}
181
182#[derive(Debug, thiserror::Error)]
183pub enum ConfigLoadError {
184 #[error("failed to read configuration file {path}: {source}")]
185 Read {
186 path: PathBuf,
187 source: std::io::Error,
188 },
189 #[error("failed to parse configuration file {path}: {source}")]
190 Parse {
191 path: PathBuf,
192 source: toml::de::Error,
193 },
194 #[error("invalid environment variable {name}={value:?}: {reason}")]
195 InvalidEnvironment {
196 name: &'static str,
197 value: String,
198 reason: String,
199 },
200 #[error("invalid configuration value {name}={value:?}: {reason}")]
201 InvalidRange {
202 name: &'static str,
203 value: String,
204 reason: String,
205 },
206}
207
208pub fn parse_env<T>(
213 env: &impl Fn(&str) -> Option<String>,
214 name: &'static str,
215) -> Result<Option<T>, ConfigLoadError>
216where
217 T: std::str::FromStr,
218 T::Err: std::fmt::Display,
219{
220 match env(name) {
221 Some(val) => match val.parse::<T>() {
222 Ok(parsed) => Ok(Some(parsed)),
223 Err(e) => Err(ConfigLoadError::InvalidEnvironment {
224 name,
225 value: val,
226 reason: e.to_string(),
227 }),
228 },
229 None => Ok(None),
230 }
231}
232
233pub fn parse_bool_env(
241 env: &impl Fn(&str) -> Option<String>,
242 name: &'static str,
243) -> Result<Option<bool>, ConfigLoadError> {
244 match env(name) {
245 Some(val) => match val.to_lowercase().as_str() {
246 "true" | "1" | "yes" | "on" => Ok(Some(true)),
247 "false" | "0" | "no" | "off" => Ok(Some(false)),
248 _ => Err(ConfigLoadError::InvalidEnvironment {
249 name,
250 value: val,
251 reason: "expected one of: true, 1, yes, on, false, 0, no, off".to_string(),
252 }),
253 },
254 None => Ok(None),
255 }
256}
257
258impl Config {
259 pub fn load() -> Result<Self, ConfigLoadError> {
260 let config_path = paths::config_path();
261 Self::load_from(&config_path, &|name| std::env::var(name).ok())
262 }
263
264 fn load_from(
265 config_path: &std::path::Path,
266 env: &impl Fn(&str) -> Option<String>,
267 ) -> Result<Self, ConfigLoadError> {
268 let config_file = match std::fs::read_to_string(config_path) {
269 Ok(content) => toml::from_str(&content).map_err(|source| ConfigLoadError::Parse {
270 path: config_path.to_path_buf(),
271 source,
272 })?,
273 Err(e) if e.kind() == std::io::ErrorKind::NotFound => ConfigFile::default(),
274 Err(source) => {
275 return Err(ConfigLoadError::Read {
276 path: config_path.to_path_buf(),
277 source,
278 });
279 }
280 };
281
282 let server = config_file.server.unwrap_or_default();
283
284 let config = Self {
285 grpc_host: env("GRPC_HOST")
286 .or_else(|| server.grpc_host.clone())
287 .unwrap_or_else(|| "127.0.0.1".to_string()),
288 grpc_port: parse_env(env, "GRPC_PORT")?
289 .or(server.grpc_port)
290 .unwrap_or(50051),
291 http_host: env("HTTP_HOST")
292 .or_else(|| server.http_host.clone())
293 .unwrap_or_else(|| "127.0.0.1".to_string()),
294 http_port: parse_env(env, "HTTP_PORT")?
295 .or(server.http_port)
296 .unwrap_or(50050),
297 db_path: env("DATABASE_URL")
298 .or_else(|| server.database.as_ref().and_then(|d| d.path.clone()))
299 .unwrap_or_else(|| paths::default_db_path().to_string_lossy().into_owned()),
300 db_max_connections: parse_env(env, "DB_MAX_CONNECTIONS")?
301 .or(server.database.as_ref().and_then(|d| d.max_connections))
302 .unwrap_or(DEFAULT_DB_MAX_CONNECTIONS),
303 premade_dir: env("PREMADE_DIR")
304 .map(PathBuf::from)
305 .or_else(|| {
306 server
307 .premade
308 .as_ref()
309 .and_then(|p| p.directory.clone())
310 .map(PathBuf::from)
311 })
312 .unwrap_or_else(paths::default_premade_dir),
313 max_command_length: parse_env(env, "MAX_COMMAND_LENGTH")?
314 .or(server.limits.as_ref().and_then(|l| l.max_command_length))
315 .unwrap_or(DEFAULT_MAX_COMMAND_LENGTH),
316 max_description_length: parse_env(env, "MAX_DESCRIPTION_LENGTH")?
317 .or(server
318 .limits
319 .as_ref()
320 .and_then(|l| l.max_description_length))
321 .unwrap_or(DEFAULT_MAX_DESCRIPTION_LENGTH),
322 max_tags: parse_env(env, "MAX_TAGS")?
323 .or(server.limits.as_ref().and_then(|l| l.max_tags))
324 .unwrap_or(DEFAULT_MAX_TAGS),
325 max_tag_length: parse_env(env, "MAX_TAG_LENGTH")?
326 .or(server.limits.as_ref().and_then(|l| l.max_tag_length))
327 .unwrap_or(DEFAULT_MAX_TAG_LENGTH),
328 max_id_length: parse_env(env, "MAX_ID_LENGTH")?
329 .or(server.limits.as_ref().and_then(|l| l.max_id_length))
330 .unwrap_or(DEFAULT_MAX_ID_LENGTH),
331 max_device_id_length: parse_env(env, "MAX_DEVICE_ID_LENGTH")?
332 .or(server.limits.as_ref().and_then(|l| l.max_device_id_length))
333 .unwrap_or(DEFAULT_MAX_DEVICE_ID_LENGTH),
334 max_api_key_length: parse_env(env, "MAX_API_KEY_LENGTH")?
335 .or(server.limits.as_ref().and_then(|l| l.max_api_key_length))
336 .unwrap_or(DEFAULT_MAX_API_KEY_LENGTH),
337 request_timeout_secs: parse_env(env, "REQUEST_TIMEOUT_SECS")?
338 .or(server.limits.as_ref().and_then(|l| l.request_timeout_secs))
339 .unwrap_or(DEFAULT_REQUEST_TIMEOUT_SECS),
340 grpc_max_message_size: parse_env(env, "GRPC_MAX_MESSAGE_SIZE")?
341 .or(server.limits.as_ref().and_then(|l| l.grpc_max_message_size))
342 .unwrap_or(DEFAULT_GRPC_MAX_MESSAGE_SIZE),
343 rate_limit_per_minute: parse_env(env, "RATE_LIMIT_PER_MINUTE")?
344 .or(server
345 .rate_limit
346 .as_ref()
347 .and_then(|r| r.requests_per_minute))
348 .unwrap_or(DEFAULT_RATE_LIMIT_PER_MINUTE),
349 trusted_proxies: env("TRUSTED_PROXIES")
350 .map(|v| {
351 v.split(',')
352 .map(|s| s.trim().to_string())
353 .filter(|s| !s.is_empty() && s.parse::<std::net::IpAddr>().is_ok())
354 .collect()
355 })
356 .or_else(|| server.rate_limit.as_ref()?.trusted_proxies.clone())
357 .unwrap_or_default(),
358 metrics_username: env("METRICS_USERNAME")
359 .or_else(|| server.metrics.as_ref().and_then(|m| m.username.clone())),
360 metrics_password: env("METRICS_PASSWORD")
361 .or_else(|| server.metrics.as_ref().and_then(|m| m.password.clone())),
362 cors_allowed_origins: env("CORS_ALLOWED_ORIGINS")
363 .or_else(|| server.cors.as_ref().and_then(|c| c.allowed_origins.clone()))
364 .map(|v| {
365 v.split(',')
366 .map(str::trim)
367 .filter(|origin| !origin.is_empty())
368 .map(ToOwned::to_owned)
369 .collect()
370 })
371 .unwrap_or_default(),
372 };
373
374 config.validate()?;
375 Ok(config)
376 }
377
378 fn validate(&self) -> Result<(), ConfigLoadError> {
379 if self.grpc_port == 0 {
380 return Err(ConfigLoadError::InvalidRange {
381 name: "GRPC_PORT",
382 value: self.grpc_port.to_string(),
383 reason: "port must be nonzero".into(),
384 });
385 }
386 if self.http_port == 0 {
387 return Err(ConfigLoadError::InvalidRange {
388 name: "HTTP_PORT",
389 value: self.http_port.to_string(),
390 reason: "port must be nonzero".into(),
391 });
392 }
393 if self.db_max_connections == 0 {
394 return Err(ConfigLoadError::InvalidRange {
395 name: "DB_MAX_CONNECTIONS",
396 value: self.db_max_connections.to_string(),
397 reason: "must be at least 1".into(),
398 });
399 }
400 if self.request_timeout_secs == 0 {
401 return Err(ConfigLoadError::InvalidRange {
402 name: "REQUEST_TIMEOUT_SECS",
403 value: self.request_timeout_secs.to_string(),
404 reason: "must be at least 1".into(),
405 });
406 }
407 if self.grpc_max_message_size == 0 {
408 return Err(ConfigLoadError::InvalidRange {
409 name: "GRPC_MAX_MESSAGE_SIZE",
410 value: self.grpc_max_message_size.to_string(),
411 reason: "must be greater than 0".into(),
412 });
413 }
414 if self.max_command_length == 0 {
415 return Err(ConfigLoadError::InvalidRange {
416 name: "MAX_COMMAND_LENGTH",
417 value: self.max_command_length.to_string(),
418 reason: "must be nonzero".into(),
419 });
420 }
421 if self.max_description_length == 0 {
422 return Err(ConfigLoadError::InvalidRange {
423 name: "MAX_DESCRIPTION_LENGTH",
424 value: self.max_description_length.to_string(),
425 reason: "must be nonzero".into(),
426 });
427 }
428 if self.max_tags == 0 {
429 return Err(ConfigLoadError::InvalidRange {
430 name: "MAX_TAGS",
431 value: self.max_tags.to_string(),
432 reason: "must be nonzero".into(),
433 });
434 }
435 if self.max_tag_length == 0 {
436 return Err(ConfigLoadError::InvalidRange {
437 name: "MAX_TAG_LENGTH",
438 value: self.max_tag_length.to_string(),
439 reason: "must be nonzero".into(),
440 });
441 }
442 if self.max_id_length == 0 {
443 return Err(ConfigLoadError::InvalidRange {
444 name: "MAX_ID_LENGTH",
445 value: self.max_id_length.to_string(),
446 reason: "must be nonzero".into(),
447 });
448 }
449 if self.max_device_id_length == 0 {
450 return Err(ConfigLoadError::InvalidRange {
451 name: "MAX_DEVICE_ID_LENGTH",
452 value: self.max_device_id_length.to_string(),
453 reason: "must be nonzero".into(),
454 });
455 }
456 if self.max_api_key_length == 0 {
457 return Err(ConfigLoadError::InvalidRange {
458 name: "MAX_API_KEY_LENGTH",
459 value: self.max_api_key_length.to_string(),
460 reason: "must be nonzero".into(),
461 });
462 }
463 if self.rate_limit_per_minute == 0 {
464 return Err(ConfigLoadError::InvalidRange {
465 name: "RATE_LIMIT_PER_MINUTE",
466 value: self.rate_limit_per_minute.to_string(),
467 reason: "must be nonzero".into(),
468 });
469 }
470 Ok(())
471 }
472
473 pub fn ensure_config_file() {
474 if let Err(e) = bootstrap::ensure_config_file() {
475 tracing::warn!("{}", e);
476 }
477 }
478}
479
480#[derive(Clone)]
481pub struct AppState {
482 pub config: Config,
483 pub metrics: Metrics,
484 pub db: Arc<Database>,
485}
486
487pub struct SnipSyncService {
488 pub db: Arc<Database>,
489 pub rate_limiter: Arc<RateLimiter>,
490 pub config: Config,
491 pub metrics: Metrics,
492 pub premade_manager: PremadeManager,
493 #[cfg(any(test, feature = "test-helpers"))]
499 pub captured_auth_header: Arc<std::sync::Mutex<Option<String>>>,
500 #[cfg(any(test, feature = "test-helpers"))]
504 pub test_observer: Option<Arc<dyn crate::test_observer::TestRequestObserver>>,
505 #[cfg(any(test, feature = "test-helpers"))]
509 pub push_fail_after: Arc<std::sync::atomic::AtomicU32>,
510 #[cfg(any(test, feature = "test-helpers"))]
513 pub push_fail_counter: Arc<std::sync::atomic::AtomicU32>,
514}
515
516impl SnipSyncService {
517 pub fn record_request(&self, method: &str) {
518 self.metrics
519 .requests_total
520 .with_label_values(&[method])
521 .inc();
522 tracing::trace!("Request: {}", method);
523 #[cfg(feature = "test-helpers")]
524 if let Some(ref obs) = self.test_observer {
525 use crate::test_observer::{RequestStarted, now_millis, operation_name_for_method};
526 let sequence = obs.allocate_sequence();
527 let concurrent = obs.current_concurrent();
528 obs.request_started(RequestStarted {
529 sequence,
530 started_at_unix_ms: now_millis(),
531 method: method.to_string(),
532 operation: operation_name_for_method(method).to_string(),
533 authenticated_user_id: None,
534 authenticated_device_id: None,
535 target_library_id: None,
536 request_revision: None,
537 payload_len: 0,
538 payload_sha256: String::new(),
539 payload_contains_plaintext_sentinel: false,
540 concurrent_at_start: concurrent,
541 });
542 }
543 }
544
545 #[cfg_attr(not(feature = "test-helpers"), allow(unused_variables))]
546 pub fn record_request_finished(&self, method: &str, success: bool) {
547 #[cfg(feature = "test-helpers")]
548 if let Some(ref obs) = self.test_observer {
549 use crate::test_observer::RequestFinished;
550 let sequence = obs.last_started_sequence_for_method(method);
551 obs.request_finished(RequestFinished {
552 sequence,
553 finished_at_unix_ms: crate::test_observer::now_millis(),
554 success,
555 response_revision: None,
556 });
557 }
558 }
559
560 #[cfg_attr(not(feature = "test-helpers"), allow(unused_variables))]
565 pub fn update_request_ids(
566 &self,
567 method: &str,
568 user_id: Option<String>,
569 device_id: Option<String>,
570 library_id: Option<String>,
571 ) {
572 #[cfg(feature = "test-helpers")]
573 if let Some(ref obs) = self.test_observer {
574 obs.update_ids_for_last_method(method, user_id, device_id, library_id);
575 }
576 }
577
578 pub fn record_request_duration(&self, method: &str, start: std::time::Instant) {
579 let duration = start.elapsed().as_secs_f64();
580 self.metrics
581 .request_duration_seconds
582 .with_label_values(&[method])
583 .observe(duration);
584 tracing::debug!("Request {} completed in {:.3}s", method, duration);
585 }
586
587 pub fn record_rate_limit(&self) {
588 self.metrics.rate_limit_hits.inc();
589 }
590
591 pub fn record_auth_failure(&self) {
592 self.metrics.auth_failures.inc();
593 }
594
595 pub fn record_sync(&self, direction: &str) {
596 self.metrics
597 .sync_operations_total
598 .with_label_values(&[direction])
599 .inc();
600 }
601
602 pub fn record_library_op(&self, operation: &str) {
603 self.metrics
604 .library_operations_total
605 .with_label_values(&[operation])
606 .inc();
607 }
608
609 fn request_api_key<T>(&self, request: &Request<T>, body_api_key: &str) -> String {
610 let api_key = extract_api_key(request, body_api_key);
611 #[cfg(any(test, feature = "test-helpers"))]
612 self.capture_test_auth_header(&api_key);
613 api_key
614 }
615
616 #[cfg(any(test, feature = "test-helpers"))]
617 fn capture_test_auth_header(&self, api_key: &str) {
618 if !api_key.is_empty() {
619 let mut slot = self
620 .captured_auth_header
621 .lock()
622 .unwrap_or_else(|e| e.into_inner());
623 if slot.is_none() {
624 *slot = Some(format!("Bearer {api_key}"));
625 }
626 }
627 }
628
629 pub async fn authenticate_and_rate_limit(&self, api_key: &str) -> Result<String, Status> {
630 self.authenticate_and_rate_limit_with_duration(api_key, None)
631 .await
632 }
633
634 pub async fn authenticate_and_rate_limit_with_duration(
637 &self,
638 api_key: &str,
639 start: Option<std::time::Instant>,
640 ) -> Result<String, Status> {
641 if api_key.is_empty() {
642 if let Some(s) = start {
643 self.record_request_duration("auth", s);
644 }
645 return Err(Status::unauthenticated("API key is required"));
646 }
647 if api_key.len() > self.config.max_api_key_length {
648 if let Some(s) = start {
649 self.record_request_duration("auth", s);
650 }
651 return Err(Status::invalid_argument(format!(
652 "API key exceeds maximum length of {} bytes",
653 self.config.max_api_key_length
654 )));
655 }
656
657 if !self
658 .rate_limiter
659 .allow(
660 api_key,
661 self.config.rate_limit_per_minute as usize,
662 Duration::from_secs(60),
663 )
664 .await
665 {
666 self.record_rate_limit();
667 if let Some(s) = start {
668 self.record_request_duration("auth", s);
669 }
670 return Err(Status::resource_exhausted("Rate limit exceeded"));
671 }
672
673 let user_id = self
674 .db
675 .get_user_by_api_key(api_key)
676 .await
677 .map_err(|_| {
678 if let Some(s) = start {
679 self.record_request_duration("auth", s);
680 }
681 Status::internal("Internal error")
682 })?
683 .ok_or_else(|| {
684 self.record_auth_failure();
685 if let Some(s) = start {
686 self.record_request_duration("auth", s);
687 }
688 Status::unauthenticated("Invalid API key")
689 })?;
690
691 Ok(user_id)
692 }
693
694 pub fn validate_snippet(&self, snippet: &ProtoSnippet) -> Result<(), Status> {
695 if snippet.id.is_empty() {
696 return Err(Status::invalid_argument("Snippet ID is required"));
697 }
698 if snippet.id.len() > self.config.max_id_length {
699 return Err(Status::invalid_argument(format!(
700 "Snippet ID exceeds maximum length of {} bytes",
701 self.config.max_id_length
702 )));
703 }
704
705 if snippet.device_id.is_empty() {
706 return Err(Status::invalid_argument("Device ID is required"));
707 }
708 if snippet.device_id.len() > self.config.max_device_id_length {
709 return Err(Status::invalid_argument(format!(
710 "Device ID exceeds maximum length of {} bytes",
711 self.config.max_device_id_length
712 )));
713 }
714
715 if !snippet.encrypted && snippet.command.len() > self.config.max_command_length {
716 return Err(Status::invalid_argument(format!(
717 "Command exceeds maximum length of {} bytes",
718 self.config.max_command_length
719 )));
720 }
721
722 if !snippet.encrypted && snippet.command.trim().is_empty() {
723 return Err(Status::invalid_argument("Snippet command is required"));
724 }
725
726 if snippet.encrypted && (snippet.command.is_empty() || snippet.command.trim().is_empty()) {
727 return Err(Status::invalid_argument(
728 "Encrypted snippet payload is required",
729 ));
730 }
731
732 if snippet.description.len() > self.config.max_description_length {
733 return Err(Status::invalid_argument(format!(
734 "Description exceeds maximum length of {} bytes",
735 self.config.max_description_length
736 )));
737 }
738
739 if snippet.tags.len() > self.config.max_tags {
740 return Err(Status::invalid_argument(format!(
741 "Too many tags (max {})",
742 self.config.max_tags
743 )));
744 }
745
746 for tag in &snippet.tags {
747 if tag.len() > self.config.max_tag_length {
748 return Err(Status::invalid_argument(format!(
749 "Tag '{}' exceeds maximum length of {} bytes",
750 tag, self.config.max_tag_length
751 )));
752 }
753 }
754
755 let now = chrono::Utc::now().timestamp();
758 let tolerance = 300; if snippet.updated_at > now + tolerance {
761 let skew = snippet.updated_at - now;
762 return Err(Status::invalid_argument(format!(
763 "updated_at is {} seconds ahead of server time; \
764 synchronize the client clock and retry",
765 skew
766 )));
767 }
768 if snippet.created_at > now + tolerance {
769 let skew = snippet.created_at - now;
770 return Err(Status::invalid_argument(format!(
771 "created_at is {} seconds ahead of server time; \
772 synchronize the client clock and retry",
773 skew
774 )));
775 }
776 if snippet.created_at < 0 || snippet.updated_at < 0 {
777 return Err(Status::invalid_argument("Timestamps must be non-negative"));
778 }
779 if snippet.created_at > snippet.updated_at {
780 return Err(Status::invalid_argument(
781 "created_at must not be greater than updated_at",
782 ));
783 }
784
785 Ok(())
786 }
787}
788
789#[tonic::async_trait]
790impl SnippetSync for SnipSyncService {
791 async fn health(
792 &self,
793 _request: Request<HealthRequest>,
794 ) -> Result<Response<HealthResponse>, Status> {
795 let request_id = uuid::Uuid::new_v4();
796 let start = std::time::Instant::now();
797 self.record_request("health");
798 tracing::debug!(request_id = %request_id, "Health check");
799 let healthy = self.db.ping().await.is_ok();
800 self.record_request_duration("health", start);
801 self.record_request_finished("health", healthy);
802 Ok(Response::new(HealthResponse {
803 healthy,
804 version: env!("CARGO_PKG_VERSION").to_string(),
805 }))
806 }
807
808 async fn register(
809 &self,
810 request: Request<RegisterRequest>,
811 ) -> Result<Response<RegisterResponse>, Status> {
812 let request_id = uuid::Uuid::new_v4();
813 let start = std::time::Instant::now();
814 self.record_request("register");
815 tracing::info!(request_id = %request_id, "Register request");
816
817 let peer_ip = request
820 .extensions()
821 .get::<SocketAddr>()
822 .map(|addr| addr.ip().to_string());
823
824 let rate_limit_key = if let Some(ref ip) = peer_ip
825 && self.config.trusted_proxies.contains(ip)
826 {
827 request
828 .metadata()
829 .get("x-forwarded-for")
830 .and_then(|v| v.to_str().ok())
831 .and_then(|header| header.split(',').next())
832 .map(|s| strip_port(s.trim()))
833 .unwrap_or_else(|| ip.clone())
834 } else {
835 peer_ip.unwrap_or_else(|| "unknown".to_string())
836 };
837
838 if !self
839 .rate_limiter
840 .allow(
841 &rate_limit_key,
842 self.config.rate_limit_per_minute as usize,
843 Duration::from_secs(60),
844 )
845 .await
846 {
847 self.record_rate_limit();
848 self.record_request_duration("register", start);
849 self.record_request_finished("register", false);
850 return Err(Status::resource_exhausted(
851 "Rate limit exceeded for registration",
852 ));
853 }
854
855 let _req = request.into_inner();
856
857 let api_key = uuid::Uuid::new_v4().to_string();
858
859 match self.db.create_user(&api_key).await {
860 Ok(device_id) => {
861 if uuid::Uuid::parse_str(&device_id).is_err() {
862 tracing::error!(
863 request_id = %request_id,
864 "Generated device_id is not a valid UUID: {}",
865 device_id
866 );
867 self.record_request_duration("register", start);
868 self.record_request_finished("register", false);
869 return Err(Status::internal(
870 "Internal error: invalid device ID generated",
871 ));
872 }
873 tracing::info!(
874 request_id = %request_id,
875 device_id = %device_id,
876 "Created new user"
877 );
878 self.record_request_duration("register", start);
879 self.record_request_finished("register", true);
880 Ok(Response::new(RegisterResponse {
881 success: true,
882 api_key,
883 message: "Account created successfully".to_string(),
884 device_id,
885 }))
886 }
887 Err(e) => {
888 tracing::error!(request_id = %request_id, "Failed to create user: {}", e);
889 self.record_request_duration("register", start);
890 self.record_request_finished("register", false);
891 Err(Status::internal("Internal error"))
892 }
893 }
894 }
895
896 async fn get_snippets(
897 &self,
898 request: Request<GetSnippetsRequest>,
899 ) -> Result<Response<SnippetList>, Status> {
900 let request_id = uuid::Uuid::new_v4();
901 let start = std::time::Instant::now();
902 self.record_request("get_snippets");
903 tracing::info!(request_id = %request_id, "GetSnippets request");
904 let api_key = self.request_api_key(&request, &request.get_ref().api_key);
905 let req = request.into_inner();
906
907 let user_id = self
908 .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
909 .await
910 .inspect_err(|_| {
911 self.record_request_finished("get_snippets", false);
912 })?;
913
914 let library_id = if req.library_id.is_empty() {
915 self.db.get_default_library(&user_id).await.map_err(|e| {
916 self.record_request_duration("get_snippets", start);
917 self.record_request_finished("get_snippets", false);
918 tracing::error!("Internal error: {}", e);
919 Status::internal("Internal error")
920 })?
921 } else {
922 if !self
923 .db
924 .verify_library_ownership(&user_id, &req.library_id)
925 .await
926 .map_err(|e| {
927 self.record_request_duration("get_snippets", start);
928 self.record_request_finished("get_snippets", false);
929 tracing::error!("Internal error: {}", e);
930 Status::internal("Internal error")
931 })?
932 {
933 tracing::warn!(
934 "User {} attempted to access library {} without ownership",
935 user_id,
936 req.library_id
937 );
938 self.record_request_duration("get_snippets", start);
939 self.record_request_finished("get_snippets", false);
940 return Err(Status::not_found("Library not found"));
941 }
942 req.library_id
943 };
944
945 self.update_request_ids(
947 "get_snippets",
948 Some(user_id.clone()),
949 None,
950 Some(library_id.clone()),
951 );
952
953 let limit = if req.limit > 0 {
954 req.limit.clamp(1, MAX_REQUEST_LIMIT)
955 } else {
956 100
957 };
958 let offset = if req.offset > 0 { req.offset } else { 0 };
959
960 let (snippets, total) = self
961 .db
962 .get_snippets(&user_id, &library_id, req.since, limit, offset, false)
963 .await
964 .map_err(|e| {
965 self.record_request_duration("get_snippets", start);
966 self.record_request_finished("get_snippets", false);
967 tracing::error!("Internal error: {}", e);
968 Status::internal("Internal error")
969 })?;
970
971 let has_more = offset.saturating_add(snippets.len() as i32) < total;
972
973 let proto_snippets: Vec<ProtoSnippet> = snippets
974 .into_iter()
975 .map(|s| ProtoSnippet {
976 id: s.id,
977 description: s.description,
978 command: s.command,
979 tags: s.tags,
980 created_at: s.created_at,
981 updated_at: s.updated_at,
982 device_id: s.device_id,
983 deleted: s.deleted,
984 encrypted: s.encrypted,
985 })
986 .collect();
987
988 self.record_request_duration("get_snippets", start);
989
990 let result = Ok(Response::new(SnippetList {
991 snippets: proto_snippets,
992 total_count: total,
993 has_more,
994 }));
995 self.record_request_finished("get_snippets", result.is_ok());
996 result
997 }
998
999 async fn push_snippets(
1000 &self,
1001 request: Request<PushSnippetsRequest>,
1002 ) -> Result<Response<PushSnippetsResponse>, Status> {
1003 let request_id = uuid::Uuid::new_v4();
1004 let start = std::time::Instant::now();
1005 self.record_request("push_snippets");
1006 tracing::info!(request_id = %request_id, "PushSnippets request");
1007 let api_key = self.request_api_key(&request, &request.get_ref().api_key);
1008 let req = request.into_inner();
1009
1010 let user_id = self
1011 .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
1012 .await
1013 .inspect_err(|_| {
1014 self.record_request_finished("push_snippets", false);
1015 })?;
1016
1017 let library_id = if req.library_id.is_empty() {
1018 self.db.get_default_library(&user_id).await.map_err(|e| {
1019 self.record_request_duration("push_snippets", start);
1020 self.record_request_finished("push_snippets", false);
1021 tracing::error!("Internal error: {}", e);
1022 Status::internal("Internal error")
1023 })?
1024 } else {
1025 if !self
1026 .db
1027 .verify_library_ownership(&user_id, &req.library_id)
1028 .await
1029 .map_err(|e| {
1030 self.record_request_duration("push_snippets", start);
1031 self.record_request_finished("push_snippets", false);
1032 tracing::error!("Internal error: {}", e);
1033 Status::internal("Internal error")
1034 })?
1035 {
1036 tracing::warn!(
1037 "User {} attempted to push to library {} without ownership",
1038 user_id,
1039 req.library_id
1040 );
1041 self.record_request_duration("push_snippets", start);
1042 self.record_request_finished("push_snippets", false);
1043 return Err(Status::not_found("Library not found"));
1044 }
1045 req.library_id
1046 };
1047
1048 self.update_request_ids(
1050 "push_snippets",
1051 Some(user_id.clone()),
1052 req.snippets.first().map(|s| s.device_id.clone()),
1053 Some(library_id.clone()),
1054 );
1055
1056 if req.snippets.len() > DEFAULT_MAX_SYNC_SNIPPETS {
1057 self.record_request_duration("push_snippets", start);
1058 self.record_request_finished("push_snippets", false);
1059 return Err(Status::invalid_argument(format!(
1060 "Too many snippets in push request (max {}), got {}",
1061 DEFAULT_MAX_SYNC_SNIPPETS,
1062 req.snippets.len()
1063 )));
1064 }
1065
1066 #[cfg(feature = "test-helpers")]
1072 {
1073 let threshold = self
1074 .push_fail_after
1075 .load(std::sync::atomic::Ordering::SeqCst);
1076 if threshold != u32::MAX {
1077 let count = self
1078 .push_fail_counter
1079 .fetch_add(1, std::sync::atomic::Ordering::SeqCst)
1080 + 1;
1081 if count >= threshold {
1082 self.record_request_duration("push_snippets", start);
1083 self.record_request_finished("push_snippets", false);
1084 return Err(Status::internal("test-injected push failure"));
1085 }
1086 }
1087 }
1088
1089 let mut accepted = 0;
1090 let mut rejected = 0;
1091
1092 let mut tx = self.db.pool().begin().await.map_err(|e| {
1093 self.record_request_duration("push_snippets", start);
1094 self.record_request_finished("push_snippets", false);
1095 tracing::error!(request_id = %request_id, "Failed to begin transaction: {}", e);
1096 Status::internal("Internal error")
1097 })?;
1098
1099 for snippet in req.snippets {
1100 if let Err(e) = self.validate_snippet(&snippet) {
1101 rejected += 1;
1102 tracing::warn!(request_id = %request_id, snippet_id = %snippet.id, reason = %e, "Snippet validation failed");
1103 continue;
1104 }
1105
1106 let db_snippet = db::Snippet {
1107 id: snippet.id.clone(),
1108 description: snippet.description,
1109 command: snippet.command,
1110 tags: snippet.tags,
1111 created_at: snippet.created_at,
1112 updated_at: snippet.updated_at,
1113 device_id: snippet.device_id,
1114 deleted: snippet.deleted,
1115 encrypted: snippet.encrypted,
1116 };
1117
1118 match self
1119 .db
1120 .upsert_snippet_in_tx(&mut tx, &db_snippet, &user_id, &library_id)
1121 .await
1122 {
1123 Ok(_) => accepted += 1,
1124 Err(e) => {
1125 tracing::warn!(
1126 request_id = %request_id,
1127 snippet_id = %snippet.id,
1128 reason = %e,
1129 "Snippet upsert failed"
1130 );
1131 rejected += 1;
1132 }
1133 }
1134 }
1135
1136 tx.commit().await.map_err(|e| {
1137 self.record_request_duration("push_snippets", start);
1138 self.record_request_finished("push_snippets", false);
1139 tracing::error!(request_id = %request_id, "Failed to commit transaction: {}", e);
1140 Status::internal("Internal error")
1141 })?;
1142
1143 self.record_request_duration("push_snippets", start);
1144
1145 let result = Ok(Response::new(PushSnippetsResponse {
1146 success: rejected == 0,
1147 message: format!("Accepted {}, rejected {}", accepted, rejected),
1148 accepted_count: accepted,
1149 rejected_count: rejected,
1150 }));
1151 self.record_request_finished("push_snippets", result.is_ok());
1152 result
1153 }
1154
1155 async fn sync(&self, request: Request<SyncRequest>) -> Result<Response<SyncResponse>, Status> {
1156 let request_id = uuid::Uuid::new_v4();
1157 let start = std::time::Instant::now();
1158 self.record_request("sync");
1159 tracing::info!(request_id = %request_id, "Sync request");
1160 let api_key = self.request_api_key(&request, &request.get_ref().api_key);
1161 let req = request.into_inner();
1162
1163 let user_id = self
1164 .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
1165 .await
1166 .inspect_err(|_| {
1167 self.record_request_finished("sync", false);
1168 })?;
1169
1170 if req.local_snippets.len() > DEFAULT_MAX_SYNC_SNIPPETS {
1171 self.record_request_duration("sync", start);
1172 self.record_request_finished("sync", false);
1173 return Err(Status::invalid_argument(format!(
1174 "Too many snippets in sync request (max {}), got {}",
1175 DEFAULT_MAX_SYNC_SNIPPETS,
1176 req.local_snippets.len()
1177 )));
1178 }
1179
1180 self.record_sync("bidirectional");
1181
1182 let library_id = if req.library_id.is_empty() {
1183 self.db.get_default_library(&user_id).await.map_err(|e| {
1184 self.record_request_duration("sync", start);
1185 self.record_request_finished("sync", false);
1186 tracing::error!("Internal error: {}", e);
1187 Status::internal("Internal error")
1188 })?
1189 } else {
1190 if !self
1191 .db
1192 .verify_library_ownership(&user_id, &req.library_id)
1193 .await
1194 .map_err(|e| {
1195 self.record_request_duration("sync", start);
1196 self.record_request_finished("sync", false);
1197 tracing::error!("Internal error: {}", e);
1198 Status::internal("Internal error")
1199 })?
1200 {
1201 tracing::warn!(
1202 "User {} attempted to sync with library {} without ownership",
1203 user_id,
1204 req.library_id
1205 );
1206 self.record_request_duration("sync", start);
1207 self.record_request_finished("sync", false);
1208 return Err(Status::not_found("Library not found"));
1209 }
1210 req.library_id
1211 };
1212
1213 self.update_request_ids(
1215 "sync",
1216 Some(user_id.clone()),
1217 req.local_snippets.first().map(|s| s.device_id.clone()),
1218 Some(library_id.clone()),
1219 );
1220
1221 let mut skipped_ids = Vec::new();
1222
1223 let mut tx = self.db.pool().begin().await.map_err(|e| {
1224 self.record_request_duration("sync", start);
1225 self.record_request_finished("sync", false);
1226 tracing::error!(request_id = %request_id, "Failed to begin transaction: {}", e);
1227 Status::internal("Internal error")
1228 })?;
1229
1230 for snippet in &req.local_snippets {
1231 if let Err(e) = self.validate_snippet(snippet) {
1232 tracing::warn!(
1233 request_id = %request_id,
1234 snippet_id = %snippet.id,
1235 reason = %e,
1236 "Snippet skipped: validation failed"
1237 );
1238 skipped_ids.push(snippet.id.clone());
1239 continue;
1240 }
1241
1242 if snippet.updated_at <= req.last_sync_timestamp {
1243 continue;
1244 }
1245
1246 let db_snippet = db::Snippet {
1247 id: snippet.id.clone(),
1248 description: snippet.description.clone(),
1249 command: snippet.command.clone(),
1250 tags: snippet.tags.clone(),
1251 created_at: snippet.created_at,
1252 updated_at: snippet.updated_at,
1253 device_id: snippet.device_id.clone(),
1254 deleted: snippet.deleted,
1255 encrypted: snippet.encrypted,
1256 };
1257
1258 if let Err(e) = self
1259 .db
1260 .upsert_snippet_in_tx(&mut tx, &db_snippet, &user_id, &library_id)
1261 .await
1262 {
1263 tracing::warn!(
1264 request_id = %request_id,
1265 snippet_id = %snippet.id,
1266 reason = %e,
1267 "Snippet skipped: upsert failed"
1268 );
1269 skipped_ids.push(snippet.id.clone());
1270 }
1271 }
1272
1273 tx.commit().await.map_err(|e| {
1274 self.record_request_duration("sync", start);
1275 self.record_request_finished("sync", false);
1276 tracing::error!(request_id = %request_id, "Failed to commit transaction: {}", e);
1277 Status::internal("Internal error")
1278 })?;
1279
1280 let limit = if req.limit > 0 {
1281 req.limit.clamp(1, MAX_REQUEST_LIMIT)
1282 } else {
1283 1000
1284 };
1285
1286 let offset = if req.offset > 0 { req.offset } else { 0 };
1287
1288 let (snippets, total) = self
1289 .db
1290 .get_snippets(
1291 &user_id,
1292 &library_id,
1293 req.last_sync_timestamp,
1294 limit,
1295 offset,
1296 true,
1297 )
1298 .await
1299 .map_err(|e| {
1300 self.record_request_duration("sync", start);
1301 self.record_request_finished("sync", false);
1302 tracing::error!("Internal error: {}", e);
1303 Status::internal("Internal error")
1304 })?;
1305
1306 let has_more = offset.saturating_add(snippets.len() as i32) < total;
1307
1308 let timestamp = if has_more {
1309 req.last_sync_timestamp
1311 } else {
1312 self.db
1313 .get_latest_timestamp(&user_id, &library_id)
1314 .await
1315 .map_err(|e| {
1316 self.record_request_duration("sync", start);
1317 self.record_request_finished("sync", false);
1318 tracing::error!("Internal error: {}", e);
1319 Status::internal("Internal error")
1320 })?
1321 };
1322
1323 let proto_snippets: Vec<ProtoSnippet> = snippets
1324 .into_iter()
1325 .map(|s| ProtoSnippet {
1326 id: s.id,
1327 description: s.description,
1328 command: s.command,
1329 tags: s.tags,
1330 created_at: s.created_at,
1331 updated_at: s.updated_at,
1332 device_id: s.device_id,
1333 deleted: s.deleted,
1334 encrypted: s.encrypted,
1335 })
1336 .collect();
1337
1338 let skipped_count = skipped_ids.len() as i32;
1339
1340 tracing::info!(
1341 request_id = %request_id,
1342 snippets_synced = proto_snippets.len(),
1343 skipped_count = skipped_count,
1344 has_more = has_more,
1345 "Sync completed"
1346 );
1347
1348 self.record_request_duration("sync", start);
1349
1350 let result = Ok(Response::new(SyncResponse {
1351 success: true,
1352 message: if skipped_count > 0 {
1353 format!("Sync completed, {} snippets skipped", skipped_count)
1354 } else {
1355 "Sync completed".to_string()
1356 },
1357 snippets: proto_snippets,
1358 server_timestamp: timestamp,
1359 skipped_count,
1360 skipped_ids,
1361 has_more,
1362 total_count: total,
1363 }));
1364 self.record_request_finished("sync", result.is_ok());
1365 result
1366 }
1367
1368 async fn create_library(
1369 &self,
1370 request: Request<CreateLibraryRequest>,
1371 ) -> Result<Response<CreateLibraryResponse>, Status> {
1372 let request_id = uuid::Uuid::new_v4();
1373 let start = std::time::Instant::now();
1374 self.record_request("create_library");
1375 self.record_library_op("create");
1376 tracing::info!(request_id = %request_id, "CreateLibrary request");
1377 let api_key = self.request_api_key(&request, &request.get_ref().api_key);
1378 let req = request.into_inner();
1379
1380 let user_id = self
1381 .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
1382 .await
1383 .inspect_err(|_| {
1384 self.record_request_finished("create_library", false);
1385 })?;
1386
1387 let result = match self.db.create_library(&user_id, &req.name).await {
1388 Ok(lib_id) => {
1389 tracing::info!("Created library '{}' for user {}", req.name, user_id);
1390 self.record_request_duration("create_library", start);
1391 Ok(Response::new(CreateLibraryResponse {
1392 success: true,
1393 library_id: lib_id,
1394 message: format!("Library '{}' created successfully", req.name),
1395 }))
1396 }
1397 Err(db::DbError::Conflict(msg)) => {
1398 self.record_request_duration("create_library", start);
1399 Err(Status::already_exists(msg))
1400 }
1401 Err(db::DbError::Validation(msg)) => {
1402 self.record_request_duration("create_library", start);
1403 Err(Status::invalid_argument(msg))
1404 }
1405 Err(db::DbError::NotFound(msg)) => {
1406 self.record_request_duration("create_library", start);
1407 Err(Status::invalid_argument(msg))
1408 }
1409 Err(db::DbError::Internal(msg)) => {
1410 tracing::error!("Internal error creating library: {}", msg);
1411 self.record_request_duration("create_library", start);
1412 Err(Status::internal("Internal error"))
1413 }
1414 Err(db::DbError::Database(e)) => {
1415 tracing::error!("Database error creating library: {}", e);
1416 self.record_request_duration("create_library", start);
1417 Err(Status::internal("Internal error"))
1418 }
1419 };
1420 self.record_request_finished("create_library", result.is_ok());
1421 result
1422 }
1423
1424 async fn list_libraries(
1425 &self,
1426 request: Request<ListLibrariesRequest>,
1427 ) -> Result<Response<ListLibrariesResponse>, Status> {
1428 let request_id = uuid::Uuid::new_v4();
1429 let start = std::time::Instant::now();
1430 self.record_request("list_libraries");
1431 self.record_library_op("list");
1432 tracing::info!(request_id = %request_id, "ListLibraries request");
1433 let api_key = self.request_api_key(&request, &request.get_ref().api_key);
1434 let req = request.into_inner();
1435
1436 let user_id = self
1437 .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
1438 .await
1439 .inspect_err(|_| {
1440 self.record_request_finished("list_libraries", false);
1441 })?;
1442
1443 let limit = if req.limit > 0 {
1444 req.limit.clamp(1, MAX_REQUEST_LIMIT)
1445 } else {
1446 50
1447 };
1448 let offset = if req.offset > 0 { req.offset } else { 0 };
1449
1450 let (libraries, total) = self
1451 .db
1452 .list_libraries(&user_id, limit, offset)
1453 .await
1454 .map_err(|e| {
1455 self.record_request_duration("list_libraries", start);
1456 self.record_request_finished("list_libraries", false);
1457 tracing::error!("Internal error: {}", e);
1458 Status::internal("Internal error")
1459 })?;
1460
1461 let has_more = offset.saturating_add(libraries.len() as i32) < total;
1462
1463 let proto_libraries: Vec<Library> = libraries
1464 .into_iter()
1465 .map(|l| Library {
1466 id: l.id,
1467 name: l.name,
1468 created_at: l.created_at,
1469 snippet_count: l.snippet_count,
1470 })
1471 .collect();
1472
1473 self.record_request_duration("list_libraries", start);
1474
1475 let result = Ok(Response::new(ListLibrariesResponse {
1476 libraries: proto_libraries,
1477 total_count: total,
1478 has_more,
1479 }));
1480 self.record_request_finished("list_libraries", result.is_ok());
1481 result
1482 }
1483
1484 async fn delete_library(
1485 &self,
1486 request: Request<DeleteLibraryRequest>,
1487 ) -> Result<Response<DeleteLibraryResponse>, Status> {
1488 let request_id = uuid::Uuid::new_v4();
1489 let start = std::time::Instant::now();
1490 self.record_request("delete_library");
1491 self.record_library_op("delete");
1492 tracing::info!(request_id = %request_id, "DeleteLibrary request");
1493 let api_key = self.request_api_key(&request, &request.get_ref().api_key);
1494 let req = request.into_inner();
1495
1496 let user_id = self
1497 .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
1498 .await
1499 .inspect_err(|_| {
1500 self.record_request_finished("delete_library", false);
1501 })?;
1502
1503 if req.library_id.is_empty() || req.library_id == "default" {
1506 self.record_request_duration("delete_library", start);
1507 self.record_request_finished("delete_library", false);
1508 return Err(Status::invalid_argument("Cannot delete default library"));
1509 }
1510 if let Ok(default_id) = self.db.get_default_library(&user_id).await
1511 && req.library_id == default_id
1512 {
1513 self.record_request_duration("delete_library", start);
1514 self.record_request_finished("delete_library", false);
1515 return Err(Status::invalid_argument("Cannot delete default library"));
1516 }
1517
1518 let result = match self.db.delete_library(&user_id, &req.library_id).await {
1519 Ok(_) => {
1520 tracing::info!("Deleted library {} for user {}", req.library_id, user_id);
1521 Ok(Response::new(DeleteLibraryResponse {
1522 success: true,
1523 message: "Library deleted successfully".to_string(),
1524 }))
1525 }
1526 Err(db::DbError::NotFound(msg)) => Err(Status::not_found(msg)),
1527 Err(db::DbError::Conflict(msg)) => Err(Status::failed_precondition(msg)),
1528 Err(db::DbError::Validation(msg)) => Err(Status::invalid_argument(msg)),
1529 Err(db::DbError::Internal(msg)) => {
1530 tracing::error!("Internal error deleting library: {}", msg);
1531 Err(Status::internal("Internal error"))
1532 }
1533 Err(db::DbError::Database(e)) => {
1534 tracing::error!("Failed to delete library: {}", e);
1535 Err(Status::internal("Internal error"))
1536 }
1537 };
1538 self.record_request_duration("delete_library", start);
1539 self.record_request_finished("delete_library", result.is_ok());
1540 result
1541 }
1542
1543 async fn list_premade_libraries(
1544 &self,
1545 request: Request<ListPremadeLibrariesRequest>,
1546 ) -> Result<Response<ListPremadeLibrariesResponse>, Status> {
1547 let request_id = uuid::Uuid::new_v4();
1548 let start = std::time::Instant::now();
1549 self.record_request("list_premade_libraries");
1550 tracing::info!(request_id = %request_id, "ListPremadeLibraries request");
1551 let api_key = self.request_api_key(&request, &request.get_ref().api_key);
1552 let _req = request.into_inner();
1553
1554 let user_id = self
1555 .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
1556 .await
1557 .inspect_err(|_| {
1558 self.record_request_finished("list_premade_libraries", false);
1559 })?;
1560
1561 let libraries = self.premade_manager.list();
1562
1563 let proto_libraries: Vec<ProtoPremadeLibrary> = libraries
1564 .into_iter()
1565 .map(|l| ProtoPremadeLibrary {
1566 name: l.name,
1567 filename: l.filename,
1568 description: l.description,
1569 snippet_count: l.snippet_count,
1570 tags: l.tags,
1571 })
1572 .collect();
1573
1574 tracing::info!(
1575 request_id = %request_id,
1576 user_id = %user_id,
1577 count = proto_libraries.len(),
1578 "ListPremadeLibraries completed"
1579 );
1580
1581 let count = proto_libraries.len() as i32;
1582
1583 self.record_request_duration("list_premade_libraries", start);
1584
1585 let result = Ok(Response::new(ListPremadeLibrariesResponse {
1586 libraries: proto_libraries,
1587 has_more: false,
1588 total_count: count,
1589 }));
1590 self.record_request_finished("list_premade_libraries", result.is_ok());
1591 result
1592 }
1593
1594 async fn get_premade_library(
1595 &self,
1596 request: Request<GetPremadeLibraryRequest>,
1597 ) -> Result<Response<GetPremadeLibraryResponse>, Status> {
1598 let request_id = uuid::Uuid::new_v4();
1599 let start = std::time::Instant::now();
1600 self.record_request("get_premade_library");
1601 tracing::info!(request_id = %request_id, "GetPremadeLibrary request");
1602 let api_key = self.request_api_key(&request, &request.get_ref().api_key);
1603 let req = request.into_inner();
1604
1605 let user_id = self
1606 .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
1607 .await
1608 .inspect_err(|_| {
1609 self.record_request_finished("get_premade_library", false);
1610 })?;
1611
1612 if req.filename.is_empty() {
1613 self.record_request_duration("get_premade_library", start);
1614 self.record_request_finished("get_premade_library", false);
1615 return Err(Status::invalid_argument("Filename is required"));
1616 }
1617
1618 if req.filename.contains("..") || req.filename.contains('/') || req.filename.contains('\\')
1619 {
1620 self.record_request_duration("get_premade_library", start);
1621 self.record_request_finished("get_premade_library", false);
1622 return Err(Status::invalid_argument("Invalid filename"));
1623 }
1624
1625 let sanitized: String = req
1626 .filename
1627 .chars()
1628 .filter(|c| c.is_alphanumeric() || *c == '-' || *c == '_' || *c == '.')
1629 .collect();
1630
1631 if sanitized.is_empty() || sanitized.len() > 64 {
1632 self.record_request_duration("get_premade_library", start);
1633 self.record_request_finished("get_premade_library", false);
1634 return Err(Status::invalid_argument("Invalid filename"));
1635 }
1636 if sanitized != req.filename {
1637 self.record_request_duration("get_premade_library", start);
1638 self.record_request_finished("get_premade_library", false);
1639 return Err(Status::invalid_argument("Invalid filename"));
1640 }
1641
1642 let content = match self.premade_manager.get(&sanitized) {
1643 Ok(c) => c,
1644 Err(e) => {
1645 self.record_request_duration("get_premade_library", start);
1646 self.record_request_finished("get_premade_library", false);
1647 return Err(e);
1648 }
1649 };
1650
1651 tracing::info!("User {} fetched premade library '{}'", user_id, sanitized);
1652
1653 self.record_request_duration("get_premade_library", start);
1654
1655 let result = Ok(Response::new(GetPremadeLibraryResponse {
1656 success: true,
1657 name: sanitized.clone(),
1658 content,
1659 message: "Library fetched successfully".to_string(),
1660 }));
1661 self.record_request_finished("get_premade_library", result.is_ok());
1662 result
1663 }
1664
1665 async fn search_premade_libraries(
1666 &self,
1667 request: Request<SearchPremadeLibrariesRequest>,
1668 ) -> Result<Response<SearchPremadeLibrariesResponse>, Status> {
1669 let request_id = uuid::Uuid::new_v4();
1670 let start = std::time::Instant::now();
1671 self.record_request("search_premade_libraries");
1672 tracing::info!(request_id = %request_id, "SearchPremadeLibraries request");
1673 let api_key = self.request_api_key(&request, &request.get_ref().api_key);
1674 let req = request.into_inner();
1675
1676 let _user_id = self
1677 .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
1678 .await
1679 .inspect_err(|_| {
1680 self.record_request_finished("search_premade_libraries", false);
1681 })?;
1682
1683 if req.query.is_empty() {
1684 self.record_request_duration("search_premade_libraries", start);
1685 self.record_request_finished("search_premade_libraries", false);
1686 return Err(Status::invalid_argument("Query is required"));
1687 }
1688
1689 let results = self.premade_manager.search(&req.query);
1690
1691 let proto_libraries: Vec<ProtoPremadeLibrary> = results
1692 .into_iter()
1693 .map(|l| ProtoPremadeLibrary {
1694 name: l.name,
1695 filename: l.filename,
1696 description: l.description,
1697 snippet_count: l.snippet_count,
1698 tags: l.tags,
1699 })
1700 .collect();
1701
1702 let count = proto_libraries.len() as i32;
1703
1704 tracing::info!(
1705 request_id = %request_id,
1706 query = %req.query,
1707 count = count,
1708 "SearchPremadeLibraries completed"
1709 );
1710
1711 self.record_request_duration("search_premade_libraries", start);
1712
1713 let result = Ok(Response::new(SearchPremadeLibrariesResponse {
1714 libraries: proto_libraries,
1715 total_count: count,
1716 }));
1717 self.record_request_finished("search_premade_libraries", result.is_ok());
1718 result
1719 }
1720}
1721
1722#[cfg(test)]
1723mod tests {
1724 use super::*;
1725 use snip_proto::{
1726 CreateLibraryRequest, GetPremadeLibraryRequest, GetSnippetsRequest, HealthRequest,
1727 ListLibrariesRequest, PushSnippetsRequest, RegisterRequest, Snippet as ProtoSnippet,
1728 SyncRequest,
1729 };
1730
1731 pub async fn setup_test_service() -> SnipSyncService {
1732 setup_test_service_with_rate_limit(DEFAULT_RATE_LIMIT_PER_MINUTE).await
1733 }
1734
1735 async fn setup_test_service_with_rate_limit(rate_limit_per_minute: u32) -> SnipSyncService {
1736 let db = Arc::new(Database::connect("sqlite::memory:", 5).await.unwrap());
1737 let config = Config {
1738 grpc_host: "127.0.0.1".to_string(),
1739 grpc_port: 50051,
1740 http_host: "127.0.0.1".to_string(),
1741 http_port: 50050,
1742 db_path: "sqlite::memory:".to_string(),
1743 db_max_connections: 5,
1744 premade_dir: PathBuf::from("premade-libraries"),
1745 max_command_length: 1024,
1746 max_description_length: 1024,
1747 max_tags: 50,
1748 max_tag_length: 100,
1749 max_id_length: 128,
1750 max_device_id_length: 128,
1751 max_api_key_length: 512,
1752 request_timeout_secs: 30,
1753 grpc_max_message_size: 4 * 1024 * 1024,
1754 rate_limit_per_minute,
1755 trusted_proxies: vec![],
1756 metrics_username: None,
1757 metrics_password: None,
1758 cors_allowed_origins: vec![],
1759 };
1760 let metrics = Metrics::fallback();
1761 let rate_limiter = Arc::new(RateLimiter::new());
1762 let premade_manager = PremadeManager::new(PathBuf::from("premade-libraries"));
1763
1764 SnipSyncService {
1765 db,
1766 rate_limiter,
1767 config,
1768 metrics,
1769 premade_manager,
1770 #[cfg(any(test, feature = "test-helpers"))]
1771 captured_auth_header: Arc::new(std::sync::Mutex::new(None)),
1772 test_observer: None,
1773 push_fail_after: Arc::new(std::sync::atomic::AtomicU32::new(u32::MAX)),
1774 push_fail_counter: Arc::new(std::sync::atomic::AtomicU32::new(0)),
1775 }
1776 }
1777
1778 pub async fn register_test_user(service: &SnipSyncService) -> String {
1779 let req = Request::new(RegisterRequest {
1780 device_id: "test-device".to_string(),
1781 });
1782 let resp = service.register(req).await.unwrap();
1783 resp.into_inner().api_key
1784 }
1785
1786 #[tokio::test]
1787 async fn test_health_check() {
1788 let service = setup_test_service().await;
1789 let req = Request::new(HealthRequest {});
1790 let resp = service.health(req).await.unwrap();
1791 let health = resp.into_inner();
1792 assert!(health.healthy);
1793 assert_eq!(health.version, env!("CARGO_PKG_VERSION"));
1794 }
1795
1796 #[tokio::test]
1797 async fn test_register_creates_user() {
1798 let service = setup_test_service().await;
1799 let req = Request::new(RegisterRequest {
1800 device_id: "test-device".to_string(),
1801 });
1802 let resp = service.register(req).await.unwrap();
1803 let reg = resp.into_inner();
1804 assert!(reg.success);
1805 assert!(!reg.api_key.is_empty());
1806 assert!(!reg.device_id.is_empty());
1807 assert!(uuid::Uuid::parse_str(®.device_id).is_ok());
1808 }
1809
1810 #[tokio::test]
1811 async fn test_register_rate_limiting() {
1812 let service = setup_test_service_with_rate_limit(3).await;
1813 for _ in 0..3 {
1814 let req = Request::new(RegisterRequest {
1815 device_id: "test-device".to_string(),
1816 });
1817 let _ = service.register(req).await;
1818 }
1819 let req = Request::new(RegisterRequest {
1820 device_id: "test-device".to_string(),
1821 });
1822 let resp = service.register(req).await;
1823 assert!(resp.is_err());
1824 assert_eq!(resp.unwrap_err().code(), tonic::Code::ResourceExhausted);
1825 }
1826
1827 #[tokio::test]
1828 async fn test_create_and_list_libraries() {
1829 let service = setup_test_service().await;
1830 let api_key = register_test_user(&service).await;
1831
1832 let req = Request::new(CreateLibraryRequest {
1833 api_key: api_key.clone(),
1834 name: "test-lib".to_string(),
1835 });
1836 let resp = service.create_library(req).await.unwrap();
1837 let create = resp.into_inner();
1838 assert!(create.success);
1839 assert!(!create.library_id.is_empty());
1840
1841 let req = Request::new(ListLibrariesRequest {
1842 api_key: api_key.clone(),
1843 limit: 100,
1844 offset: 0,
1845 });
1846 let resp = service.list_libraries(req).await.unwrap();
1847 let list = resp.into_inner();
1848 assert_eq!(list.libraries.len(), 2);
1849 assert!(list.libraries.iter().any(|l| l.name == "test-lib"));
1850 }
1851
1852 #[tokio::test]
1853 async fn test_create_duplicate_library_name() {
1854 let service = setup_test_service().await;
1855 let api_key = register_test_user(&service).await;
1856
1857 let req = Request::new(CreateLibraryRequest {
1858 api_key: api_key.clone(),
1859 name: "test-lib".to_string(),
1860 });
1861 let _ = service.create_library(req).await.unwrap();
1862
1863 let req = Request::new(CreateLibraryRequest {
1864 api_key: api_key.clone(),
1865 name: "test-lib".to_string(),
1866 });
1867 let resp = service.create_library(req).await;
1868 assert!(resp.is_err());
1869 assert_eq!(resp.unwrap_err().code(), tonic::Code::AlreadyExists);
1870 }
1871
1872 #[tokio::test]
1873 async fn test_invalid_api_key() {
1874 let service = setup_test_service().await;
1875 let req = Request::new(GetSnippetsRequest {
1876 api_key: "invalid-key".to_string(),
1877 library_id: String::new(),
1878 limit: 100,
1879 offset: 0,
1880 since: 0,
1881 });
1882 let resp = service.get_snippets(req).await;
1883 assert!(resp.is_err());
1884 assert_eq!(resp.unwrap_err().code(), tonic::Code::Unauthenticated);
1885 }
1886
1887 #[tokio::test]
1888 async fn test_validate_snippet_empty_id() {
1889 let service = setup_test_service().await;
1890 let snippet = ProtoSnippet {
1891 id: String::new(),
1892 description: "test".to_string(),
1893 command: "echo hello".to_string(),
1894 tags: vec![],
1895 created_at: 0,
1896 updated_at: 0,
1897 device_id: "device".to_string(),
1898 deleted: false,
1899 encrypted: false,
1900 };
1901 let result = service.validate_snippet(&snippet);
1902 assert!(result.is_err());
1903 assert!(result.unwrap_err().message().contains("ID is required"));
1904 }
1905
1906 #[tokio::test]
1907 async fn test_validate_snippet_oversized_command() {
1908 let service = setup_test_service().await;
1909 let snippet = ProtoSnippet {
1910 id: "test-id".to_string(),
1911 description: "test".to_string(),
1912 command: "x".repeat(2000),
1913 tags: vec![],
1914 created_at: 0,
1915 updated_at: 0,
1916 device_id: "device".to_string(),
1917 deleted: false,
1918 encrypted: false,
1919 };
1920 let result = service.validate_snippet(&snippet);
1921 assert!(result.is_err());
1922 assert!(result.unwrap_err().message().contains("maximum length"));
1923 }
1924
1925 #[tokio::test]
1926 async fn test_validate_snippet_future_timestamp() {
1927 let service = setup_test_service().await;
1928 let future = chrono::Utc::now().timestamp() + 600;
1929 let snippet = ProtoSnippet {
1930 id: "test-id".to_string(),
1931 description: "test".to_string(),
1932 command: "echo hello".to_string(),
1933 tags: vec![],
1934 created_at: future,
1935 updated_at: future,
1936 device_id: "device".to_string(),
1937 deleted: false,
1938 encrypted: false,
1939 };
1940 let result = service.validate_snippet(&snippet);
1941 assert!(result.is_err());
1942 let msg = result.unwrap_err().message().to_string();
1943 assert!(
1944 msg.contains("ahead of server time"),
1945 "Expected clock skew message, got: {msg}"
1946 );
1947 }
1948
1949 #[tokio::test]
1950 async fn test_validate_snippet_negative_timestamp() {
1951 let service = setup_test_service().await;
1952 let snippet = ProtoSnippet {
1953 id: "test-id".to_string(),
1954 description: "test".to_string(),
1955 command: "echo hello".to_string(),
1956 tags: vec![],
1957 created_at: -1,
1958 updated_at: -1,
1959 device_id: "device".to_string(),
1960 deleted: false,
1961 encrypted: false,
1962 };
1963 let result = service.validate_snippet(&snippet);
1964 assert!(result.is_err());
1965 assert!(result.unwrap_err().message().contains("non-negative"));
1966 }
1967
1968 #[tokio::test]
1969 async fn test_validate_snippet_clock_skew_reports_magnitude() {
1970 let service = setup_test_service().await;
1971 let now = chrono::Utc::now().timestamp();
1972 let snippet = ProtoSnippet {
1973 id: "skew-id".to_string(),
1974 description: "test".to_string(),
1975 command: "echo hello".to_string(),
1976 tags: vec![],
1977 created_at: now,
1978 updated_at: now + 742, device_id: "device".to_string(),
1980 deleted: false,
1981 encrypted: false,
1982 };
1983 let result = service.validate_snippet(&snippet);
1984 assert!(result.is_err());
1985 let msg = result.unwrap_err().message().to_string();
1986 assert!(
1987 msg.contains("742"),
1988 "Clock skew message should contain magnitude, got: {msg}"
1989 );
1990 assert!(
1991 msg.contains("synchronize the client clock"),
1992 "Clock skew message should contain corrective action, got: {msg}"
1993 );
1994 }
1995
1996 #[tokio::test]
1997 async fn test_validate_snippet_created_ahead_reports_skew() {
1998 let service = setup_test_service().await;
1999 let now = chrono::Utc::now().timestamp();
2000 let snippet = ProtoSnippet {
2001 id: "skew-created".to_string(),
2002 description: "test".to_string(),
2003 command: "echo hello".to_string(),
2004 tags: vec![],
2005 created_at: now + 500,
2006 updated_at: now, device_id: "device".to_string(),
2008 deleted: false,
2009 encrypted: false,
2010 };
2011 let result = service.validate_snippet(&snippet);
2012 assert!(result.is_err());
2013 let msg = result.unwrap_err().message().to_string();
2014 assert!(
2015 msg.contains("created_at"),
2016 "Should mention created_at: {msg}"
2017 );
2018 assert!(msg.contains("500"), "Should contain skew magnitude: {msg}");
2019 }
2020
2021 #[tokio::test]
2022 async fn test_validate_snippet_too_many_tags() {
2023 let service = setup_test_service().await;
2024 let snippet = ProtoSnippet {
2025 id: "test-id".to_string(),
2026 description: "test".to_string(),
2027 command: "echo hello".to_string(),
2028 tags: (0..100).map(|i| format!("tag{}", i)).collect(),
2029 created_at: 0,
2030 updated_at: 0,
2031 device_id: "device".to_string(),
2032 deleted: false,
2033 encrypted: false,
2034 };
2035 let result = service.validate_snippet(&snippet);
2036 assert!(result.is_err());
2037 assert!(result.unwrap_err().message().contains("Too many tags"));
2038 }
2039
2040 #[tokio::test]
2041 async fn test_validate_snippet_valid() {
2042 let service = setup_test_service().await;
2043 let snippet = ProtoSnippet {
2044 id: "test-id".to_string(),
2045 description: "test".to_string(),
2046 command: "echo hello".to_string(),
2047 tags: vec!["bash".to_string()],
2048 created_at: 0,
2049 updated_at: 0,
2050 device_id: "device".to_string(),
2051 deleted: false,
2052 encrypted: false,
2053 };
2054 assert!(service.validate_snippet(&snippet).is_ok());
2055 }
2056
2057 #[tokio::test]
2058 async fn test_cross_user_library_access_denied() {
2059 let service = setup_test_service().await;
2060 let api_key1 = register_test_user(&service).await;
2061
2062 let req = Request::new(CreateLibraryRequest {
2063 api_key: api_key1.clone(),
2064 name: "user1-lib".to_string(),
2065 });
2066 let resp = service.create_library(req).await.unwrap();
2067 let library_id = resp.into_inner().library_id;
2068
2069 let api_key2 = register_test_user(&service).await;
2070
2071 let req = Request::new(GetSnippetsRequest {
2072 api_key: api_key2,
2073 library_id,
2074 limit: 100,
2075 offset: 0,
2076 since: 0,
2077 });
2078 let resp = service.get_snippets(req).await;
2079 assert!(resp.is_err());
2080 assert_eq!(resp.unwrap_err().code(), tonic::Code::NotFound);
2081 }
2082
2083 #[tokio::test]
2084 async fn test_push_and_get_snippets() {
2085 let service = setup_test_service().await;
2086 let api_key = register_test_user(&service).await;
2087
2088 let req = Request::new(CreateLibraryRequest {
2089 api_key: api_key.clone(),
2090 name: "test-lib".to_string(),
2091 });
2092 let resp = service.create_library(req).await.unwrap();
2093 let library_id = resp.into_inner().library_id;
2094
2095 let snippet = ProtoSnippet {
2096 id: "snippet-1".to_string(),
2097 description: "Test snippet".to_string(),
2098 command: "echo hello".to_string(),
2099 tags: vec!["test".to_string()],
2100 created_at: chrono::Utc::now().timestamp(),
2101 updated_at: chrono::Utc::now().timestamp(),
2102 device_id: "device-1".to_string(),
2103 deleted: false,
2104 encrypted: false,
2105 };
2106 let req = Request::new(PushSnippetsRequest {
2107 api_key: api_key.clone(),
2108 library_id: library_id.clone(),
2109 snippets: vec![snippet],
2110 });
2111 let resp = service.push_snippets(req).await.unwrap();
2112 let push = resp.into_inner();
2113 assert_eq!(push.accepted_count, 1);
2114 assert_eq!(push.rejected_count, 0);
2115
2116 let req = Request::new(GetSnippetsRequest {
2117 api_key: api_key.clone(),
2118 library_id,
2119 limit: 100,
2120 offset: 0,
2121 since: 0,
2122 });
2123 let resp = service.get_snippets(req).await.unwrap();
2124 let list = resp.into_inner();
2125 assert_eq!(list.snippets.len(), 1);
2126 assert_eq!(list.snippets[0].id, "snippet-1");
2127 assert_eq!(list.snippets[0].command, "echo hello");
2128 }
2129
2130 #[tokio::test]
2131 async fn test_delete_library() {
2132 let service = setup_test_service().await;
2133 let api_key = register_test_user(&service).await;
2134
2135 let req = Request::new(CreateLibraryRequest {
2136 api_key: api_key.clone(),
2137 name: "to-delete".to_string(),
2138 });
2139 let resp = service.create_library(req).await.unwrap();
2140 let library_id = resp.into_inner().library_id;
2141
2142 let req = Request::new(snip_proto::DeleteLibraryRequest {
2143 api_key: api_key.clone(),
2144 library_id: library_id.clone(),
2145 });
2146 let resp = service.delete_library(req).await.unwrap();
2147 assert!(resp.into_inner().success);
2148
2149 let req = Request::new(ListLibrariesRequest {
2150 api_key: api_key.clone(),
2151 limit: 100,
2152 offset: 0,
2153 });
2154 let resp = service.list_libraries(req).await.unwrap();
2155 let list = resp.into_inner();
2156 assert_eq!(list.libraries.len(), 1);
2157 assert_eq!(list.libraries[0].name, "default");
2158 }
2159
2160 #[tokio::test]
2161 async fn test_delete_default_library_blocked() {
2162 let service = setup_test_service().await;
2163 let api_key = register_test_user(&service).await;
2164
2165 let req = Request::new(snip_proto::DeleteLibraryRequest {
2166 api_key: api_key.clone(),
2167 library_id: "default".to_string(),
2168 });
2169 let resp = service.delete_library(req).await;
2170 assert!(resp.is_err());
2171 assert!(resp.unwrap_err().message().contains("Cannot delete"));
2172 }
2173
2174 #[tokio::test]
2175 async fn test_sync_basic() {
2176 let service = setup_test_service().await;
2177 let api_key = register_test_user(&service).await;
2178
2179 let req = Request::new(CreateLibraryRequest {
2180 api_key: api_key.clone(),
2181 name: "sync-test".to_string(),
2182 });
2183 let resp = service.create_library(req).await.unwrap();
2184 let library_id = resp.into_inner().library_id;
2185
2186 let req = Request::new(SyncRequest {
2187 api_key: api_key.clone(),
2188 local_snippets: vec![],
2189 last_sync_timestamp: 0,
2190 library_id,
2191 limit: 1000,
2192 offset: 0,
2193 });
2194 let resp = service.sync(req).await.unwrap();
2195 let sync = resp.into_inner();
2196 assert_eq!(sync.snippets.len(), 0);
2197 }
2198
2199 #[tokio::test]
2200 async fn test_premade_filename_with_unsafe_characters_is_rejected() {
2201 let service = setup_test_service().await;
2202 let api_key = register_test_user(&service).await;
2203
2204 let req = Request::new(GetPremadeLibraryRequest {
2205 api_key,
2206 filename: "valid-name!.toml".to_string(),
2207 });
2208 let error = service.get_premade_library(req).await.unwrap_err();
2209
2210 assert_eq!(error.code(), tonic::Code::InvalidArgument);
2211 assert_eq!(error.message(), "Invalid filename");
2212 }
2213
2214 #[test]
2215 fn config_load_missing_file_uses_defaults() {
2216 let dir = tempfile::tempdir().unwrap();
2217 let path = dir.path().join("missing.toml");
2218 let config = Config::load_from(&path, &|_| None).unwrap();
2219 assert_eq!(config.grpc_port, 50051);
2220 assert_eq!(config.http_port, 50050);
2221 }
2222
2223 #[test]
2224 fn config_load_merges_file_and_environment_overrides() {
2225 let dir = tempfile::tempdir().unwrap();
2226 let path = dir.path().join("config.toml");
2227 std::fs::write(
2228 &path,
2229 "[server]\ngrpc_port = 51000\nhttp_host = \"192.0.2.10\"\n",
2230 )
2231 .unwrap();
2232 let config = Config::load_from(&path, &|name| {
2233 (name == "GRPC_PORT").then(|| "52000".to_string())
2234 })
2235 .unwrap();
2236 assert_eq!(config.grpc_port, 52000);
2237 assert_eq!(config.http_host, "192.0.2.10");
2238 }
2239
2240 #[test]
2241 fn config_load_rejects_malformed_existing_file() {
2242 let dir = tempfile::tempdir().unwrap();
2243 let path = dir.path().join("config.toml");
2244 std::fs::write(&path, "[server\n").unwrap();
2245 let error = match Config::load_from(&path, &|_| None) {
2246 Ok(_) => panic!("malformed config unexpectedly loaded"),
2247 Err(error) => error,
2248 };
2249 let message = error.to_string();
2250 assert!(message.contains(&path.display().to_string()));
2251 assert!(message.contains("parse"));
2252 }
2253
2254 #[test]
2255 fn config_load_rejects_unreadable_existing_path() {
2256 let dir = tempfile::tempdir().unwrap();
2257 let error = match Config::load_from(dir.path(), &|_| None) {
2258 Ok(_) => panic!("directory unexpectedly loaded as config"),
2259 Err(error) => error,
2260 };
2261 assert!(
2262 error
2263 .to_string()
2264 .contains(&dir.path().display().to_string())
2265 );
2266 }
2267
2268 #[test]
2269 fn parse_env_valid_numeric_override() {
2270 let env = |name: &str| match name {
2271 "GRPC_PORT" => Some("60000".to_string()),
2272 _ => None,
2273 };
2274 let val: Option<u16> = parse_env(&env, "GRPC_PORT").unwrap();
2275 assert_eq!(val, Some(60000));
2276 }
2277
2278 #[test]
2279 fn parse_env_malformed_numeric_returns_invalid_environment() {
2280 let env = |name: &str| match name {
2281 "GRPC_PORT" => Some("not-a-number".to_string()),
2282 _ => None,
2283 };
2284 let err = parse_env::<u16>(&env, "GRPC_PORT").unwrap_err();
2285 match err {
2286 ConfigLoadError::InvalidEnvironment { name, value, .. } => {
2287 assert_eq!(name, "GRPC_PORT");
2288 assert_eq!(value, "not-a-number");
2289 }
2290 other => panic!("expected InvalidEnvironment, got: {other}"),
2291 }
2292 }
2293
2294 #[test]
2295 fn parse_env_missing_variable_returns_none() {
2296 let env = |_name: &str| -> Option<String> { None };
2297 let val: Option<u16> = parse_env(&env, "GRPC_PORT").unwrap();
2298 assert_eq!(val, None);
2299 }
2300
2301 #[test]
2302 fn parse_bool_env_accepted_true_spellings() {
2303 for input in &["true", "1", "yes", "on", "TRUE", "Yes", "ON"] {
2304 let env = |_: &str| Some(input.to_string());
2305 let val = parse_bool_env(&env, "FLAG").unwrap();
2306 assert_eq!(val, Some(true), "expected true for {input:?}");
2307 }
2308 }
2309
2310 #[test]
2311 fn parse_bool_env_accepted_false_spellings() {
2312 for input in &["false", "0", "no", "off", "FALSE", "No", "OFF"] {
2313 let env = |_: &str| Some(input.to_string());
2314 let val = parse_bool_env(&env, "FLAG").unwrap();
2315 assert_eq!(val, Some(false), "expected false for {input:?}");
2316 }
2317 }
2318
2319 #[test]
2320 fn parse_bool_env_unknown_value_fails() {
2321 let env = |_: &str| Some("maybe".to_string());
2322 let err = parse_bool_env(&env, "FLAG").unwrap_err();
2323 match err {
2324 ConfigLoadError::InvalidEnvironment { name, value, .. } => {
2325 assert_eq!(name, "FLAG");
2326 assert_eq!(value, "maybe");
2327 }
2328 other => panic!("expected InvalidEnvironment, got: {other}"),
2329 }
2330 }
2331
2332 #[test]
2333 fn parse_bool_env_missing_variable_returns_none() {
2334 let env = |_name: &str| -> Option<String> { None };
2335 let val = parse_bool_env(&env, "FLAG").unwrap();
2336 assert_eq!(val, None);
2337 }
2338
2339 #[test]
2340 fn config_validate_rejects_zero_grpc_port() {
2341 let dir = tempfile::tempdir().unwrap();
2342 let path = dir.path().join("config.toml");
2343 std::fs::write(&path, "[server]\ngrpc_port = 0\n").unwrap();
2344 let err = Config::load_from(&path, &|_| None).unwrap_err();
2345 match err {
2346 ConfigLoadError::InvalidRange { name, .. } => assert_eq!(name, "GRPC_PORT"),
2347 other => panic!("expected InvalidRange, got: {other}"),
2348 }
2349 }
2350
2351 #[test]
2352 fn config_validate_rejects_zero_db_max_connections() {
2353 let dir = tempfile::tempdir().unwrap();
2354 let path = dir.path().join("config.toml");
2355 std::fs::write(&path, "[server.database]\nmax_connections = 0\n").unwrap();
2356 let err = Config::load_from(&path, &|_| None).unwrap_err();
2357 match err {
2358 ConfigLoadError::InvalidRange { name, .. } => assert_eq!(name, "DB_MAX_CONNECTIONS"),
2359 other => panic!("expected InvalidRange, got: {other}"),
2360 }
2361 }
2362
2363 #[test]
2364 fn config_validate_rejects_zero_request_timeout() {
2365 let dir = tempfile::tempdir().unwrap();
2366 let path = dir.path().join("config.toml");
2367 std::fs::write(&path, "[server.limits]\nrequest_timeout_secs = 0\n").unwrap();
2368 let err = Config::load_from(&path, &|_| None).unwrap_err();
2369 match err {
2370 ConfigLoadError::InvalidRange { name, .. } => assert_eq!(name, "REQUEST_TIMEOUT_SECS"),
2371 other => panic!("expected InvalidRange, got: {other}"),
2372 }
2373 }
2374
2375 #[test]
2376 fn config_load_rejects_malformed_numeric_env() {
2377 let dir = tempfile::tempdir().unwrap();
2378 let path = dir.path().join("config.toml");
2379 std::fs::write(&path, "").unwrap();
2380 let env = |name: &str| match name {
2381 "GRPC_PORT" => Some("abc".to_string()),
2382 _ => None,
2383 };
2384 let err = Config::load_from(&path, &env).unwrap_err();
2385 match err {
2386 ConfigLoadError::InvalidEnvironment { name, .. } => assert_eq!(name, "GRPC_PORT"),
2387 other => panic!("expected InvalidEnvironment, got: {other}"),
2388 }
2389 }
2390
2391 #[test]
2392 fn config_validate_rejects_zero_max_id_length() {
2393 let dir = tempfile::tempdir().unwrap();
2394 let path = dir.path().join("config.toml");
2395 std::fs::write(&path, "[server.limits]\nmax_id_length = 0\n").unwrap();
2396 let err = Config::load_from(&path, &|_| None).unwrap_err();
2397 match err {
2398 ConfigLoadError::InvalidRange { name, .. } => assert_eq!(name, "MAX_ID_LENGTH"),
2399 other => panic!("expected InvalidRange, got: {other}"),
2400 }
2401 }
2402
2403 #[test]
2404 fn config_validate_rejects_zero_max_device_id_length() {
2405 let dir = tempfile::tempdir().unwrap();
2406 let path = dir.path().join("config.toml");
2407 std::fs::write(&path, "[server.limits]\nmax_device_id_length = 0\n").unwrap();
2408 let err = Config::load_from(&path, &|_| None).unwrap_err();
2409 match err {
2410 ConfigLoadError::InvalidRange { name, .. } => assert_eq!(name, "MAX_DEVICE_ID_LENGTH"),
2411 other => panic!("expected InvalidRange, got: {other}"),
2412 }
2413 }
2414
2415 #[test]
2416 fn config_validate_rejects_zero_max_api_key_length() {
2417 let dir = tempfile::tempdir().unwrap();
2418 let path = dir.path().join("config.toml");
2419 std::fs::write(&path, "[server.limits]\nmax_api_key_length = 0\n").unwrap();
2420 let err = Config::load_from(&path, &|_| None).unwrap_err();
2421 match err {
2422 ConfigLoadError::InvalidRange { name, .. } => assert_eq!(name, "MAX_API_KEY_LENGTH"),
2423 other => panic!("expected InvalidRange, got: {other}"),
2424 }
2425 }
2426
2427 #[test]
2428 fn config_validate_rejects_zero_rate_limit_per_minute() {
2429 let dir = tempfile::tempdir().unwrap();
2430 let path = dir.path().join("config.toml");
2431 std::fs::write(&path, "[server.rate_limit]\nrequests_per_minute = 0\n").unwrap();
2432 let err = Config::load_from(&path, &|_| None).unwrap_err();
2433 match err {
2434 ConfigLoadError::InvalidRange { name, .. } => {
2435 assert_eq!(name, "RATE_LIMIT_PER_MINUTE")
2436 }
2437 other => panic!("expected InvalidRange, got: {other}"),
2438 }
2439 }
2440
2441 #[test]
2442 fn config_validate_accepts_valid_boundary_values() {
2443 let dir = tempfile::tempdir().unwrap();
2444 let path = dir.path().join("config.toml");
2445 std::fs::write(
2446 &path,
2447 "[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",
2448 )
2449 .unwrap();
2450 let config = Config::load_from(&path, &|_| None).unwrap();
2451 assert_eq!(config.max_id_length, 1);
2452 assert_eq!(config.max_device_id_length, 1);
2453 assert_eq!(config.max_api_key_length, 1);
2454 assert_eq!(config.rate_limit_per_minute, 1);
2455 }
2456}