component.rs 22.9 KB
Newer Older
1
2
// SPDX-FileCopyrightText: Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
Ryan Olson's avatar
Ryan Olson committed
3
4
5

//! The [Component] module defines the top-level API for building distributed applications.
//!
Graham King's avatar
Graham King committed
6
7
8
//! A distributed application consists of a set of [Component] that can host one
//! or more [Endpoint]. Each [Endpoint] is a network-accessible service
//! that can be accessed by other [Component] in the distributed application.
Ryan Olson's avatar
Ryan Olson committed
9
10
11
12
//!
//! A [Component] is made discoverable by registering it with the distributed runtime under
//! a [`Namespace`].
//!
Graham King's avatar
Graham King committed
13
//! A [`Namespace`] is a logical grouping of [Component] that are grouped together.
Ryan Olson's avatar
Ryan Olson committed
14
15
16
17
18
19
20
21
22
23
24
25
//!
//! We might extend namespace to include grouping behavior, which would define groups of
//! components that are tightly coupled.
//!
//! A [Component] is the core building block of a distributed application. It is a logical
//! unit of work such as a `Preprocessor` or `SmartRouter` that has a well-defined role in the
//! distributed application.
//!
//! A [Component] can present to the distributed application one or more configuration files
//! which define how that component was constructed/configured and what capabilities it can
//! provide.
//!
Graham King's avatar
Graham King committed
26
//! Other [Component] can write to watching locations within a [Component] etcd
Ryan Olson's avatar
Ryan Olson committed
27
28
29
30
31
//! path. This allows the [Component] to take dynamic actions depending on the watch
//! triggers.
//!
//! TODO: Top-level Overview of Endpoints/Functions

32
33
use std::fmt;

34
use crate::{
35
36
    config::HealthStatus,
    discovery::Lease,
37
    metrics::{MetricsRegistry, prometheus_names},
38
    service::ServiceSet,
39
    transports::etcd::{ETCD_ROOT_PATH, EtcdPath},
40
};
Ryan Olson's avatar
Ryan Olson committed
41

Ryan Olson's avatar
Ryan Olson committed
42
use super::{
43
    DistributedRuntime, Result, Runtime, error,
44
45
46
47
    traits::*,
    transports::etcd::{COMPONENT_KEYWORD, ENDPOINT_KEYWORD},
    transports::nats::Slug,
    utils::Duration,
Ryan Olson's avatar
Ryan Olson committed
48
};
Ryan Olson's avatar
Ryan Olson committed
49

50
use crate::pipeline::network::{PushWorkHandler, ingress::push_endpoint::PushEndpoint};
51
use crate::protocols::EndpointId;
52
use crate::service::ComponentNatsServerPrometheusMetrics;
Ryan Olson's avatar
Ryan Olson committed
53
54
55
56
57
58
59
60
use async_nats::{
    rustls::quic,
    service::{Service, ServiceExt},
};
use derive_builder::Builder;
use derive_getters::Getters;
use educe::Educe;
use serde::{Deserialize, Serialize};
61
use service::EndpointStatsHandler;
62
use std::{collections::HashMap, hash::Hash, sync::Arc};
Ryan Olson's avatar
Ryan Olson committed
63
64
65
use validator::{Validate, ValidationError};

mod client;
66
67
#[allow(clippy::module_inception)]
mod component;
Ryan Olson's avatar
Ryan Olson committed
68
mod endpoint;
Ryan Olson's avatar
Ryan Olson committed
69
mod namespace;
Ryan Olson's avatar
Ryan Olson committed
70
mod registry;
71
pub mod service;
Ryan Olson's avatar
Ryan Olson committed
72

73
74
pub use client::{Client, InstanceSource};

75
/// The root key-value path where each instance registers itself in.
76
/// An instance is namespace+component+endpoint+lease_id and must be unique.
77
pub const INSTANCE_ROOT_PATH: &str = "v1/instances";
78

Ryan Olson's avatar
Ryan Olson committed
79
80
81
82
83
84
#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum TransportType {
    NatsTcp(String),
}

