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