1use crate::transport::TransportConfig;
32use parking_lot::RwLock;
33use std::collections::HashMap;
34use std::path::PathBuf;
35use std::sync::Arc;
36
37#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
59pub enum SocketKind {
60 Req,
62 Rep,
64 Quic,
66}
67
68impl SocketKind {
69 pub fn suffix(&self) -> &'static str {
71 match self {
72 SocketKind::Rep => "",
73 SocketKind::Req => "-req",
74 SocketKind::Quic => "-quic",
75 }
76 }
77}
78
79#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
84pub enum EndpointMode {
85 #[default]
87 Inproc,
88 Ipc,
94}
95
96#[derive(Debug, Clone)]
98pub struct ServiceEntry {
99 pub name: String,
101 pub endpoints: HashMap<SocketKind, TransportConfig>,
103 pub description: Option<String>,
105 pub schema: Option<&'static [u8]>,
107}
108
109pub struct EndpointRegistry {
123 mode: EndpointMode,
124 runtime_dir: Option<PathBuf>,
125 services: RwLock<HashMap<String, ServiceEntry>>,
126}
127
128impl EndpointRegistry {
129 pub fn new(mode: EndpointMode, runtime_dir: Option<PathBuf>) -> Self {
136 Self {
137 mode,
138 runtime_dir,
139 services: RwLock::new(HashMap::new()),
140 }
141 }
142
143 pub fn register(
147 &self,
148 name: &str,
149 socket_kind: SocketKind,
150 endpoint: TransportConfig,
151 description: Option<&str>,
152 ) {
153 let mut services = self.services.write();
154 let entry = services
155 .entry(name.to_owned())
156 .or_insert_with(|| ServiceEntry {
157 name: name.to_owned(),
158 endpoints: HashMap::new(),
159 description: description.map(String::from),
160 schema: None,
161 });
162 if let Some(desc) = description {
164 entry.description = Some(desc.to_owned());
165 }
166 entry.endpoints.insert(socket_kind, endpoint);
167 }
168
169 pub(crate) fn unregister(&self, name: &str, socket_kind: SocketKind) {
176 let mut services = self.services.write();
177 if let Some(entry) = services.get_mut(name) {
178 entry.endpoints.remove(&socket_kind);
179 if entry.endpoints.is_empty() {
180 services.remove(name);
181 }
182 }
183 }
184
185 #[allow(dead_code)]
187 pub(crate) fn unregister_all(&self, name: &str) {
188 self.services.write().remove(name);
189 }
190
191 pub fn endpoint(&self, name: &str, socket_kind: SocketKind) -> TransportConfig {
202 self.try_endpoint(name, socket_kind)
203 .unwrap_or_else(|err| panic!("{err}"))
204 }
205
206 pub fn try_endpoint(
212 &self,
213 name: &str,
214 socket_kind: SocketKind,
215 ) -> anyhow::Result<TransportConfig> {
216 if let Some(endpoint) = self.registered_endpoint(name, socket_kind) {
217 return Ok(endpoint);
218 }
219
220 self.local_default_endpoint(name, socket_kind)
221 }
222
223 pub fn registered_endpoint(
226 &self,
227 name: &str,
228 socket_kind: SocketKind,
229 ) -> Option<TransportConfig> {
230 if let Some(entry) = self.services.read().get(name) {
231 if let Some(ep) = entry.endpoints.get(&socket_kind) {
232 return Some(ep.clone());
233 }
234 }
235 None
236 }
237
238 fn local_default_endpoint(
243 &self,
244 name: &str,
245 socket_kind: SocketKind,
246 ) -> anyhow::Result<TransportConfig> {
247 match self.mode {
248 EndpointMode::Inproc => local_inproc_endpoint(name, socket_kind),
249 EndpointMode::Ipc => {
250 same_host_uds_endpoint(name, socket_kind, self.runtime_dir.as_ref())
251 }
252 }
253 }
254}
255
256fn local_inproc_endpoint(name: &str, socket_kind: SocketKind) -> anyhow::Result<TransportConfig> {
257 if socket_kind == SocketKind::Quic {
258 anyhow::bail!(
259 "no registered QUIC endpoint for service '{name}' — network reach must be announced or explicitly registered"
260 );
261 }
262 Ok(TransportConfig::inproc(format!(
263 "hyprstream/{name}{}",
264 socket_kind.suffix()
265 )))
266}
267
268fn same_host_uds_endpoint(
269 name: &str,
270 socket_kind: SocketKind,
271 runtime_dir: Option<&PathBuf>,
272) -> anyhow::Result<TransportConfig> {
273 if socket_kind == SocketKind::Quic {
274 anyhow::bail!(
275 "no registered QUIC endpoint for service '{name}' — network reach must be announced or explicitly registered"
276 );
277 }
278 let suffix = socket_kind.suffix();
279 let path = runtime_dir
280 .map(|d| d.join(format!("{name}{suffix}.sock")))
281 .unwrap_or_else(|| PathBuf::from(format!("/tmp/hyprstream/{name}{suffix}.sock")));
282 Ok(TransportConfig::ipc(path))
283}
284
285impl EndpointRegistry {
286 pub fn register_rep(&self, name: &str, endpoint: TransportConfig, description: Option<&str>) {
292 self.register(name, SocketKind::Rep, endpoint, description);
293 }
294
295 #[allow(dead_code)]
299 pub(crate) fn unregister_rep(&self, name: &str) {
300 self.unregister(name, SocketKind::Rep);
301 }
302
303 pub fn rep_endpoint(&self, name: &str) -> TransportConfig {
307 self.endpoint(name, SocketKind::Rep)
308 }
309
310 pub fn mode(&self) -> EndpointMode {
316 self.mode
317 }
318
319 pub fn runtime_dir(&self) -> Option<&PathBuf> {
321 self.runtime_dir.as_ref()
322 }
323
324 pub fn list_services(&self) -> Vec<String> {
326 self.services.read().keys().cloned().collect()
327 }
328
329 pub fn service_entry(&self, name: &str) -> Option<ServiceEntry> {
331 self.services.read().get(name).cloned()
332 }
333
334 pub fn service_endpoints(&self, name: &str) -> Option<HashMap<SocketKind, TransportConfig>> {
336 self.services.read().get(name).map(|e| e.endpoints.clone())
337 }
338
339 pub fn register_with_schema(
341 &self,
342 name: &str,
343 socket_kind: SocketKind,
344 endpoint: TransportConfig,
345 description: Option<&str>,
346 schema: Option<&'static [u8]>,
347 ) {
348 let mut services = self.services.write();
349 let entry = services
350 .entry(name.to_owned())
351 .or_insert_with(|| ServiceEntry {
352 name: name.to_owned(),
353 endpoints: HashMap::new(),
354 description: description.map(String::from),
355 schema: None,
356 });
357 if let Some(desc) = description {
358 entry.description = Some(desc.to_owned());
359 }
360 if schema.is_some() {
361 entry.schema = schema;
362 }
363 entry.endpoints.insert(socket_kind, endpoint);
364 }
365
366 pub fn service_schema(&self, name: &str) -> Option<&'static [u8]> {
368 self.services.read().get(name).and_then(|e| e.schema)
369 }
370}
371
372#[async_trait::async_trait]
377impl crate::resolver::Resolver for EndpointRegistry {
378 async fn resolve(&self, name: &str, kind: SocketKind) -> anyhow::Result<TransportConfig> {
379 self.try_endpoint(name, kind)
380 }
381}
382
383static REGISTRY: RwLock<Option<EndpointRegistry>> = RwLock::new(None);
385
386fn registered_global_endpoint(
387 name: &str,
388 kind: SocketKind,
389) -> anyhow::Result<Option<TransportConfig>> {
390 let registry = try_global()
391 .ok_or_else(|| anyhow::anyhow!("EndpointRegistry not initialized — call init() first"))?;
392 Ok(registry.registered_endpoint(name, kind))
393}
394
395pub struct LocalInprocResolver;
397
398#[async_trait::async_trait]
399impl crate::resolver::Resolver for LocalInprocResolver {
400 async fn resolve(&self, name: &str, kind: SocketKind) -> anyhow::Result<TransportConfig> {
401 if let Some(endpoint) = registered_global_endpoint(name, kind)? {
402 return Ok(endpoint);
403 }
404 local_inproc_endpoint(name, kind)
405 }
406}
407
408pub struct IpcResolver {
410 runtime_dir: Option<PathBuf>,
411}
412
413impl IpcResolver {
414 pub fn new(runtime_dir: Option<PathBuf>) -> Self {
415 Self { runtime_dir }
416 }
417}
418
419#[async_trait::async_trait]
420impl crate::resolver::Resolver for IpcResolver {
421 async fn resolve(&self, name: &str, kind: SocketKind) -> anyhow::Result<TransportConfig> {
422 if let Some(endpoint) = registered_global_endpoint(name, kind)? {
423 return Ok(endpoint);
424 }
425 same_host_uds_endpoint(name, kind, self.runtime_dir.as_ref())
426 }
427}
428
429pub fn init(mode: EndpointMode, runtime_dir: Option<PathBuf>) {
438 let mut guard = REGISTRY.write();
439 if guard.is_none() {
440 *guard = Some(EndpointRegistry::new(mode, runtime_dir.clone()));
441 let resolver: Arc<dyn crate::resolver::Resolver> = match mode {
444 EndpointMode::Inproc => Arc::new(LocalInprocResolver),
445 EndpointMode::Ipc => Arc::new(IpcResolver::new(runtime_dir)),
446 };
447 crate::resolver::set_global(resolver);
448 }
449}
450
451pub fn shutdown() {
455 *REGISTRY.write() = None;
456}
457
458pub fn global() -> impl std::ops::Deref<Target = EndpointRegistry> + 'static {
469 parking_lot::RwLockReadGuard::map(REGISTRY.read(), |r| match r.as_ref() {
470 Some(registry) => registry,
471 None => panic!("EndpointRegistry not initialized - call init() first"),
472 })
473}
474
475pub fn try_global() -> Option<impl std::ops::Deref<Target = EndpointRegistry> + 'static> {
479 let guard = REGISTRY.read();
480 if guard.is_some() {
481 Some(parking_lot::RwLockReadGuard::map(guard, |r| {
482 match r.as_ref() {
484 Some(registry) => registry,
485 None => unreachable!("checked is_some() above"),
486 }
487 }))
488 } else {
489 None
490 }
491}
492
493pub struct ServiceRegistration {
513 name: String,
514 socket_kinds: Vec<SocketKind>,
515}
516
517impl ServiceRegistration {
518 pub fn new(
530 name: &str,
531 endpoint: TransportConfig,
532 description: Option<&str>,
533 ) -> anyhow::Result<Self> {
534 Self::with_socket_kind(name, SocketKind::Rep, endpoint, description)
535 }
536
537 pub fn with_socket_kind(
546 name: &str,
547 socket_kind: SocketKind,
548 endpoint: TransportConfig,
549 description: Option<&str>,
550 ) -> anyhow::Result<Self> {
551 let registry = try_global().ok_or_else(|| anyhow::anyhow!("Registry not initialized"))?;
552 registry.register(name, socket_kind, endpoint, description);
553 Ok(Self {
554 name: name.to_owned(),
555 socket_kinds: vec![socket_kind],
556 })
557 }
558
559 pub fn multi(
567 name: &str,
568 endpoints: Vec<(SocketKind, TransportConfig)>,
569 description: Option<&str>,
570 ) -> anyhow::Result<Self> {
571 let registry = try_global().ok_or_else(|| anyhow::anyhow!("Registry not initialized"))?;
572 let mut socket_kinds = Vec::with_capacity(endpoints.len());
573 for (socket_kind, endpoint) in endpoints {
574 registry.register(name, socket_kind, endpoint, description);
575 socket_kinds.push(socket_kind);
576 }
577 Ok(Self {
578 name: name.to_owned(),
579 socket_kinds,
580 })
581 }
582
583 pub fn add_socket_kind(
585 &mut self,
586 socket_kind: SocketKind,
587 endpoint: TransportConfig,
588 description: Option<&str>,
589 ) -> anyhow::Result<()> {
590 let registry = try_global().ok_or_else(|| anyhow::anyhow!("Registry not initialized"))?;
591 registry.register(&self.name, socket_kind, endpoint, description);
592 self.socket_kinds.push(socket_kind);
593 Ok(())
594 }
595
596 pub fn name(&self) -> &str {
598 &self.name
599 }
600
601 pub fn socket_kinds(&self) -> &[SocketKind] {
603 &self.socket_kinds
604 }
605}
606
607impl Drop for ServiceRegistration {
608 fn drop(&mut self) {
609 if let Some(registry) = try_global() {
610 for socket_kind in &self.socket_kinds {
611 registry.unregister(&self.name, *socket_kind);
612 }
613 }
614 }
615}
616
617#[cfg(test)]
618mod tests {
619 use super::*;
620 use crate::resolver::Resolver;
621 use parking_lot::Mutex;
622
623 static TEST_MUTEX: Mutex<()> = Mutex::new(());
625
626 fn reset_registry() {
627 *REGISTRY.write() = None;
628 }
629
630 #[test]
631 fn test_inproc_defaults() {
632 let _lock = TEST_MUTEX.lock();
633 reset_registry();
634 init(EndpointMode::Inproc, None);
635
636 let endpoint = global().endpoint("policy", SocketKind::Rep);
638 assert_eq!(endpoint.endpoint_string(), "inproc://hyprstream/policy");
639
640 let endpoint = global().endpoint("model", SocketKind::Req);
642 assert_eq!(endpoint.endpoint_string(), "inproc://hyprstream/model-req");
643 }
644
645 #[test]
646 fn test_global_resolver_installs_local_inproc_profile() {
647 let _lock = TEST_MUTEX.lock();
648 reset_registry();
649 init(EndpointMode::Inproc, None);
650
651 let resolver = match crate::resolver::try_global() {
652 Some(resolver) => resolver,
653 None => panic!("global resolver must be installed"),
654 };
655 let endpoint = futures::executor::block_on(resolver.resolve("policy", SocketKind::Rep))
656 .unwrap_or_else(|err| panic!("local-inproc resolver failed: {err}"));
657 assert_eq!(endpoint.endpoint_string(), "inproc://hyprstream/policy");
658 }
659
660 #[test]
661 fn test_ipc_defaults() {
662 let _lock = TEST_MUTEX.lock();
663 reset_registry();
664 init(EndpointMode::Ipc, Some(PathBuf::from("/run/hyprstream")));
665
666 let endpoint = global().endpoint("policy", SocketKind::Rep);
668 assert_eq!(
669 endpoint.endpoint_string(),
670 "ipc:///run/hyprstream/policy.sock"
671 );
672
673 let endpoint = global().endpoint("model", SocketKind::Req);
675 assert_eq!(
676 endpoint.endpoint_string(),
677 "ipc:///run/hyprstream/model-req.sock"
678 );
679 }
680
681 #[test]
682 fn test_global_resolver_installs_ipc_profile() {
683 let _lock = TEST_MUTEX.lock();
684 reset_registry();
685 init(EndpointMode::Ipc, Some(PathBuf::from("/run/hyprstream")));
686
687 let resolver = match crate::resolver::try_global() {
688 Some(resolver) => resolver,
689 None => panic!("global resolver must be installed"),
690 };
691 let endpoint = futures::executor::block_on(resolver.resolve("policy", SocketKind::Rep))
692 .unwrap_or_else(|err| panic!("same-host-uds resolver failed: {err}"));
693 assert_eq!(
694 endpoint.endpoint_string(),
695 "ipc:///run/hyprstream/policy.sock"
696 );
697 }
698
699 #[test]
700 fn test_single_registration() -> anyhow::Result<()> {
701 let _lock = TEST_MUTEX.lock();
702 reset_registry();
703 init(EndpointMode::Inproc, None);
704
705 {
706 let _reg = ServiceRegistration::new(
707 "test-service",
708 TransportConfig::inproc("custom/endpoint"),
709 Some("Test service"),
710 )?;
711
712 let endpoint = global().endpoint("test-service", SocketKind::Rep);
713 assert_eq!(endpoint.endpoint_string(), "inproc://custom/endpoint");
714 }
715
716 let endpoint = global().endpoint("test-service", SocketKind::Rep);
718 assert_eq!(
719 endpoint.endpoint_string(),
720 "inproc://hyprstream/test-service"
721 );
722 Ok(())
723 }
724
725 #[test]
726 fn test_multi_registration() -> anyhow::Result<()> {
727 let _lock = TEST_MUTEX.lock();
728 reset_registry();
729 init(EndpointMode::Inproc, None);
730
731 {
732 let _reg = ServiceRegistration::multi(
733 "model",
734 vec![
735 (SocketKind::Rep, TransportConfig::inproc("model/rep")),
736 (SocketKind::Quic, TransportConfig::inproc("model/quic")),
737 ],
738 Some("Model service"),
739 )?;
740
741 let rep_ep = global().endpoint("model", SocketKind::Rep);
743 assert_eq!(rep_ep.endpoint_string(), "inproc://model/rep");
744
745 let quic_ep = global().endpoint("model", SocketKind::Quic);
746 assert_eq!(quic_ep.endpoint_string(), "inproc://model/quic");
747 }
748
749 let rep_ep = global().endpoint("model", SocketKind::Rep);
752 assert_eq!(rep_ep.endpoint_string(), "inproc://hyprstream/model");
753
754 let err = match global().try_endpoint("model", SocketKind::Quic) {
755 Ok(endpoint) => panic!("missing QUIC endpoint resolved to {endpoint:?}"),
756 Err(err) => err,
757 };
758 assert!(
759 err.to_string().contains("no registered QUIC endpoint"),
760 "unexpected error: {err}"
761 );
762 Ok(())
763 }
764
765 #[test]
766 fn test_missing_quic_endpoint_fails_closed_through_resolver() {
767 let _lock = TEST_MUTEX.lock();
768 reset_registry();
769 init(EndpointMode::Inproc, None);
770
771 let err = match futures::executor::block_on(global().resolve("model", SocketKind::Quic)) {
772 Ok(endpoint) => panic!("missing QUIC endpoint resolved to {endpoint:?}"),
773 Err(err) => err,
774 };
775 assert!(
776 err.to_string().contains("no registered QUIC endpoint"),
777 "unexpected error: {err}"
778 );
779 }
780
781 #[test]
782 fn test_backward_compat() {
783 let _lock = TEST_MUTEX.lock();
784 reset_registry();
785 init(EndpointMode::Inproc, None);
786
787 let registry = global();
789 registry.register_rep(
790 "compat-service",
791 TransportConfig::inproc("compat/endpoint"),
792 None,
793 );
794
795 let endpoint = registry.rep_endpoint("compat-service");
797 assert_eq!(endpoint.endpoint_string(), "inproc://compat/endpoint");
798
799 let endpoint = registry.endpoint("compat-service", SocketKind::Rep);
801 assert_eq!(endpoint.endpoint_string(), "inproc://compat/endpoint");
802 }
803
804 #[test]
805 fn test_try_global_uninitialized() {
806 let _lock = TEST_MUTEX.lock();
807 reset_registry();
808 assert!(try_global().is_none());
809 }
810
811 #[test]
812 fn test_list_services() {
813 let _lock = TEST_MUTEX.lock();
814 reset_registry();
815 init(EndpointMode::Inproc, None);
816
817 global().register("svc1", SocketKind::Rep, TransportConfig::inproc("a"), None);
818 global().register("svc2", SocketKind::Quic, TransportConfig::inproc("b"), None);
819
820 let services = global().list_services();
821 assert!(services.contains(&"svc1".to_owned()));
822 assert!(services.contains(&"svc2".to_owned()));
823 }
824}