85
86
87
88
89
90
#[derive(Default)]
pub struct RegistryInner {
    services: HashMap<String, Service>,
    stats_handlers: HashMap<String, Arc<std::sync::Mutex<HashMap<String, EndpointStatsHandler>>>>,
}

Ryan Olson's avatar
Ryan Olson committed
91
92
#[derive(Clone)]
pub struct Registry {
93
    inner: Arc<tokio::sync::Mutex<RegistryInner>>,
Ryan Olson's avatar
Ryan Olson committed
94
95
}

96
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
97
pub struct Instance {
Ryan Olson's avatar
Ryan Olson committed
98
99
100
    pub component: String,
    pub endpoint: String,
    pub namespace: String,
101
    pub instance_id: i64,
Ryan Olson's avatar
Ryan Olson committed
102
103
104
    pub transport: TransportType,
}

105
impl Instance {
106
    pub fn id(&self) -> i64 {
107
        self.instance_id
108
    }
109
110
111
112
113
114
115
    pub fn endpoint_id(&self) -> EndpointId {
        EndpointId {
            namespace: self.namespace.clone(),
            component: self.component.clone(),
            name: self.endpoint.clone(),
        }
    }
116
117
}

118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
impl fmt::Display for Instance {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "{}/{}/{}/{}",
            self.namespace, self.component, self.endpoint, self.instance_id
        )
    }
}

/// Sort by string name
impl std::cmp::Ord for Instance {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        self.to_string().cmp(&other.to_string())
    }
}

impl PartialOrd for Instance {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        // Since Ord is fully implemented, the comparison is always total.
        Some(self.cmp(other))
    }
}

Ryan Olson's avatar
Ryan Olson committed
142
/// A [Component] a discoverable entity in the distributed runtime.
Graham King's avatar
Graham King committed
143
144
/// You can host [Endpoint] on a [Component] by first creating
/// a [Service] then adding one or more [Endpoint] to the [Service].
Ryan Olson's avatar
Ryan Olson committed
145
146
///
/// You can also issue a request to a [Component]'s [Endpoint] by creating a [Client].
147
#[derive(Educe, Builder, Clone, Validate)]
Ryan Olson's avatar
Ryan Olson committed
148
149
150
151
152
#[educe(Debug)]
#[builder(pattern = "owned")]
pub struct Component {
    #[builder(private)]
    #[educe(Debug(ignore))]
153
    drt: Arc<DistributedRuntime>,
Ryan Olson's avatar
Ryan Olson committed
154
155
156
157

    // todo - restrict the namespace to a-z0-9-_A-Z
    /// Name of the component
    #[builder(setter(into))]
158
    #[validate(custom(function = "validate_allowed_chars"))]
Ryan Olson's avatar
Ryan Olson committed
159
160
    name: String,

161
162
163
164
    /// Additional labels for metrics
    #[builder(default = "Vec::new()")]
    labels: Vec<(String, String)>,

Ryan Olson's avatar
Ryan Olson committed
165
166
167
    // todo - restrict the namespace to a-z0-9-_A-Z
    /// Namespace
    #[builder(setter(into))]
168
    namespace: Namespace,
169
170
171
172

    // A static component's endpoints cannot be discovered via etcd, they are
    // fixed at startup time.
    is_static: bool,
Ryan Olson's avatar
Ryan Olson committed
173
174
}

175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
impl Hash for Component {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        self.namespace.name().hash(state);
        self.name.hash(state);
        self.is_static.hash(state);
    }
}

impl PartialEq for Component {
    fn eq(&self, other: &Self) -> bool {
        self.namespace.name() == other.namespace.name()
            && self.name == other.name
            && self.is_static == other.is_static
    }
}

impl Eq for Component {}

193
194
impl std::fmt::Display for Component {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
195
        write!(f, "{}.{}", self.namespace.name(), self.name)
196
197
198
    }
}

199
200
201
202
203
204
205
206
207
208
209
210
impl DistributedRuntimeProvider for Component {
    fn drt(&self) -> &DistributedRuntime {
        &self.drt
    }
}

