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 paths;
21pub mod premade;
22pub mod process;
23pub mod rate_limiter;
24pub mod server_lock;
25#[cfg(any(test, feature = "test-helpers"))]
26pub mod test_helpers;
27#[cfg(any(test, feature = "test-helpers"))]
28pub mod test_observer;
29
30pub use db::Database;
31pub use metrics::Metrics;
32pub use premade::PremadeManager;
33pub use rate_limiter::RateLimiter;
34
35use serde::Deserialize;
36use snip_proto::{
37 CreateLibraryRequest, CreateLibraryResponse, DeleteLibraryRequest, DeleteLibraryResponse,
38 GetPremadeLibraryRequest, GetPremadeLibraryResponse, GetSnippetsRequest, HealthRequest,
39 HealthResponse, Library, ListLibrariesRequest, ListLibrariesResponse,
40 ListPremadeLibrariesRequest, ListPremadeLibrariesResponse,
41 PremadeLibrary as ProtoPremadeLibrary, PushSnippetsRequest, PushSnippetsResponse,
42 RegisterRequest, RegisterResponse, SearchPremadeLibrariesRequest,
43 SearchPremadeLibrariesResponse, Snippet as ProtoSnippet, SnippetList, SyncRequest,
44 SyncResponse, snippet_sync_server::SnippetSync,
45};
46use std::net::SocketAddr;
47use std::path::PathBuf;
48use std::sync::Arc;
49use std::time::Duration;
50use tonic::{Request, Response, Status};
51
52pub fn extract_api_key<T>(request: &Request<T>, body_api_key: &str) -> String {
55 request
56 .metadata()
57 .get("authorization")
58 .and_then(|v| v.to_str().ok())
59 .and_then(|v| v.strip_prefix("Bearer "))
60 .filter(|v| !v.is_empty())
61 .unwrap_or(body_api_key)
62 .to_string()
63}
64
65fn strip_port(addr: &str) -> String {
66 if let Some(close_bracket) = addr.find("]:") {
67 return addr[1..close_bracket].to_string();
68 }
69 if !addr.starts_with('[') && addr.matches(':').count() > 1 {
72 return addr.to_string();
73 }
74 if let Some(colon_pos) = addr.rfind(':')
75 && !addr.starts_with('[')
76 {
77 return addr[..colon_pos].to_string();
78 }
79 addr.to_string()
80}
81
82pub const DEFAULT_MAX_COMMAND_LENGTH: usize = 1024;
83pub const DEFAULT_MAX_DESCRIPTION_LENGTH: usize = 1024;
84pub const DEFAULT_MAX_TAGS: usize = 50;
85pub const DEFAULT_MAX_TAG_LENGTH: usize = 100;
86pub const DEFAULT_MAX_ID_LENGTH: usize = 128;
87pub const DEFAULT_MAX_DEVICE_ID_LENGTH: usize = 128;
88pub const DEFAULT_MAX_API_KEY_LENGTH: usize = 512;
89pub const DEFAULT_MAX_SYNC_SNIPPETS: usize = 10000;
90pub const DEFAULT_REQUEST_TIMEOUT_SECS: u64 = 30;
91pub const DEFAULT_RATE_LIMIT_PER_MINUTE: u32 = 120;
92pub const DEFAULT_DB_MAX_CONNECTIONS: u32 = 5;
93pub const DEFAULT_GRPC_MAX_MESSAGE_SIZE: u32 = 4 * 1024 * 1024; pub const MAX_REQUEST_LIMIT: i32 = 1000;
95
96#[derive(Deserialize, Default)]
97pub struct ConfigFile {
98 pub server: Option<ServerConfig>,
99}
100
101#[derive(Deserialize, Default)]
102pub struct ServerConfig {
103 pub grpc_host: Option<String>,
104 pub grpc_port: Option<u16>,
105 pub http_host: Option<String>,
106 pub http_port: Option<u16>,
107 pub database: Option<DatabaseConfig>,
108 pub premade: Option<PremadeConfig>,
109 pub limits: Option<LimitsConfig>,
110 pub rate_limit: Option<RateLimitConfig>,
111 pub metrics: Option<MetricsConfig>,
112 pub cors: Option<CorsConfig>,
113}
114
115#[derive(Deserialize, Default)]
116pub struct DatabaseConfig {
117 pub path: Option<String>,
118 pub max_connections: Option<u32>,
119}
120
121#[derive(Deserialize, Default)]
122pub struct PremadeConfig {
123 pub directory: Option<String>,
124}
125
126#[derive(Deserialize, Default)]
127pub struct LimitsConfig {
128 pub max_command_length: Option<usize>,
129 pub max_description_length: Option<usize>,
130 pub max_tags: Option<usize>,
131 pub max_tag_length: Option<usize>,
132 pub max_id_length: Option<usize>,
133 pub max_device_id_length: Option<usize>,
134 pub max_api_key_length: Option<usize>,
135 pub request_timeout_secs: Option<u64>,
136 pub grpc_max_message_size: Option<u32>,
137}
138
139#[derive(Deserialize, Default)]
140pub struct RateLimitConfig {
141 pub requests_per_minute: Option<u32>,
142 pub trusted_proxies: Option<Vec<String>>,
143 pub persist: Option<bool>,
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)]
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 persist_rate_limits: bool,
178 pub metrics_username: Option<String>,
179 pub metrics_password: Option<String>,
180 pub cors_allowed_origins: Vec<String>,
181}
182
183#[derive(Debug, thiserror::Error)]
184pub enum ConfigLoadError {
185 #[error("failed to read configuration file {path}: {source}")]
186 Read {
187 path: PathBuf,
188 source: std::io::Error,
189 },
190 #[error("failed to parse configuration file {path}: {source}")]
191 Parse {
192 path: PathBuf,
193 source: toml::de::Error,
194 },
195}
196
197impl Config {
198 pub fn load() -> Result<Self, ConfigLoadError> {
199 let config_path = paths::config_path();
200 Self::load_from(&config_path, &|name| std::env::var(name).ok())
201 }
202
203 fn load_from(
204 config_path: &std::path::Path,
205 env: &impl Fn(&str) -> Option<String>,
206 ) -> Result<Self, ConfigLoadError> {
207 let config_file = match std::fs::read_to_string(config_path) {
208 Ok(content) => toml::from_str(&content).map_err(|source| ConfigLoadError::Parse {
209 path: config_path.to_path_buf(),
210 source,
211 })?,
212 Err(e) if e.kind() == std::io::ErrorKind::NotFound => ConfigFile::default(),
213 Err(source) => {
214 return Err(ConfigLoadError::Read {
215 path: config_path.to_path_buf(),
216 source,
217 });
218 }
219 };
220
221 let server = config_file.server.unwrap_or_default();
222
223 Ok(Self {
224 grpc_host: env("GRPC_HOST")
225 .or_else(|| server.grpc_host.clone())
226 .unwrap_or_else(|| "127.0.0.1".to_string()),
227 grpc_port: env("GRPC_PORT")
228 .and_then(|v| v.parse().ok())
229 .or(server.grpc_port)
230 .unwrap_or(50051),
231 http_host: env("HTTP_HOST")
232 .or_else(|| server.http_host.clone())
233 .unwrap_or_else(|| "127.0.0.1".to_string()),
234 http_port: env("HTTP_PORT")
235 .and_then(|v| v.parse().ok())
236 .or(server.http_port)
237 .unwrap_or(50050),
238 db_path: env("DATABASE_URL")
239 .or_else(|| server.database.as_ref().and_then(|d| d.path.clone()))
240 .unwrap_or_else(|| paths::default_db_path().to_string_lossy().into_owned()),
241 db_max_connections: env("DB_MAX_CONNECTIONS")
242 .and_then(|v| v.parse().ok())
243 .or(server.database.as_ref().and_then(|d| d.max_connections))
244 .unwrap_or(DEFAULT_DB_MAX_CONNECTIONS),
245 premade_dir: env("PREMADE_DIR")
246 .map(PathBuf::from)
247 .or_else(|| {
248 server
249 .premade
250 .as_ref()
251 .and_then(|p| p.directory.clone())
252 .map(PathBuf::from)
253 })
254 .unwrap_or_else(paths::default_premade_dir),
255 max_command_length: env("MAX_COMMAND_LENGTH")
256 .and_then(|v| v.parse().ok())
257 .or(server.limits.as_ref().and_then(|l| l.max_command_length))
258 .unwrap_or(DEFAULT_MAX_COMMAND_LENGTH),
259 max_description_length: env("MAX_DESCRIPTION_LENGTH")
260 .and_then(|v| v.parse().ok())
261 .or(server
262 .limits
263 .as_ref()
264 .and_then(|l| l.max_description_length))
265 .unwrap_or(DEFAULT_MAX_DESCRIPTION_LENGTH),
266 max_tags: env("MAX_TAGS")
267 .and_then(|v| v.parse().ok())
268 .or(server.limits.as_ref().and_then(|l| l.max_tags))
269 .unwrap_or(DEFAULT_MAX_TAGS),
270 max_tag_length: env("MAX_TAG_LENGTH")
271 .and_then(|v| v.parse().ok())
272 .or(server.limits.as_ref().and_then(|l| l.max_tag_length))
273 .unwrap_or(DEFAULT_MAX_TAG_LENGTH),
274 max_id_length: env("MAX_ID_LENGTH")
275 .and_then(|v| v.parse().ok())
276 .or(server.limits.as_ref().and_then(|l| l.max_id_length))
277 .unwrap_or(DEFAULT_MAX_ID_LENGTH),
278 max_device_id_length: env("MAX_DEVICE_ID_LENGTH")
279 .and_then(|v| v.parse().ok())
280 .or(server.limits.as_ref().and_then(|l| l.max_device_id_length))
281 .unwrap_or(DEFAULT_MAX_DEVICE_ID_LENGTH),
282 max_api_key_length: env("MAX_API_KEY_LENGTH")
283 .and_then(|v| v.parse().ok())
284 .or(server.limits.as_ref().and_then(|l| l.max_api_key_length))
285 .unwrap_or(DEFAULT_MAX_API_KEY_LENGTH),
286 request_timeout_secs: env("REQUEST_TIMEOUT_SECS")
287 .and_then(|v| v.parse().ok())
288 .or(server.limits.as_ref().and_then(|l| l.request_timeout_secs))
289 .unwrap_or(DEFAULT_REQUEST_TIMEOUT_SECS),
290 grpc_max_message_size: env("GRPC_MAX_MESSAGE_SIZE")
291 .and_then(|v| v.parse().ok())
292 .or(server.limits.as_ref().and_then(|l| l.grpc_max_message_size))
293 .unwrap_or(DEFAULT_GRPC_MAX_MESSAGE_SIZE),
294 rate_limit_per_minute: env("RATE_LIMIT_PER_MINUTE")
295 .and_then(|v| v.parse().ok())
296 .or(server
297 .rate_limit
298 .as_ref()
299 .and_then(|r| r.requests_per_minute))
300 .unwrap_or(DEFAULT_RATE_LIMIT_PER_MINUTE),
301 trusted_proxies: env("TRUSTED_PROXIES")
302 .map(|v| {
303 v.split(',')
304 .map(|s| s.trim().to_string())
305 .filter(|s| !s.is_empty() && s.parse::<std::net::IpAddr>().is_ok())
306 .collect()
307 })
308 .or_else(|| server.rate_limit.as_ref()?.trusted_proxies.clone())
309 .unwrap_or_default(),
310 persist_rate_limits: env("PERSIST_RATE_LIMITS")
311 .map(|v| v == "true" || v == "1")
312 .or(server.rate_limit.as_ref().and_then(|r| r.persist))
313 .unwrap_or(false),
314 metrics_username: env("METRICS_USERNAME")
315 .or_else(|| server.metrics.as_ref().and_then(|m| m.username.clone())),
316 metrics_password: env("METRICS_PASSWORD")
317 .or_else(|| server.metrics.as_ref().and_then(|m| m.password.clone())),
318 cors_allowed_origins: env("CORS_ALLOWED_ORIGINS")
319 .or_else(|| server.cors.as_ref().and_then(|c| c.allowed_origins.clone()))
320 .map(|v| {
321 v.split(',')
322 .map(str::trim)
323 .filter(|origin| !origin.is_empty())
324 .map(ToOwned::to_owned)
325 .collect()
326 })
327 .unwrap_or_default(),
328 })
329 }
330
331 pub fn ensure_config_file() {
332 if let Err(e) = bootstrap::ensure_config_file() {
333 tracing::warn!("{}", e);
334 }
335 }
336}
337
338#[derive(Clone)]
339pub struct AppState {
340 pub config: Config,
341 pub metrics: Metrics,
342 pub db: Arc<Database>,
343}
344
345pub struct SnipSyncService {
346 pub db: Arc<Database>,
347 pub rate_limiter: Arc<RateLimiter>,
348 pub config: Config,
349 pub metrics: Metrics,
350 pub premade_manager: PremadeManager,
351 #[cfg(any(test, feature = "test-helpers"))]
357 pub captured_auth_header: Arc<std::sync::Mutex<Option<String>>>,
358 #[cfg(any(test, feature = "test-helpers"))]
362 pub test_observer: Option<Arc<dyn crate::test_observer::TestRequestObserver>>,
363}
364
365impl SnipSyncService {
366 pub fn record_request(&self, method: &str) {
367 self.metrics
368 .requests_total
369 .with_label_values(&[method])
370 .inc();
371 tracing::trace!("Request: {}", method);
372 #[cfg(feature = "test-helpers")]
373 if let Some(ref obs) = self.test_observer {
374 use crate::test_observer::{RequestStarted, now_millis, operation_name_for_method};
375 let sequence = obs.allocate_sequence();
376 let concurrent = obs.current_concurrent();
377 obs.request_started(RequestStarted {
378 sequence,
379 started_at_unix_ms: now_millis(),
380 method: method.to_string(),
381 operation: operation_name_for_method(method).to_string(),
382 authenticated_user_id: None,
383 authenticated_device_id: None,
384 target_library_id: None,
385 request_revision: None,
386 payload_len: 0,
387 payload_sha256: String::new(),
388 payload_contains_plaintext_sentinel: false,
389 concurrent_at_start: concurrent,
390 });
391 }
392 }
393
394 #[cfg_attr(not(feature = "test-helpers"), allow(unused_variables))]
395 pub fn record_request_finished(&self, method: &str, success: bool) {
396 #[cfg(feature = "test-helpers")]
397 if let Some(ref obs) = self.test_observer {
398 use crate::test_observer::RequestFinished;
399 let sequence = obs.last_started_sequence_for_method(method);
400 obs.request_finished(RequestFinished {
401 sequence,
402 finished_at_unix_ms: crate::test_observer::now_millis(),
403 success,
404 response_revision: None,
405 });
406 }
407 }
408
409 #[cfg_attr(not(feature = "test-helpers"), allow(unused_variables))]
414 pub fn update_request_ids(
415 &self,
416 method: &str,
417 user_id: Option<String>,
418 device_id: Option<String>,
419 library_id: Option<String>,
420 ) {
421 #[cfg(feature = "test-helpers")]
422 if let Some(ref obs) = self.test_observer {
423 obs.update_ids_for_last_method(method, user_id, device_id, library_id);
424 }
425 }
426
427 pub fn record_request_duration(&self, method: &str, start: std::time::Instant) {
428 let duration = start.elapsed().as_secs_f64();
429 self.metrics
430 .request_duration_seconds
431 .with_label_values(&[method])
432 .observe(duration);
433 tracing::debug!("Request {} completed in {:.3}s", method, duration);
434 }
435
436 pub fn record_rate_limit(&self) {
437 self.metrics.rate_limit_hits.inc();
438 }
439
440 pub fn record_auth_failure(&self) {
441 self.metrics.auth_failures.inc();
442 }
443
444 pub fn record_sync(&self, direction: &str) {
445 self.metrics
446 .sync_operations_total
447 .with_label_values(&[direction])
448 .inc();
449 }
450
451 pub fn record_library_op(&self, operation: &str) {
452 self.metrics
453 .library_operations_total
454 .with_label_values(&[operation])
455 .inc();
456 }
457
458 fn request_api_key<T>(&self, request: &Request<T>, body_api_key: &str) -> String {
459 let api_key = extract_api_key(request, body_api_key);
460 #[cfg(any(test, feature = "test-helpers"))]
461 self.capture_test_auth_header(&api_key);
462 api_key
463 }
464
465 #[cfg(any(test, feature = "test-helpers"))]
466 fn capture_test_auth_header(&self, api_key: &str) {
467 if !api_key.is_empty() {
468 let mut slot = self
469 .captured_auth_header
470 .lock()
471 .unwrap_or_else(|e| e.into_inner());
472 if slot.is_none() {
473 *slot = Some(format!("Bearer {api_key}"));
474 }
475 }
476 }
477
478 pub async fn authenticate_and_rate_limit(&self, api_key: &str) -> Result<String, Status> {
479 self.authenticate_and_rate_limit_with_duration(api_key, None)
480 .await
481 }
482
483 pub async fn authenticate_and_rate_limit_with_duration(
486 &self,
487 api_key: &str,
488 start: Option<std::time::Instant>,
489 ) -> Result<String, Status> {
490 if api_key.is_empty() {
491 if let Some(s) = start {
492 self.record_request_duration("auth", s);
493 }
494 return Err(Status::unauthenticated("API key is required"));
495 }
496 if api_key.len() > self.config.max_api_key_length {
497 if let Some(s) = start {
498 self.record_request_duration("auth", s);
499 }
500 return Err(Status::invalid_argument(format!(
501 "API key exceeds maximum length of {} bytes",
502 self.config.max_api_key_length
503 )));
504 }
505
506 if !self
507 .rate_limiter
508 .allow(
509 api_key,
510 self.config.rate_limit_per_minute as usize,
511 Duration::from_secs(60),
512 )
513 .await
514 {
515 self.record_rate_limit();
516 if let Some(s) = start {
517 self.record_request_duration("auth", s);
518 }
519 return Err(Status::resource_exhausted("Rate limit exceeded"));
520 }
521
522 let user_id = self
523 .db
524 .get_user_by_api_key(api_key)
525 .await
526 .map_err(|_| {
527 if let Some(s) = start {
528 self.record_request_duration("auth", s);
529 }
530 Status::internal("Internal error")
531 })?
532 .ok_or_else(|| {
533 self.record_auth_failure();
534 if let Some(s) = start {
535 self.record_request_duration("auth", s);
536 }
537 Status::unauthenticated("Invalid API key")
538 })?;
539
540 Ok(user_id)
541 }
542
543 pub fn validate_snippet(&self, snippet: &ProtoSnippet) -> Result<(), Status> {
544 if snippet.id.is_empty() {
545 return Err(Status::invalid_argument("Snippet ID is required"));
546 }
547 if snippet.id.len() > self.config.max_id_length {
548 return Err(Status::invalid_argument(format!(
549 "Snippet ID exceeds maximum length of {} bytes",
550 self.config.max_id_length
551 )));
552 }
553
554 if snippet.device_id.is_empty() {
555 return Err(Status::invalid_argument("Device ID is required"));
556 }
557 if snippet.device_id.len() > self.config.max_device_id_length {
558 return Err(Status::invalid_argument(format!(
559 "Device ID exceeds maximum length of {} bytes",
560 self.config.max_device_id_length
561 )));
562 }
563
564 if !snippet.encrypted && snippet.command.len() > self.config.max_command_length {
565 return Err(Status::invalid_argument(format!(
566 "Command exceeds maximum length of {} bytes",
567 self.config.max_command_length
568 )));
569 }
570
571 if !snippet.encrypted && snippet.command.trim().is_empty() {
572 return Err(Status::invalid_argument("Snippet command is required"));
573 }
574
575 if snippet.encrypted && (snippet.command.is_empty() || snippet.command.trim().is_empty()) {
576 return Err(Status::invalid_argument(
577 "Encrypted snippet payload is required",
578 ));
579 }
580
581 if snippet.description.len() > self.config.max_description_length {
582 return Err(Status::invalid_argument(format!(
583 "Description exceeds maximum length of {} bytes",
584 self.config.max_description_length
585 )));
586 }
587
588 if snippet.tags.len() > self.config.max_tags {
589 return Err(Status::invalid_argument(format!(
590 "Too many tags (max {})",
591 self.config.max_tags
592 )));
593 }
594
595 for tag in &snippet.tags {
596 if tag.len() > self.config.max_tag_length {
597 return Err(Status::invalid_argument(format!(
598 "Tag '{}' exceeds maximum length of {} bytes",
599 tag, self.config.max_tag_length
600 )));
601 }
602 }
603
604 let now = chrono::Utc::now().timestamp();
605 if snippet.updated_at > now + 300 {
606 return Err(Status::invalid_argument(
607 "Updated timestamp is more than 5 minutes in the future",
608 ));
609 }
610 if snippet.created_at > now + 300 {
611 return Err(Status::invalid_argument(
612 "Created timestamp is more than 5 minutes in the future",
613 ));
614 }
615 if snippet.created_at < 0 || snippet.updated_at < 0 {
616 return Err(Status::invalid_argument("Timestamps must be non-negative"));
617 }
618 if snippet.created_at > snippet.updated_at {
619 return Err(Status::invalid_argument(
620 "created_at must not be greater than updated_at",
621 ));
622 }
623
624 Ok(())
625 }
626}
627
628#[tonic::async_trait]
629impl SnippetSync for SnipSyncService {
630 async fn health(
631 &self,
632 _request: Request<HealthRequest>,
633 ) -> Result<Response<HealthResponse>, Status> {
634 let request_id = uuid::Uuid::new_v4();
635 let start = std::time::Instant::now();
636 self.record_request("health");
637 tracing::debug!(request_id = %request_id, "Health check");
638 let healthy = self.db.ping().await.is_ok();
639 self.record_request_duration("health", start);
640 self.record_request_finished("health", healthy);
641 Ok(Response::new(HealthResponse {
642 healthy,
643 version: env!("CARGO_PKG_VERSION").to_string(),
644 }))
645 }
646
647 async fn register(
648 &self,
649 request: Request<RegisterRequest>,
650 ) -> Result<Response<RegisterResponse>, Status> {
651 let request_id = uuid::Uuid::new_v4();
652 let start = std::time::Instant::now();
653 self.record_request("register");
654 tracing::info!(request_id = %request_id, "Register request");
655
656 let peer_ip = request
659 .extensions()
660 .get::<SocketAddr>()
661 .map(|addr| addr.ip().to_string());
662
663 let rate_limit_key = if let Some(ref ip) = peer_ip
664 && self.config.trusted_proxies.contains(ip)
665 {
666 request
667 .metadata()
668 .get("x-forwarded-for")
669 .and_then(|v| v.to_str().ok())
670 .and_then(|header| header.split(',').next())
671 .map(|s| strip_port(s.trim()))
672 .unwrap_or_else(|| ip.clone())
673 } else {
674 peer_ip.unwrap_or_else(|| "unknown".to_string())
675 };
676
677 if !self
678 .rate_limiter
679 .allow(
680 &rate_limit_key,
681 self.config.rate_limit_per_minute as usize,
682 Duration::from_secs(60),
683 )
684 .await
685 {
686 self.record_rate_limit();
687 self.record_request_duration("register", start);
688 self.record_request_finished("register", false);
689 return Err(Status::resource_exhausted(
690 "Rate limit exceeded for registration",
691 ));
692 }
693
694 let _req = request.into_inner();
695
696 let api_key = uuid::Uuid::new_v4().to_string();
697
698 match self.db.create_user(&api_key).await {
699 Ok(device_id) => {
700 if uuid::Uuid::parse_str(&device_id).is_err() {
701 tracing::error!(
702 request_id = %request_id,
703 "Generated device_id is not a valid UUID: {}",
704 device_id
705 );
706 self.record_request_duration("register", start);
707 self.record_request_finished("register", false);
708 return Err(Status::internal(
709 "Internal error: invalid device ID generated",
710 ));
711 }
712 tracing::info!(
713 request_id = %request_id,
714 device_id = %device_id,
715 "Created new user"
716 );
717 self.record_request_duration("register", start);
718 self.record_request_finished("register", true);
719 Ok(Response::new(RegisterResponse {
720 success: true,
721 api_key,
722 message: "Account created successfully".to_string(),
723 device_id,
724 }))
725 }
726 Err(e) => {
727 tracing::error!(request_id = %request_id, "Failed to create user: {}", e);
728 self.record_request_duration("register", start);
729 self.record_request_finished("register", false);
730 Err(Status::internal("Internal error"))
731 }
732 }
733 }
734
735 async fn get_snippets(
736 &self,
737 request: Request<GetSnippetsRequest>,
738 ) -> Result<Response<SnippetList>, Status> {
739 let request_id = uuid::Uuid::new_v4();
740 let start = std::time::Instant::now();
741 self.record_request("get_snippets");
742 tracing::info!(request_id = %request_id, "GetSnippets request");
743 let api_key = self.request_api_key(&request, &request.get_ref().api_key);
744 let req = request.into_inner();
745
746 let user_id = self
747 .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
748 .await
749 .inspect_err(|_| {
750 self.record_request_finished("get_snippets", false);
751 })?;
752
753 let library_id = if req.library_id.is_empty() {
754 self.db.get_default_library(&user_id).await.map_err(|e| {
755 self.record_request_duration("get_snippets", start);
756 self.record_request_finished("get_snippets", false);
757 tracing::error!("Internal error: {}", e);
758 Status::internal("Internal error")
759 })?
760 } else {
761 if !self
762 .db
763 .verify_library_ownership(&user_id, &req.library_id)
764 .await
765 .map_err(|e| {
766 self.record_request_duration("get_snippets", start);
767 self.record_request_finished("get_snippets", false);
768 tracing::error!("Internal error: {}", e);
769 Status::internal("Internal error")
770 })?
771 {
772 tracing::warn!(
773 "User {} attempted to access library {} without ownership",
774 user_id,
775 req.library_id
776 );
777 self.record_request_duration("get_snippets", start);
778 self.record_request_finished("get_snippets", false);
779 return Err(Status::not_found("Library not found"));
780 }
781 req.library_id
782 };
783
784 self.update_request_ids(
786 "get_snippets",
787 Some(user_id.clone()),
788 None,
789 Some(library_id.clone()),
790 );
791
792 let limit = if req.limit > 0 {
793 req.limit.clamp(1, MAX_REQUEST_LIMIT)
794 } else {
795 100
796 };
797 let offset = if req.offset > 0 { req.offset } else { 0 };
798
799 let (snippets, total) = self
800 .db
801 .get_snippets(&user_id, &library_id, req.since, limit, offset, false)
802 .await
803 .map_err(|e| {
804 self.record_request_duration("get_snippets", start);
805 self.record_request_finished("get_snippets", false);
806 tracing::error!("Internal error: {}", e);
807 Status::internal("Internal error")
808 })?;
809
810 let has_more = offset.saturating_add(snippets.len() as i32) < total;
811
812 let proto_snippets: Vec<ProtoSnippet> = snippets
813 .into_iter()
814 .map(|s| ProtoSnippet {
815 id: s.id,
816 description: s.description,
817 command: s.command,
818 tags: s.tags,
819 created_at: s.created_at,
820 updated_at: s.updated_at,
821 device_id: s.device_id,
822 deleted: s.deleted,
823 encrypted: s.encrypted,
824 })
825 .collect();
826
827 self.record_request_duration("get_snippets", start);
828
829 let result = Ok(Response::new(SnippetList {
830 snippets: proto_snippets,
831 total_count: total,
832 has_more,
833 }));
834 self.record_request_finished("get_snippets", result.is_ok());
835 result
836 }
837
838 async fn push_snippets(
839 &self,
840 request: Request<PushSnippetsRequest>,
841 ) -> Result<Response<PushSnippetsResponse>, Status> {
842 let request_id = uuid::Uuid::new_v4();
843 let start = std::time::Instant::now();
844 self.record_request("push_snippets");
845 tracing::info!(request_id = %request_id, "PushSnippets request");
846 let api_key = self.request_api_key(&request, &request.get_ref().api_key);
847 let req = request.into_inner();
848
849 let user_id = self
850 .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
851 .await
852 .inspect_err(|_| {
853 self.record_request_finished("push_snippets", false);
854 })?;
855
856 let library_id = if req.library_id.is_empty() {
857 self.db.get_default_library(&user_id).await.map_err(|e| {
858 self.record_request_duration("push_snippets", start);
859 self.record_request_finished("push_snippets", false);
860 tracing::error!("Internal error: {}", e);
861 Status::internal("Internal error")
862 })?
863 } else {
864 if !self
865 .db
866 .verify_library_ownership(&user_id, &req.library_id)
867 .await
868 .map_err(|e| {
869 self.record_request_duration("push_snippets", start);
870 self.record_request_finished("push_snippets", false);
871 tracing::error!("Internal error: {}", e);
872 Status::internal("Internal error")
873 })?
874 {
875 tracing::warn!(
876 "User {} attempted to push to library {} without ownership",
877 user_id,
878 req.library_id
879 );
880 self.record_request_duration("push_snippets", start);
881 self.record_request_finished("push_snippets", false);
882 return Err(Status::not_found("Library not found"));
883 }
884 req.library_id
885 };
886
887 self.update_request_ids(
889 "push_snippets",
890 Some(user_id.clone()),
891 req.snippets.first().map(|s| s.device_id.clone()),
892 Some(library_id.clone()),
893 );
894
895 if req.snippets.len() > DEFAULT_MAX_SYNC_SNIPPETS {
896 self.record_request_duration("push_snippets", start);
897 self.record_request_finished("push_snippets", false);
898 return Err(Status::invalid_argument(format!(
899 "Too many snippets in push request (max {}), got {}",
900 DEFAULT_MAX_SYNC_SNIPPETS,
901 req.snippets.len()
902 )));
903 }
904
905 let mut accepted = 0;
906 let mut rejected = 0;
907
908 let mut tx = self.db.pool().begin().await.map_err(|e| {
909 self.record_request_duration("push_snippets", start);
910 self.record_request_finished("push_snippets", false);
911 tracing::error!(request_id = %request_id, "Failed to begin transaction: {}", e);
912 Status::internal("Internal error")
913 })?;
914
915 for snippet in req.snippets {
916 if let Err(e) = self.validate_snippet(&snippet) {
917 rejected += 1;
918 tracing::warn!(request_id = %request_id, snippet_id = %snippet.id, reason = %e, "Snippet validation failed");
919 continue;
920 }
921
922 let db_snippet = db::Snippet {
923 id: snippet.id.clone(),
924 description: snippet.description,
925 command: snippet.command,
926 tags: snippet.tags,
927 created_at: snippet.created_at,
928 updated_at: snippet.updated_at,
929 device_id: snippet.device_id,
930 deleted: snippet.deleted,
931 encrypted: snippet.encrypted,
932 };
933
934 match self
935 .db
936 .upsert_snippet_in_tx(&mut tx, &db_snippet, &user_id, &library_id)
937 .await
938 {
939 Ok(_) => accepted += 1,
940 Err(e) => {
941 tracing::warn!(
942 request_id = %request_id,
943 snippet_id = %snippet.id,
944 reason = %e,
945 "Snippet upsert failed"
946 );
947 rejected += 1;
948 }
949 }
950 }
951
952 tx.commit().await.map_err(|e| {
953 self.record_request_duration("push_snippets", start);
954 self.record_request_finished("push_snippets", false);
955 tracing::error!(request_id = %request_id, "Failed to commit transaction: {}", e);
956 Status::internal("Internal error")
957 })?;
958
959 self.record_request_duration("push_snippets", start);
960
961 let result = Ok(Response::new(PushSnippetsResponse {
962 success: rejected == 0,
963 message: format!("Accepted {}, rejected {}", accepted, rejected),
964 accepted_count: accepted,
965 rejected_count: rejected,
966 }));
967 self.record_request_finished("push_snippets", result.is_ok());
968 result
969 }
970
971 async fn sync(&self, request: Request<SyncRequest>) -> Result<Response<SyncResponse>, Status> {
972 let request_id = uuid::Uuid::new_v4();
973 let start = std::time::Instant::now();
974 self.record_request("sync");
975 tracing::info!(request_id = %request_id, "Sync request");
976 let api_key = self.request_api_key(&request, &request.get_ref().api_key);
977 let req = request.into_inner();
978
979 let user_id = self
980 .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
981 .await
982 .inspect_err(|_| {
983 self.record_request_finished("sync", false);
984 })?;
985
986 if req.local_snippets.len() > DEFAULT_MAX_SYNC_SNIPPETS {
987 self.record_request_duration("sync", start);
988 self.record_request_finished("sync", false);
989 return Err(Status::invalid_argument(format!(
990 "Too many snippets in sync request (max {}), got {}",
991 DEFAULT_MAX_SYNC_SNIPPETS,
992 req.local_snippets.len()
993 )));
994 }
995
996 self.record_sync("bidirectional");
997
998 let library_id = if req.library_id.is_empty() {
999 self.db.get_default_library(&user_id).await.map_err(|e| {
1000 self.record_request_duration("sync", start);
1001 self.record_request_finished("sync", false);
1002 tracing::error!("Internal error: {}", e);
1003 Status::internal("Internal error")
1004 })?
1005 } else {
1006 if !self
1007 .db
1008 .verify_library_ownership(&user_id, &req.library_id)
1009 .await
1010 .map_err(|e| {
1011 self.record_request_duration("sync", start);
1012 self.record_request_finished("sync", false);
1013 tracing::error!("Internal error: {}", e);
1014 Status::internal("Internal error")
1015 })?
1016 {
1017 tracing::warn!(
1018 "User {} attempted to sync with library {} without ownership",
1019 user_id,
1020 req.library_id
1021 );
1022 self.record_request_duration("sync", start);
1023 self.record_request_finished("sync", false);
1024 return Err(Status::not_found("Library not found"));
1025 }
1026 req.library_id
1027 };
1028
1029 self.update_request_ids(
1031 "sync",
1032 Some(user_id.clone()),
1033 req.local_snippets.first().map(|s| s.device_id.clone()),
1034 Some(library_id.clone()),
1035 );
1036
1037 let mut skipped_ids = Vec::new();
1038
1039 let mut tx = self.db.pool().begin().await.map_err(|e| {
1040 self.record_request_duration("sync", start);
1041 self.record_request_finished("sync", false);
1042 tracing::error!(request_id = %request_id, "Failed to begin transaction: {}", e);
1043 Status::internal("Internal error")
1044 })?;
1045
1046 for snippet in &req.local_snippets {
1047 if let Err(e) = self.validate_snippet(snippet) {
1048 tracing::warn!(
1049 request_id = %request_id,
1050 snippet_id = %snippet.id,
1051 reason = %e,
1052 "Snippet skipped: validation failed"
1053 );
1054 skipped_ids.push(snippet.id.clone());
1055 continue;
1056 }
1057
1058 if snippet.updated_at <= req.last_sync_timestamp {
1059 continue;
1060 }
1061
1062 let db_snippet = db::Snippet {
1063 id: snippet.id.clone(),
1064 description: snippet.description.clone(),
1065 command: snippet.command.clone(),
1066 tags: snippet.tags.clone(),
1067 created_at: snippet.created_at,
1068 updated_at: snippet.updated_at,
1069 device_id: snippet.device_id.clone(),
1070 deleted: snippet.deleted,
1071 encrypted: snippet.encrypted,
1072 };
1073
1074 if let Err(e) = self
1075 .db
1076 .upsert_snippet_in_tx(&mut tx, &db_snippet, &user_id, &library_id)
1077 .await
1078 {
1079 tracing::warn!(
1080 request_id = %request_id,
1081 snippet_id = %snippet.id,
1082 reason = %e,
1083 "Snippet skipped: upsert failed"
1084 );
1085 skipped_ids.push(snippet.id.clone());
1086 }
1087 }
1088
1089 tx.commit().await.map_err(|e| {
1090 self.record_request_duration("sync", start);
1091 self.record_request_finished("sync", false);
1092 tracing::error!(request_id = %request_id, "Failed to commit transaction: {}", e);
1093 Status::internal("Internal error")
1094 })?;
1095
1096 let limit = if req.limit > 0 {
1097 req.limit.clamp(1, MAX_REQUEST_LIMIT)
1098 } else {
1099 1000
1100 };
1101
1102 let offset = if req.offset > 0 { req.offset } else { 0 };
1103
1104 let (snippets, total) = self
1105 .db
1106 .get_snippets(
1107 &user_id,
1108 &library_id,
1109 req.last_sync_timestamp,
1110 limit,
1111 offset,
1112 true,
1113 )
1114 .await
1115 .map_err(|e| {
1116 self.record_request_duration("sync", start);
1117 self.record_request_finished("sync", false);
1118 tracing::error!("Internal error: {}", e);
1119 Status::internal("Internal error")
1120 })?;
1121
1122 let has_more = offset.saturating_add(snippets.len() as i32) < total;
1123
1124 let timestamp = if has_more {
1125 req.last_sync_timestamp
1127 } else {
1128 self.db
1129 .get_latest_timestamp(&user_id, &library_id)
1130 .await
1131 .map_err(|e| {
1132 self.record_request_duration("sync", start);
1133 self.record_request_finished("sync", false);
1134 tracing::error!("Internal error: {}", e);
1135 Status::internal("Internal error")
1136 })?
1137 };
1138
1139 let proto_snippets: Vec<ProtoSnippet> = snippets
1140 .into_iter()
1141 .map(|s| ProtoSnippet {
1142 id: s.id,
1143 description: s.description,
1144 command: s.command,
1145 tags: s.tags,
1146 created_at: s.created_at,
1147 updated_at: s.updated_at,
1148 device_id: s.device_id,
1149 deleted: s.deleted,
1150 encrypted: s.encrypted,
1151 })
1152 .collect();
1153
1154 let skipped_count = skipped_ids.len() as i32;
1155
1156 tracing::info!(
1157 request_id = %request_id,
1158 snippets_synced = proto_snippets.len(),
1159 skipped_count = skipped_count,
1160 has_more = has_more,
1161 "Sync completed"
1162 );
1163
1164 self.record_request_duration("sync", start);
1165
1166 let result = Ok(Response::new(SyncResponse {
1167 success: true,
1168 message: if skipped_count > 0 {
1169 format!("Sync completed, {} snippets skipped", skipped_count)
1170 } else {
1171 "Sync completed".to_string()
1172 },
1173 snippets: proto_snippets,
1174 server_timestamp: timestamp,
1175 skipped_count,
1176 skipped_ids,
1177 has_more,
1178 total_count: total,
1179 }));
1180 self.record_request_finished("sync", result.is_ok());
1181 result
1182 }
1183
1184 async fn create_library(
1185 &self,
1186 request: Request<CreateLibraryRequest>,
1187 ) -> Result<Response<CreateLibraryResponse>, Status> {
1188 let request_id = uuid::Uuid::new_v4();
1189 let start = std::time::Instant::now();
1190 self.record_request("create_library");
1191 self.record_library_op("create");
1192 tracing::info!(request_id = %request_id, "CreateLibrary request");
1193 let api_key = self.request_api_key(&request, &request.get_ref().api_key);
1194 let req = request.into_inner();
1195
1196 let user_id = self
1197 .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
1198 .await
1199 .inspect_err(|_| {
1200 self.record_request_finished("create_library", false);
1201 })?;
1202
1203 let result = match self.db.create_library(&user_id, &req.name).await {
1204 Ok(lib_id) => {
1205 tracing::info!("Created library '{}' for user {}", req.name, user_id);
1206 self.record_request_duration("create_library", start);
1207 Ok(Response::new(CreateLibraryResponse {
1208 success: true,
1209 library_id: lib_id,
1210 message: format!("Library '{}' created successfully", req.name),
1211 }))
1212 }
1213 Err(db::DbError::Conflict(msg)) => {
1214 self.record_request_duration("create_library", start);
1215 Err(Status::already_exists(msg))
1216 }
1217 Err(db::DbError::Validation(msg)) => {
1218 self.record_request_duration("create_library", start);
1219 Err(Status::invalid_argument(msg))
1220 }
1221 Err(db::DbError::NotFound(msg)) => {
1222 self.record_request_duration("create_library", start);
1223 Err(Status::invalid_argument(msg))
1224 }
1225 Err(db::DbError::Internal(msg)) => {
1226 tracing::error!("Internal error creating library: {}", msg);
1227 self.record_request_duration("create_library", start);
1228 Err(Status::internal("Internal error"))
1229 }
1230 Err(db::DbError::Database(e)) => {
1231 tracing::error!("Database error creating library: {}", e);
1232 self.record_request_duration("create_library", start);
1233 Err(Status::internal("Internal error"))
1234 }
1235 };
1236 self.record_request_finished("create_library", result.is_ok());
1237 result
1238 }
1239
1240 async fn list_libraries(
1241 &self,
1242 request: Request<ListLibrariesRequest>,
1243 ) -> Result<Response<ListLibrariesResponse>, Status> {
1244 let request_id = uuid::Uuid::new_v4();
1245 let start = std::time::Instant::now();
1246 self.record_request("list_libraries");
1247 self.record_library_op("list");
1248 tracing::info!(request_id = %request_id, "ListLibraries request");
1249 let api_key = self.request_api_key(&request, &request.get_ref().api_key);
1250 let req = request.into_inner();
1251
1252 let user_id = self
1253 .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
1254 .await
1255 .inspect_err(|_| {
1256 self.record_request_finished("list_libraries", false);
1257 })?;
1258
1259 let limit = if req.limit > 0 {
1260 req.limit.clamp(1, MAX_REQUEST_LIMIT)
1261 } else {
1262 50
1263 };
1264 let offset = if req.offset > 0 { req.offset } else { 0 };
1265
1266 let (libraries, total) = self
1267 .db
1268 .list_libraries(&user_id, limit, offset)
1269 .await
1270 .map_err(|e| {
1271 self.record_request_duration("list_libraries", start);
1272 self.record_request_finished("list_libraries", false);
1273 tracing::error!("Internal error: {}", e);
1274 Status::internal("Internal error")
1275 })?;
1276
1277 let has_more = offset.saturating_add(libraries.len() as i32) < total;
1278
1279 let proto_libraries: Vec<Library> = libraries
1280 .into_iter()
1281 .map(|l| Library {
1282 id: l.id,
1283 name: l.name,
1284 created_at: l.created_at,
1285 snippet_count: l.snippet_count,
1286 })
1287 .collect();
1288
1289 self.record_request_duration("list_libraries", start);
1290
1291 let result = Ok(Response::new(ListLibrariesResponse {
1292 libraries: proto_libraries,
1293 total_count: total,
1294 has_more,
1295 }));
1296 self.record_request_finished("list_libraries", result.is_ok());
1297 result
1298 }
1299
1300 async fn delete_library(
1301 &self,
1302 request: Request<DeleteLibraryRequest>,
1303 ) -> Result<Response<DeleteLibraryResponse>, Status> {
1304 let request_id = uuid::Uuid::new_v4();
1305 let start = std::time::Instant::now();
1306 self.record_request("delete_library");
1307 self.record_library_op("delete");
1308 tracing::info!(request_id = %request_id, "DeleteLibrary request");
1309 let api_key = self.request_api_key(&request, &request.get_ref().api_key);
1310 let req = request.into_inner();
1311
1312 let user_id = self
1313 .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
1314 .await
1315 .inspect_err(|_| {
1316 self.record_request_finished("delete_library", false);
1317 })?;
1318
1319 if req.library_id.is_empty() || req.library_id == "default" {
1322 self.record_request_duration("delete_library", start);
1323 self.record_request_finished("delete_library", false);
1324 return Err(Status::invalid_argument("Cannot delete default library"));
1325 }
1326 if let Ok(default_id) = self.db.get_default_library(&user_id).await
1327 && req.library_id == default_id
1328 {
1329 self.record_request_duration("delete_library", start);
1330 self.record_request_finished("delete_library", false);
1331 return Err(Status::invalid_argument("Cannot delete default library"));
1332 }
1333
1334 let result = match self.db.delete_library(&user_id, &req.library_id).await {
1335 Ok(_) => {
1336 tracing::info!("Deleted library {} for user {}", req.library_id, user_id);
1337 Ok(Response::new(DeleteLibraryResponse {
1338 success: true,
1339 message: "Library deleted successfully".to_string(),
1340 }))
1341 }
1342 Err(db::DbError::NotFound(msg)) => Err(Status::not_found(msg)),
1343 Err(db::DbError::Conflict(msg)) => Err(Status::failed_precondition(msg)),
1344 Err(db::DbError::Validation(msg)) => Err(Status::invalid_argument(msg)),
1345 Err(db::DbError::Internal(msg)) => {
1346 tracing::error!("Internal error deleting library: {}", msg);
1347 Err(Status::internal("Internal error"))
1348 }
1349 Err(db::DbError::Database(e)) => {
1350 tracing::error!("Failed to delete library: {}", e);
1351 Err(Status::internal("Internal error"))
1352 }
1353 };
1354 self.record_request_duration("delete_library", start);
1355 self.record_request_finished("delete_library", result.is_ok());
1356 result
1357 }
1358
1359 async fn list_premade_libraries(
1360 &self,
1361 request: Request<ListPremadeLibrariesRequest>,
1362 ) -> Result<Response<ListPremadeLibrariesResponse>, Status> {
1363 let request_id = uuid::Uuid::new_v4();
1364 let start = std::time::Instant::now();
1365 self.record_request("list_premade_libraries");
1366 tracing::info!(request_id = %request_id, "ListPremadeLibraries request");
1367 let api_key = self.request_api_key(&request, &request.get_ref().api_key);
1368 let _req = request.into_inner();
1369
1370 let user_id = self
1371 .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
1372 .await
1373 .inspect_err(|_| {
1374 self.record_request_finished("list_premade_libraries", false);
1375 })?;
1376
1377 let libraries = self.premade_manager.list();
1378
1379 let proto_libraries: Vec<ProtoPremadeLibrary> = libraries
1380 .into_iter()
1381 .map(|l| ProtoPremadeLibrary {
1382 name: l.name,
1383 filename: l.filename,
1384 description: l.description,
1385 snippet_count: l.snippet_count,
1386 tags: l.tags,
1387 })
1388 .collect();
1389
1390 tracing::info!(
1391 request_id = %request_id,
1392 user_id = %user_id,
1393 count = proto_libraries.len(),
1394 "ListPremadeLibraries completed"
1395 );
1396
1397 let count = proto_libraries.len() as i32;
1398
1399 self.record_request_duration("list_premade_libraries", start);
1400
1401 let result = Ok(Response::new(ListPremadeLibrariesResponse {
1402 libraries: proto_libraries,
1403 has_more: false,
1404 total_count: count,
1405 }));
1406 self.record_request_finished("list_premade_libraries", result.is_ok());
1407 result
1408 }
1409
1410 async fn get_premade_library(
1411 &self,
1412 request: Request<GetPremadeLibraryRequest>,
1413 ) -> Result<Response<GetPremadeLibraryResponse>, Status> {
1414 let request_id = uuid::Uuid::new_v4();
1415 let start = std::time::Instant::now();
1416 self.record_request("get_premade_library");
1417 tracing::info!(request_id = %request_id, "GetPremadeLibrary request");
1418 let api_key = self.request_api_key(&request, &request.get_ref().api_key);
1419 let req = request.into_inner();
1420
1421 let user_id = self
1422 .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
1423 .await
1424 .inspect_err(|_| {
1425 self.record_request_finished("get_premade_library", false);
1426 })?;
1427
1428 if req.filename.is_empty() {
1429 self.record_request_duration("get_premade_library", start);
1430 self.record_request_finished("get_premade_library", false);
1431 return Err(Status::invalid_argument("Filename is required"));
1432 }
1433
1434 if req.filename.contains("..") || req.filename.contains('/') || req.filename.contains('\\')
1435 {
1436 self.record_request_duration("get_premade_library", start);
1437 self.record_request_finished("get_premade_library", false);
1438 return Err(Status::invalid_argument("Invalid filename"));
1439 }
1440
1441 let sanitized: String = req
1442 .filename
1443 .chars()
1444 .filter(|c| c.is_alphanumeric() || *c == '-' || *c == '_' || *c == '.')
1445 .collect();
1446
1447 if sanitized.is_empty() || sanitized.len() > 64 {
1448 self.record_request_duration("get_premade_library", start);
1449 self.record_request_finished("get_premade_library", false);
1450 return Err(Status::invalid_argument("Invalid filename"));
1451 }
1452 if sanitized != req.filename {
1453 self.record_request_duration("get_premade_library", start);
1454 self.record_request_finished("get_premade_library", false);
1455 return Err(Status::invalid_argument("Invalid filename"));
1456 }
1457
1458 let content = match self.premade_manager.get(&sanitized) {
1459 Ok(c) => c,
1460 Err(e) => {
1461 self.record_request_duration("get_premade_library", start);
1462 self.record_request_finished("get_premade_library", false);
1463 return Err(e);
1464 }
1465 };
1466
1467 tracing::info!("User {} fetched premade library '{}'", user_id, sanitized);
1468
1469 self.record_request_duration("get_premade_library", start);
1470
1471 let result = Ok(Response::new(GetPremadeLibraryResponse {
1472 success: true,
1473 name: sanitized.clone(),
1474 content,
1475 message: "Library fetched successfully".to_string(),
1476 }));
1477 self.record_request_finished("get_premade_library", result.is_ok());
1478 result
1479 }
1480
1481 async fn search_premade_libraries(
1482 &self,
1483 request: Request<SearchPremadeLibrariesRequest>,
1484 ) -> Result<Response<SearchPremadeLibrariesResponse>, Status> {
1485 let request_id = uuid::Uuid::new_v4();
1486 let start = std::time::Instant::now();
1487 self.record_request("search_premade_libraries");
1488 tracing::info!(request_id = %request_id, "SearchPremadeLibraries request");
1489 let api_key = self.request_api_key(&request, &request.get_ref().api_key);
1490 let req = request.into_inner();
1491
1492 let _user_id = self
1493 .authenticate_and_rate_limit_with_duration(&api_key, Some(start))
1494 .await
1495 .inspect_err(|_| {
1496 self.record_request_finished("search_premade_libraries", false);
1497 })?;
1498
1499 if req.query.is_empty() {
1500 self.record_request_duration("search_premade_libraries", start);
1501 self.record_request_finished("search_premade_libraries", false);
1502 return Err(Status::invalid_argument("Query is required"));
1503 }
1504
1505 let results = self.premade_manager.search(&req.query);
1506
1507 let proto_libraries: Vec<ProtoPremadeLibrary> = results
1508 .into_iter()
1509 .map(|l| ProtoPremadeLibrary {
1510 name: l.name,
1511 filename: l.filename,
1512 description: l.description,
1513 snippet_count: l.snippet_count,
1514 tags: l.tags,
1515 })
1516 .collect();
1517
1518 let count = proto_libraries.len() as i32;
1519
1520 tracing::info!(
1521 request_id = %request_id,
1522 query = %req.query,
1523 count = count,
1524 "SearchPremadeLibraries completed"
1525 );
1526
1527 self.record_request_duration("search_premade_libraries", start);
1528
1529 let result = Ok(Response::new(SearchPremadeLibrariesResponse {
1530 libraries: proto_libraries,
1531 total_count: count,
1532 }));
1533 self.record_request_finished("search_premade_libraries", result.is_ok());
1534 result
1535 }
1536}
1537
1538#[cfg(test)]
1539mod tests {
1540 use super::*;
1541 use snip_proto::{
1542 CreateLibraryRequest, GetPremadeLibraryRequest, GetSnippetsRequest, HealthRequest,
1543 ListLibrariesRequest, PushSnippetsRequest, RegisterRequest, Snippet as ProtoSnippet,
1544 SyncRequest,
1545 };
1546
1547 pub async fn setup_test_service() -> SnipSyncService {
1548 setup_test_service_with_rate_limit(DEFAULT_RATE_LIMIT_PER_MINUTE).await
1549 }
1550
1551 async fn setup_test_service_with_rate_limit(rate_limit_per_minute: u32) -> SnipSyncService {
1552 let db = Arc::new(Database::connect("sqlite::memory:", 5).await.unwrap());
1553 let config = Config {
1554 grpc_host: "127.0.0.1".to_string(),
1555 grpc_port: 50051,
1556 http_host: "127.0.0.1".to_string(),
1557 http_port: 50050,
1558 db_path: "sqlite::memory:".to_string(),
1559 db_max_connections: 5,
1560 premade_dir: PathBuf::from("premade-libraries"),
1561 max_command_length: 1024,
1562 max_description_length: 1024,
1563 max_tags: 50,
1564 max_tag_length: 100,
1565 max_id_length: 128,
1566 max_device_id_length: 128,
1567 max_api_key_length: 512,
1568 request_timeout_secs: 30,
1569 grpc_max_message_size: 4 * 1024 * 1024,
1570 rate_limit_per_minute,
1571 trusted_proxies: vec![],
1572 persist_rate_limits: false,
1573 metrics_username: None,
1574 metrics_password: None,
1575 cors_allowed_origins: vec![],
1576 };
1577 let metrics = Metrics::fallback();
1578 let rate_limiter = Arc::new(RateLimiter::new());
1579 let premade_manager = PremadeManager::new(PathBuf::from("premade-libraries"));
1580
1581 SnipSyncService {
1582 db,
1583 rate_limiter,
1584 config,
1585 metrics,
1586 premade_manager,
1587 #[cfg(any(test, feature = "test-helpers"))]
1588 captured_auth_header: Arc::new(std::sync::Mutex::new(None)),
1589 test_observer: None,
1590 }
1591 }
1592
1593 pub async fn register_test_user(service: &SnipSyncService) -> String {
1594 let req = Request::new(RegisterRequest {
1595 device_id: "test-device".to_string(),
1596 });
1597 let resp = service.register(req).await.unwrap();
1598 resp.into_inner().api_key
1599 }
1600
1601 #[tokio::test]
1602 async fn test_health_check() {
1603 let service = setup_test_service().await;
1604 let req = Request::new(HealthRequest {});
1605 let resp = service.health(req).await.unwrap();
1606 let health = resp.into_inner();
1607 assert!(health.healthy);
1608 assert_eq!(health.version, env!("CARGO_PKG_VERSION"));
1609 }
1610
1611 #[tokio::test]
1612 async fn test_register_creates_user() {
1613 let service = setup_test_service().await;
1614 let req = Request::new(RegisterRequest {
1615 device_id: "test-device".to_string(),
1616 });
1617 let resp = service.register(req).await.unwrap();
1618 let reg = resp.into_inner();
1619 assert!(reg.success);
1620 assert!(!reg.api_key.is_empty());
1621 assert!(!reg.device_id.is_empty());
1622 assert!(uuid::Uuid::parse_str(®.device_id).is_ok());
1623 }
1624
1625 #[tokio::test]
1626 async fn test_register_rate_limiting() {
1627 let service = setup_test_service_with_rate_limit(3).await;
1628 for _ in 0..3 {
1629 let req = Request::new(RegisterRequest {
1630 device_id: "test-device".to_string(),
1631 });
1632 let _ = service.register(req).await;
1633 }
1634 let req = Request::new(RegisterRequest {
1635 device_id: "test-device".to_string(),
1636 });
1637 let resp = service.register(req).await;
1638 assert!(resp.is_err());
1639 assert_eq!(resp.unwrap_err().code(), tonic::Code::ResourceExhausted);
1640 }
1641
1642 #[tokio::test]
1643 async fn test_create_and_list_libraries() {
1644 let service = setup_test_service().await;
1645 let api_key = register_test_user(&service).await;
1646
1647 let req = Request::new(CreateLibraryRequest {
1648 api_key: api_key.clone(),
1649 name: "test-lib".to_string(),
1650 });
1651 let resp = service.create_library(req).await.unwrap();
1652 let create = resp.into_inner();
1653 assert!(create.success);
1654 assert!(!create.library_id.is_empty());
1655
1656 let req = Request::new(ListLibrariesRequest {
1657 api_key: api_key.clone(),
1658 limit: 100,
1659 offset: 0,
1660 });
1661 let resp = service.list_libraries(req).await.unwrap();
1662 let list = resp.into_inner();
1663 assert_eq!(list.libraries.len(), 2);
1664 assert!(list.libraries.iter().any(|l| l.name == "test-lib"));
1665 }
1666
1667 #[tokio::test]
1668 async fn test_create_duplicate_library_name() {
1669 let service = setup_test_service().await;
1670 let api_key = register_test_user(&service).await;
1671
1672 let req = Request::new(CreateLibraryRequest {
1673 api_key: api_key.clone(),
1674 name: "test-lib".to_string(),
1675 });
1676 let _ = service.create_library(req).await.unwrap();
1677
1678 let req = Request::new(CreateLibraryRequest {
1679 api_key: api_key.clone(),
1680 name: "test-lib".to_string(),
1681 });
1682 let resp = service.create_library(req).await;
1683 assert!(resp.is_err());
1684 assert_eq!(resp.unwrap_err().code(), tonic::Code::AlreadyExists);
1685 }
1686
1687 #[tokio::test]
1688 async fn test_invalid_api_key() {
1689 let service = setup_test_service().await;
1690 let req = Request::new(GetSnippetsRequest {
1691 api_key: "invalid-key".to_string(),
1692 library_id: String::new(),
1693 limit: 100,
1694 offset: 0,
1695 since: 0,
1696 });
1697 let resp = service.get_snippets(req).await;
1698 assert!(resp.is_err());
1699 assert_eq!(resp.unwrap_err().code(), tonic::Code::Unauthenticated);
1700 }
1701
1702 #[tokio::test]
1703 async fn test_validate_snippet_empty_id() {
1704 let service = setup_test_service().await;
1705 let snippet = ProtoSnippet {
1706 id: String::new(),
1707 description: "test".to_string(),
1708 command: "echo hello".to_string(),
1709 tags: vec![],
1710 created_at: 0,
1711 updated_at: 0,
1712 device_id: "device".to_string(),
1713 deleted: false,
1714 encrypted: false,
1715 };
1716 let result = service.validate_snippet(&snippet);
1717 assert!(result.is_err());
1718 assert!(result.unwrap_err().message().contains("ID is required"));
1719 }
1720
1721 #[tokio::test]
1722 async fn test_validate_snippet_oversized_command() {
1723 let service = setup_test_service().await;
1724 let snippet = ProtoSnippet {
1725 id: "test-id".to_string(),
1726 description: "test".to_string(),
1727 command: "x".repeat(2000),
1728 tags: vec![],
1729 created_at: 0,
1730 updated_at: 0,
1731 device_id: "device".to_string(),
1732 deleted: false,
1733 encrypted: false,
1734 };
1735 let result = service.validate_snippet(&snippet);
1736 assert!(result.is_err());
1737 assert!(result.unwrap_err().message().contains("maximum length"));
1738 }
1739
1740 #[tokio::test]
1741 async fn test_validate_snippet_future_timestamp() {
1742 let service = setup_test_service().await;
1743 let future = chrono::Utc::now().timestamp() + 600;
1744 let snippet = ProtoSnippet {
1745 id: "test-id".to_string(),
1746 description: "test".to_string(),
1747 command: "echo hello".to_string(),
1748 tags: vec![],
1749 created_at: future,
1750 updated_at: future,
1751 device_id: "device".to_string(),
1752 deleted: false,
1753 encrypted: false,
1754 };
1755 let result = service.validate_snippet(&snippet);
1756 assert!(result.is_err());
1757 assert!(result.unwrap_err().message().contains("future"));
1758 }
1759
1760 #[tokio::test]
1761 async fn test_validate_snippet_negative_timestamp() {
1762 let service = setup_test_service().await;
1763 let snippet = ProtoSnippet {
1764 id: "test-id".to_string(),
1765 description: "test".to_string(),
1766 command: "echo hello".to_string(),
1767 tags: vec![],
1768 created_at: -1,
1769 updated_at: -1,
1770 device_id: "device".to_string(),
1771 deleted: false,
1772 encrypted: false,
1773 };
1774 let result = service.validate_snippet(&snippet);
1775 assert!(result.is_err());
1776 assert!(result.unwrap_err().message().contains("non-negative"));
1777 }
1778
1779 #[tokio::test]
1780 async fn test_validate_snippet_too_many_tags() {
1781 let service = setup_test_service().await;
1782 let snippet = ProtoSnippet {
1783 id: "test-id".to_string(),
1784 description: "test".to_string(),
1785 command: "echo hello".to_string(),
1786 tags: (0..100).map(|i| format!("tag{}", i)).collect(),
1787 created_at: 0,
1788 updated_at: 0,
1789 device_id: "device".to_string(),
1790 deleted: false,
1791 encrypted: false,
1792 };
1793 let result = service.validate_snippet(&snippet);
1794 assert!(result.is_err());
1795 assert!(result.unwrap_err().message().contains("Too many tags"));
1796 }
1797
1798 #[tokio::test]
1799 async fn test_validate_snippet_valid() {
1800 let service = setup_test_service().await;
1801 let snippet = ProtoSnippet {
1802 id: "test-id".to_string(),
1803 description: "test".to_string(),
1804 command: "echo hello".to_string(),
1805 tags: vec!["bash".to_string()],
1806 created_at: 0,
1807 updated_at: 0,
1808 device_id: "device".to_string(),
1809 deleted: false,
1810 encrypted: false,
1811 };
1812 assert!(service.validate_snippet(&snippet).is_ok());
1813 }
1814
1815 #[tokio::test]
1816 async fn test_cross_user_library_access_denied() {
1817 let service = setup_test_service().await;
1818 let api_key1 = register_test_user(&service).await;
1819
1820 let req = Request::new(CreateLibraryRequest {
1821 api_key: api_key1.clone(),
1822 name: "user1-lib".to_string(),
1823 });
1824 let resp = service.create_library(req).await.unwrap();
1825 let library_id = resp.into_inner().library_id;
1826
1827 let api_key2 = register_test_user(&service).await;
1828
1829 let req = Request::new(GetSnippetsRequest {
1830 api_key: api_key2,
1831 library_id,
1832 limit: 100,
1833 offset: 0,
1834 since: 0,
1835 });
1836 let resp = service.get_snippets(req).await;
1837 assert!(resp.is_err());
1838 assert_eq!(resp.unwrap_err().code(), tonic::Code::NotFound);
1839 }
1840
1841 #[tokio::test]
1842 async fn test_push_and_get_snippets() {
1843 let service = setup_test_service().await;
1844 let api_key = register_test_user(&service).await;
1845
1846 let req = Request::new(CreateLibraryRequest {
1847 api_key: api_key.clone(),
1848 name: "test-lib".to_string(),
1849 });
1850 let resp = service.create_library(req).await.unwrap();
1851 let library_id = resp.into_inner().library_id;
1852
1853 let snippet = ProtoSnippet {
1854 id: "snippet-1".to_string(),
1855 description: "Test snippet".to_string(),
1856 command: "echo hello".to_string(),
1857 tags: vec!["test".to_string()],
1858 created_at: chrono::Utc::now().timestamp(),
1859 updated_at: chrono::Utc::now().timestamp(),
1860 device_id: "device-1".to_string(),
1861 deleted: false,
1862 encrypted: false,
1863 };
1864 let req = Request::new(PushSnippetsRequest {
1865 api_key: api_key.clone(),
1866 library_id: library_id.clone(),
1867 snippets: vec![snippet],
1868 });
1869 let resp = service.push_snippets(req).await.unwrap();
1870 let push = resp.into_inner();
1871 assert_eq!(push.accepted_count, 1);
1872 assert_eq!(push.rejected_count, 0);
1873
1874 let req = Request::new(GetSnippetsRequest {
1875 api_key: api_key.clone(),
1876 library_id,
1877 limit: 100,
1878 offset: 0,
1879 since: 0,
1880 });
1881 let resp = service.get_snippets(req).await.unwrap();
1882 let list = resp.into_inner();
1883 assert_eq!(list.snippets.len(), 1);
1884 assert_eq!(list.snippets[0].id, "snippet-1");
1885 assert_eq!(list.snippets[0].command, "echo hello");
1886 }
1887
1888 #[tokio::test]
1889 async fn test_delete_library() {
1890 let service = setup_test_service().await;
1891 let api_key = register_test_user(&service).await;
1892
1893 let req = Request::new(CreateLibraryRequest {
1894 api_key: api_key.clone(),
1895 name: "to-delete".to_string(),
1896 });
1897 let resp = service.create_library(req).await.unwrap();
1898 let library_id = resp.into_inner().library_id;
1899
1900 let req = Request::new(snip_proto::DeleteLibraryRequest {
1901 api_key: api_key.clone(),
1902 library_id: library_id.clone(),
1903 });
1904 let resp = service.delete_library(req).await.unwrap();
1905 assert!(resp.into_inner().success);
1906
1907 let req = Request::new(ListLibrariesRequest {
1908 api_key: api_key.clone(),
1909 limit: 100,
1910 offset: 0,
1911 });
1912 let resp = service.list_libraries(req).await.unwrap();
1913 let list = resp.into_inner();
1914 assert_eq!(list.libraries.len(), 1);
1915 assert_eq!(list.libraries[0].name, "default");
1916 }
1917
1918 #[tokio::test]
1919 async fn test_delete_default_library_blocked() {
1920 let service = setup_test_service().await;
1921 let api_key = register_test_user(&service).await;
1922
1923 let req = Request::new(snip_proto::DeleteLibraryRequest {
1924 api_key: api_key.clone(),
1925 library_id: "default".to_string(),
1926 });
1927 let resp = service.delete_library(req).await;
1928 assert!(resp.is_err());
1929 assert!(resp.unwrap_err().message().contains("Cannot delete"));
1930 }
1931
1932 #[tokio::test]
1933 async fn test_sync_basic() {
1934 let service = setup_test_service().await;
1935 let api_key = register_test_user(&service).await;
1936
1937 let req = Request::new(CreateLibraryRequest {
1938 api_key: api_key.clone(),
1939 name: "sync-test".to_string(),
1940 });
1941 let resp = service.create_library(req).await.unwrap();
1942 let library_id = resp.into_inner().library_id;
1943
1944 let req = Request::new(SyncRequest {
1945 api_key: api_key.clone(),
1946 local_snippets: vec![],
1947 last_sync_timestamp: 0,
1948 library_id,
1949 limit: 1000,
1950 offset: 0,
1951 });
1952 let resp = service.sync(req).await.unwrap();
1953 let sync = resp.into_inner();
1954 assert_eq!(sync.snippets.len(), 0);
1955 }
1956
1957 #[tokio::test]
1958 async fn test_premade_filename_with_unsafe_characters_is_rejected() {
1959 let service = setup_test_service().await;
1960 let api_key = register_test_user(&service).await;
1961
1962 let req = Request::new(GetPremadeLibraryRequest {
1963 api_key,
1964 filename: "valid-name!.toml".to_string(),
1965 });
1966 let error = service.get_premade_library(req).await.unwrap_err();
1967
1968 assert_eq!(error.code(), tonic::Code::InvalidArgument);
1969 assert_eq!(error.message(), "Invalid filename");
1970 }
1971
1972 #[test]
1973 fn config_load_missing_file_uses_defaults() {
1974 let dir = tempfile::tempdir().unwrap();
1975 let path = dir.path().join("missing.toml");
1976 let config = Config::load_from(&path, &|_| None).unwrap();
1977 assert_eq!(config.grpc_port, 50051);
1978 assert_eq!(config.http_port, 50050);
1979 }
1980
1981 #[test]
1982 fn config_load_merges_file_and_environment_overrides() {
1983 let dir = tempfile::tempdir().unwrap();
1984 let path = dir.path().join("config.toml");
1985 std::fs::write(
1986 &path,
1987 "[server]\ngrpc_port = 51000\nhttp_host = \"192.0.2.10\"\n",
1988 )
1989 .unwrap();
1990 let config = Config::load_from(&path, &|name| {
1991 (name == "GRPC_PORT").then(|| "52000".to_string())
1992 })
1993 .unwrap();
1994 assert_eq!(config.grpc_port, 52000);
1995 assert_eq!(config.http_host, "192.0.2.10");
1996 }
1997
1998 #[test]
1999 fn config_load_rejects_malformed_existing_file() {
2000 let dir = tempfile::tempdir().unwrap();
2001 let path = dir.path().join("config.toml");
2002 std::fs::write(&path, "[server\n").unwrap();
2003 let error = match Config::load_from(&path, &|_| None) {
2004 Ok(_) => panic!("malformed config unexpectedly loaded"),
2005 Err(error) => error,
2006 };
2007 let message = error.to_string();
2008 assert!(message.contains(&path.display().to_string()));
2009 assert!(message.contains("parse"));
2010 }
2011
2012 #[test]
2013 fn config_load_rejects_unreadable_existing_path() {
2014 let dir = tempfile::tempdir().unwrap();
2015 let error = match Config::load_from(dir.path(), &|_| None) {
2016 Ok(_) => panic!("directory unexpectedly loaded as config"),
2017 Err(error) => error,
2018 };
2019 assert!(
2020 error
2021 .to_string()
2022 .contains(&dir.path().display().to_string())
2023 );
2024 }
2025}