1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

//! This module holds schema defintions for Deploy configurations and other types.

mod app;
mod capability;
mod cpu;
mod deployment;
mod entity;
mod fs;
mod http_router;
mod logging;
mod memory;
mod network;
mod network_dns;
mod network_gateway;
mod tokens;
mod wasi;
mod webc;
mod workload;

pub use self::{
    app::*, capability::*, cpu::*, deployment::*, entity::*, fs::*, http_router::*, logging::*,
    memory::*, network::*, network_dns::*, network_gateway::*, tokens::*, wasi::*, webc::*,
    workload::*,
};

/// Extend values with defaults.
pub trait Merge {
    /// Extend `self` with values provided by `other`.
    ///
    /// Values on `self` should take precedence over `other`.
    fn merge_extend(self, other: &Self) -> Self;
}

impl<T> Merge for Option<T>
where
    T: Merge + Clone,
{
    fn merge_extend(self, other: &Self) -> Self {
        match (self, other) {
            (Some(s), Some(o)) => Some(s.merge_extend(o)),
            (None, Some(o)) => Some(o.clone()),
            (Some(s), None) => Some(s),
            (None, None) => None,
        }
    }
}

impl<T> Merge for Vec<T>
where
    T: Merge + PartialEq + Eq + Clone,
{
    fn merge_extend(mut self, other: &Self) -> Self {
        for o in other {
            if !self.contains(o) {
                self.push(o.clone());
            }
        }
        self
    }
}

macro_rules! impl_merge_primitive {
    ( $( $type:ty )* ) => {
        $(
            impl Merge for $type {
                fn merge_extend(self, _other: &Self) -> Self {
                    self
                }
            }
        )*
    };
}

impl_merge_primitive!(bool u32 String uuid::Uuid bytesize::ByteSize);

/// Deserialize JSON to a given type using serde-path-to-error.
///
/// This provides better error locations on parsing failures.
pub fn deserialize_json<T>(
    input: &[u8],
) -> Result<T, serde_path_to_error::Error<serde_json::error::Error>>
where
    T: serde::de::DeserializeOwned,
{
    let jd = &mut serde_json::Deserializer::from_slice(input);
    serde_path_to_error::deserialize(jd)
}

#[derive(
    serde::Serialize, serde::Deserialize, PartialEq, Eq, Clone, Debug, schemars::JsonSchema,
)]
#[serde(tag = "kind")]
pub enum AnyEntity {
    #[serde(rename = "wasmer.io/App.v1")]
    AppV1(AppV1),
    #[serde(rename = "wasmer.io/HttpRouter.v1")]
    HttpRouterV1(HttpRouterV1),
}