impl RuntimeProvider for Component {
    fn rt(&self) -> &Runtime {
        self.drt.rt()
    }
}

211
212
213
214
215
216
217
218
219
220
221
222
223
224
impl MetricsRegistry for Component {
    fn basename(&self) -> String {
        self.name.clone()
    }

    fn parent_hierarchy(&self) -> Vec<String> {
        [
            self.namespace.parent_hierarchy(),
            vec![self.namespace.basename()],
        ]
        .concat()
    }
}

Ryan Olson's avatar
Ryan Olson committed
225
impl Component {
226
227
    /// The component part of an instance path in key-value store.
    pub fn instance_root(&self) -> String {
228
229
230
        let ns = self.namespace.name();
        let cp = &self.name;
        format!("{INSTANCE_ROOT_PATH}/{ns}/{cp}")
Ryan Olson's avatar
Ryan Olson committed
231
232
    }

233
    pub fn service_name(&self) -> String {
234
        let service_name = format!("{}_{}", self.namespace.name(), self.name);
235
        Slug::slugify(&service_name).to_string()
Ryan Olson's avatar
Ryan Olson committed
236
237
    }

238
    pub fn path(&self) -> String {
239
        format!("{}/{}", self.namespace.name(), self.name)
240
241
    }

242
243
244
245
246
    pub fn etcd_path(&self) -> EtcdPath {
        EtcdPath::new_component(&self.namespace.name(), &self.name)
            .expect("Component name and namespace should be valid")
    }

247
    pub fn namespace(&self) -> &Namespace {
248
249
250
        &self.namespace
    }

251
252
    pub fn name(&self) -> &str {
        &self.name
253
254
    }

255
256
257
258
    pub fn labels(&self) -> &[(String, String)] {
        &self.labels
    }

Ryan Olson's avatar
Ryan Olson committed
259
260
261
262
    pub fn endpoint(&self, endpoint: impl Into<String>) -> Endpoint {
        Endpoint {
            component: self.clone(),
            name: endpoint.into(),
263
            is_static: self.is_static,
264
            labels: Vec::new(),
Ryan Olson's avatar
Ryan Olson committed
265
266
267
        }
    }

268
    pub async fn list_instances(&self) -> anyhow::Result<Vec<Instance>> {
269
270
        let client = self.drt.store();
        let Some(bucket) = client.get_bucket(&self.instance_root()).await? else {
271
272
            return Ok(vec![]);
        };
273
274
275
276
        let entries = bucket.entries().await?;
        let mut instances = Vec::with_capacity(entries.len());
        for (name, bytes) in entries.into_iter() {
            let val = match serde_json::from_slice::<Instance>(&bytes) {
277
278
                Ok(val) => val,
                Err(err) => {
279
                    anyhow::bail!("Error converting storage response to Instance: {err}. {name}",);
280
281
                }
            };
282
            instances.push(val);
283
        }
284
285
        instances.sort();
        Ok(instances)
Ryan Olson's avatar
Ryan Olson committed
286
287
    }

288
289
    /// Scrape ServiceSet, which contains NATS stats as well as user defined stats
    /// embedded in data field of ServiceInfo.
290
    pub async fn scrape_stats(&self, timeout: Duration) -> Result<ServiceSet> {
291
        // Debug: scraping stats for component
Ryan Olson's avatar
Ryan Olson committed
292
293
294
        let service_name = self.service_name();
        let service_client = self.drt().service_client();
        service_client
295
            .collect_services(&service_name, timeout)
Ryan Olson's avatar
Ryan Olson committed
296
297
298
            .await
    }

299
    /// Add Prometheus metrics for this component's NATS service stats.
300
    ///
301
    /// Starts a background task that periodically requests service statistics from NATS
302
303
304
305
    /// and updates the corresponding Prometheus metrics. The first scrape happens immediately,
    /// then subsequent scrapes occur at a fixed interval of 9.8 seconds (MAX_WAIT_MS),
    /// which should be near or smaller than typical Prometheus scraping intervals to ensure
    /// metrics are fresh when Prometheus collects them.
306
    pub fn start_scraping_nats_service_component_metrics(&self) -> Result<()> {
307
        const MAX_WAIT_MS: std::time::Duration = std::time::Duration::from_millis(9800); // Should be <= Prometheus scrape interval
308

309
310
        // If there is another component with the same service name, this will fail.
        let component_metrics = ComponentNatsServerPrometheusMetrics::new(self)?;
311
312
313
314

        let component_clone = self.clone();
        let mut hierarchies = self.parent_hierarchy();
        hierarchies.push(self.hierarchy());
315
316
317
318
319
320
321
        debug_assert!(
            hierarchies
                .last()
                .map(|x| x.as_str())
                .unwrap_or_default()
                .eq_ignore_ascii_case(&self.service_name())
        ); // it happens that in component, hierarchy and service name are the same
322

323
324
325
326
        // Start a background task that scrapes stats every 5 seconds
        let m = component_metrics.clone();
        let c = component_clone.clone();

327
328
329
330
331
332
333
334
335
        // Use the DRT's runtime handle to spawn the background task.
        // We cannot use regular `tokio::spawn` here because:
        // 1. This method may be called from contexts without an active Tokio runtime
        //    (e.g., tests that create a DRT in a blocking context)
        // 2. Tests often create a temporary runtime just to build the DRT, then drop it
        // 3. `tokio::spawn` requires being called from within a runtime context
        // By using the DRT's own runtime handle, we ensure the task runs in the
        // correct runtime that will persist for the lifetime of the component.
        c.drt().runtime().secondary().spawn(async move {
336
337
            let timeout = std::time::Duration::from_millis(500);
            let mut interval = tokio::time::interval(MAX_WAIT_MS);
338
339
340
341
342
343
344
345
346
347
348
349
350
351
            interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);

            loop {
                match c.scrape_stats(timeout).await {
                    Ok(service_set) => {
                        m.update_from_service_set(&service_set);
                    }
                    Err(err) => {
                        tracing::error!(
                            "Background scrape failed for {}: {}",
                            c.service_name(),
                            err
                        );
                        m.reset_to_zeros();
352
353
                    }
                }
354

355
356
                interval.tick().await;
            }
357
358
359
360
361
        });

