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