        Ok(())
    }

Graham King's avatar
Graham King committed
362
363
    /// TODO
    ///
Ryan Olson's avatar
Ryan Olson committed
364
    /// This method will scrape the stats for all available services
Graham King's avatar
Graham King committed
365
    /// Returns a stream of `ServiceInfo` objects.
Ryan Olson's avatar
Ryan Olson committed
366
367
368
369
370
371
372
373
374
375
376
377
    /// This should be consumed by a `[tokio::time::timeout_at`] because each services
    /// will only respond once, but there is no way to know when all services have responded.
    pub async fn stats_stream(&self) -> Result<()> {
        unimplemented!("collect_stats")
    }

    pub fn service_builder(&self) -> service::ServiceConfigBuilder {
        service::ServiceConfigBuilder::from_component(self.clone())
    }
}

impl ComponentBuilder {
378
    pub fn from_runtime(drt: Arc<DistributedRuntime>) -> Self {
Ryan Olson's avatar
Ryan Olson committed
379
380
381
382
383
384
385
386
387
388
389
        Self::default().drt(drt)
    }
}

#[derive(Debug, Clone)]
pub struct Endpoint {
    component: Component,

    // todo - restrict alphabet
    /// Endpoint name
    name: String,
390
391

    is_static: bool,
392
393
394

    /// Additional labels for metrics
    labels: Vec<(String, String)>,
Ryan Olson's avatar
Ryan Olson committed
395
396
}

397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
impl Hash for Endpoint {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        self.component.hash(state);
        self.name.hash(state);
        self.is_static.hash(state);
    }
}

impl PartialEq for Endpoint {
    fn eq(&self, other: &Self) -> bool {
        self.component == other.component
            && self.name == other.name
            && self.is_static == other.is_static
    }
}

impl Eq for Endpoint {}

415
416
417
418
419
420
421
422
423
424
425
426
impl DistributedRuntimeProvider for Endpoint {
    fn drt(&self) -> &DistributedRuntime {
        self.component.drt()
    }
}

impl RuntimeProvider for Endpoint {
    fn rt(&self) -> &Runtime {
        self.component.rt()
    }
}

427
428
429
430
431
432
433
434
435
436
437
438
439
440
impl MetricsRegistry for Endpoint {
    fn basename(&self) -> String {
        self.name.clone()
    }

    fn parent_hierarchy(&self) -> Vec<String> {
        [
            self.component.parent_hierarchy(),
            vec![self.component.basename()],
        ]
        .concat()
    }
}

Ryan Olson's avatar
Ryan Olson committed
441
impl Endpoint {
442
443
444
445
446
447
448
449
    pub fn id(&self) -> EndpointId {
        EndpointId {
            namespace: self.component.namespace().name().to_string(),
            component: self.component.name().to_string(),
            name: self.name().to_string(),
        }
    }

Ryan Olson's avatar
Ryan Olson committed
450
451
452
453
    pub fn name(&self) -> &str {
        &self.name
    }

454
455
456
457
    pub fn component(&self) -> &Component {
        &self.component
    }

458
    // todo(ryan): deprecate this as we move to Discovery traits and Component Identifiers
459
    pub fn path(&self) -> String {
460
461
462
463
464
465
        format!(
            "{}/{}/{}",
            self.component.path(),
            ENDPOINT_KEYWORD,
            self.name
        )
466
467
    }

468
469
    /// The endpoint part of an instance path in etcd
    pub fn etcd_root(&self) -> String {
470
        let component_path = self.component.instance_root();
471
472
        let endpoint_name = &self.name;
        format!("{component_path}/{endpoint_name}")
Ryan Olson's avatar
Ryan Olson committed
473
474
    }

475
476
477
478
    /// The endpoint as an EtcdPath object
    pub fn etcd_path(&self) -> EtcdPath {
        EtcdPath::new_endpoint(
            &self.component.namespace().name(),
479
            self.component.name(),
480
481
482
483
484
            &self.name,
        )
        .expect("Endpoint name and component name should be valid")
    }

485
    /// The fully path of an instance in etcd
486
    pub fn etcd_path_with_lease_id(&self, lease_id: i64) -> String {
487
488
489
490
491
492
493
494
495
        format!("{INSTANCE_ROOT_PATH}/{}", self.unique_path(lease_id))
    }

    /// Full path of this endpoint with forward slash separators, including lease id
    pub fn unique_path(&self, lease_id: i64) -> String {
        let ns = self.component.namespace().name();
        let cp = self.component.name();
        let ep = self.name();
        format!("{ns}/{cp}/{ep}/{lease_id:x}")
Ryan Olson's avatar
Ryan Olson committed
496
497
    }

498
499
500
501
502
503
504
    /// The endpoint as an EtcdPath object with lease ID
    pub fn etcd_path_object_with_lease_id(&self, lease_id: i64) -> EtcdPath {
        if self.is_static {
            self.etcd_path()
        } else {
            EtcdPath::new_endpoint_with_lease(
                &self.component.namespace().name(),
505
                self.component.name(),
506
507
508
509
510
511
512
                &self.name,
                lease_id,
            )
            .expect("Endpoint name and component name should be valid")
        }
    }

Ryan Olson's avatar
Ryan Olson committed
513
    pub fn name_with_id(&self, lease_id: i64) -> String {
514
515
516
517
518
        if self.is_static {
            self.name.clone()
        } else {
            format!("{}-{:x}", self.name, lease_id)
        }
Ryan Olson's avatar
Ryan Olson committed
519
520
    }

Ryan Olson's avatar
Ryan Olson committed
521
522
523
524
525
526
527
528
529
530
531
    pub fn subject(&self) -> String {
        format!("{}.{}", self.component.service_name(), self.name)
    }

    /// Subject to an instance of the [Endpoint] with a specific lease id
    pub fn subject_to(&self, lease_id: i64) -> String {
        format!(
            "{}.{}",
            self.component.service_name(),
            self.name_with_id(lease_id)
        )
Ryan Olson's avatar
Ryan Olson committed
532
533
    }

534
    pub async fn client(&self) -> Result<client::Client> {
535
536
537
538
539
        if self.is_static {
            client::Client::new_static(self.clone()).await
        } else {
            client::Client::new_dynamic(self.clone()).await
        }
Ryan Olson's avatar
Ryan Olson committed
540
541
542
543
544
545
546
    }

    pub fn endpoint_builder(&self) -> endpoint::EndpointConfigBuilder {
        endpoint::EndpointConfigBuilder::from_endpoint(self.clone())
    }
}

547
#[derive(Builder, Clone, Validate)]
Ryan Olson's avatar
Ryan Olson committed
548
549
550
#[builder(pattern = "owned")]
pub struct Namespace {
    #[builder(private)]
551
    runtime: Arc<DistributedRuntime>,
Ryan Olson's avatar
Ryan Olson committed
552

553
    #[validate(custom(function = "validate_allowed_chars"))]
Ryan Olson's avatar
Ryan Olson committed
554
    name: String,
555
556

    is_static: bool,
557
558
559

    #[builder(default = "None")]
    parent: Option<Arc<Namespace>>,
560
561
562
563

    /// Additional labels for metrics
    #[builder(default = "Vec::new()")]
    labels: Vec<(String, String)>,
Ryan Olson's avatar
Ryan Olson committed
564
565
}

566
567
568
569
570
571
impl DistributedRuntimeProvider for Namespace {
    fn drt(&self) -> &DistributedRuntime {
        &self.runtime
    }
}

572
573
574
575
576
577
578
579
580
581
impl std::fmt::Debug for Namespace {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "Namespace {{ name: {}; is_static: {}; parent: {:?} }}",
            self.name, self.is_static, self.parent
        )
    }
}

582
583
584
585
586
587
impl RuntimeProvider for Namespace {
    fn rt(&self) -> &Runtime {
        self.runtime.rt()
    }
}

588
589
590
591
592
593
impl std::fmt::Display for Namespace {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name)
    }
}

Ryan Olson's avatar
Ryan Olson committed
594
impl Namespace {
595
    pub(crate) fn new(runtime: DistributedRuntime, name: String, is_static: bool) -> Result<Self> {
Ryan Olson's avatar
Ryan Olson committed
596
        Ok(NamespaceBuilder::default()
597
            .runtime(Arc::new(runtime))
Ryan Olson's avatar
Ryan Olson committed
598
            .name(name)
599
            .is_static(is_static)
Ryan Olson's avatar
Ryan Olson committed
600
601
602
            .build()?)
    }

603
    /// Create a [`Component`] in the namespace who's endpoints can be discovered with etcd
Ryan Olson's avatar
Ryan Olson committed
604
    pub fn component(&self, name: impl Into<String>) -> Result<Component> {
605
        Ok(ComponentBuilder::from_runtime(self.runtime.clone())
Ryan Olson's avatar
Ryan Olson committed
606
            .name(name)
607
            .namespace(self.clone())
608
            .is_static(self.is_static)
609
            .build()?)
Ryan Olson's avatar
Ryan Olson committed
610
    }
Ryan Olson's avatar
Ryan Olson committed
611

612
613
614
615
616
617
618
619
620
621
622
    /// Create a [`Namespace`] in the parent namespace
    pub fn namespace(&self, name: impl Into<String>) -> Result<Namespace> {
        Ok(NamespaceBuilder::default()
            .runtime(self.runtime.clone())
            .name(name.into())
            .is_static(self.is_static)
            .parent(Some(Arc::new(self.clone())))
            .build()?)
    }

    pub fn etcd_path(&self) -> String {
623
        format!("{ETCD_ROOT_PATH}{}", self.name())
624
625
626
627
628
629
630
    }

    pub fn name(&self) -> String {
        match &self.parent {
            Some(parent) => format!("{}.{}", parent.name(), self.name),
            None => self.name.clone(),
        }
Ryan Olson's avatar
Ryan Olson committed
631
    }
Ryan Olson's avatar
Ryan Olson committed
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
}

// Custom validator function
fn validate_allowed_chars(input: &str) -> Result<(), ValidationError> {
    // Define the allowed character set using a regex
    let regex = regex::Regex::new(r"^[a-z0-9-_]+$").unwrap();

    if regex.is_match(input) {
        Ok(())
    } else {
        Err(ValidationError::new("invalid_characters"))
    }
}

// TODO - enable restrictions to the character sets allowed for namespaces,
// components, and endpoints.
//
// Put Validate traits on the struct and use the `validate_allowed_chars` method
// to validate the fields.

// #[cfg(test)]
// mod tests {
//     use super::*;
//     use validator::Validate;

//     #[test]
//     fn test_valid_names() {
//         // Valid strings
//         let valid_inputs = vec![
//             "abc",        // Lowercase letters
//             "abc123",     // Letters and numbers
//             "a-b-c",      // Letters with hyphens
//             "a_b_c",      // Letters with underscores
//             "a-b_c-123",  // Mixed valid characters
//             "a",          // Single character
//             "a_b",        // Short valid pattern
//             "123456",     // Only numbers
//             "a---b_c123", // Repeated hyphens/underscores
//         ];

//         for input in valid_inputs {
//             let result = validate_allowed_chars(input);
//             assert!(result.is_ok(), "Expected '{}' to be valid", input);
//         }
//     }

//     #[test]
//     fn test_invalid_names() {
//         // Invalid strings
//         let invalid_inputs = vec![
//             "abc!",     // Invalid character `!`
//             "abc@",     // Invalid character `@`
//             "123$",     // Invalid character `$`
//             "foo.bar",  // Invalid character `.`
//             "foo/bar",  // Invalid character `/`
//             "foo\\bar", // Invalid character `\`
//             "abc#",     // Invalid character `#`
//             "abc def",  // Spaces are not allowed
//             "foo,",     // Invalid character `,`
//             "",         // Empty string
//         ];

//         for input in invalid_inputs {
//             let result = validate_allowed_chars(input);
//             assert!(result.is_err(), "Expected '{}' to be invalid", input);
//         }
//     }

//     // #[test]
//     // fn test_struct_validation_valid() {
//     //     // Struct with valid data
//     //     let valid_data = InputData {
//     //         name: "valid-name_123".to_string(),
//     //     };
//     //     assert!(valid_data.validate().is_ok());
//     // }

//     // #[test]
//     // fn test_struct_validation_invalid() {
//     //     // Struct with invalid data
//     //     let invalid_data = InputData {
//     //         name: "invalid!name".to_string(),
//     //     };
//     //     let result = invalid_data.validate();
//     //     assert!(result.is_err());

//     //     if let Err(errors) = result {
//     //         let error_map = errors.field_errors();
//     //         assert!(error_map.contains_key("name"));
//     //         let name_errors = &error_map["name"];
//     //         assert_eq!(name_errors[0].code, "invalid_characters");
//     //     }
//     // }

//     #[test]
//     fn test_edge_cases() {
//         // Edge cases
//         let edge_inputs = vec![
//             ("-", true),   // Single hyphen
//             ("_", true),   // Single underscore
//             ("a-", true),  // Letter with hyphen
//             ("-", false),  // Repeated hyphens
//             ("-a", false), // Hyphen at the beginning
//             ("a-", false), // Hyphen at the end
//         ];

//         for (input, expected_validity) in edge_inputs {
//             let result = validate_allowed_chars(input);
//             if expected_validity {
//                 assert!(result.is_ok(), "Expected '{}' to be valid", input);
//             } else {
//                 assert!(result.is_err(), "Expected '{}' to be invalid", input);
//             }
//         }
//     }
// }