spacegate 0.2.0-alpha.1

A library-first, lightweight, high-performance, cloud-native supported API gateway
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use std::{path::PathBuf, str::FromStr};

use clap::Parser;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone)]
pub enum Config {
    #[cfg(feature = "fs")]
    File(PathBuf),
    #[cfg(feature = "k8s")]
    K8s(String),
    #[cfg(feature = "redis")]
    Redis(String),
}

impl FromStr for Config {
    type Err = String;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        if let Some((kind, resource)) = s.split_once(':') {
            match kind {
                "file" => {
                    #[cfg(feature = "fs")]
                    {
                        Ok(Config::File(PathBuf::from(resource)))
                    }
                    #[cfg(not(feature = "fs"))]
                    {
                        Err(format!("config backend kind {} not enabled, please select a correct build", kind))
                    }
                }
                #[cfg(feature = "k8s")]
                "k8s" => {
                    {
                        Ok(Config::K8s(resource.to_string()))
                    }
                    #[cfg(not(feature = "fs"))]
                    {
                        Err(format!("config backend kind {} not enabled, please select a correct build", kind))
                    }
                }
                #[cfg(feature = "redis")]
                "redis" => {
                    {
                        Ok(Config::Redis(resource.to_string()))
                    }
                    #[cfg(not(feature = "fs"))]
                    {
                        Err(format!("config backend kind {} not enabled, please select a correct build", kind))
                    }
                }
                _ => Err(format!("unknown config backend kind: {}", kind)),
            }
        } else {
            Err("missing config backend kind".to_string())
        }
    }
}

impl std::fmt::Display for Config {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            #[cfg(feature = "fs")]
            Config::File(path) => write!(f, "file:{}", path.display()),
            #[cfg(feature = "k8s")]
            Config::K8s(ns) => write!(f, "k8s:{}", ns),
            #[cfg(feature = "redis")]
            Config::Redis(url) => write!(f, "redis:{}", url),
        }
    }
}

impl Serialize for Config {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        self.to_string().serialize(serializer)
    }
}

impl<'de> Deserialize<'de> for Config {
    fn deserialize<D>(deserializer: D) -> Result<Config, D::Error>
    where
        D: serde::de::Deserializer<'de>,
    {
        let s = String::deserialize(deserializer)?;
        Config::from_str(&s).map_err(serde::de::Error::custom)
    }
}

/// Spacegate start up arguments
#[derive(Debug, Serialize, Deserialize, Clone, Parser)]
#[command(version, about, long_about = None)]
pub struct Args {
    /// The config file path
    ///
    /// # Example
    /// ## File
    /// `-c file:/path/to/dir`
    /// ## K8s
    /// `-c k8s:namespace`
    /// ## Redis
    /// `-c redis:redis://some-redis-url`
    #[arg(short, long, env)]
    #[cfg_attr(feature = "build-k8s", arg(default_value_t=Config::K8s(String::from("default"))))]
    #[cfg_attr(all(not(feature = "build-k8s"), target_family = "unix", feature="fs"), arg(default_value_t=Config::File(PathBuf::from("/etc/spacegate"))))]
    pub config: Config,
    /// The dynamic lib plugins dir
    ///
    /// # Example
    /// If you are using linux, you may put the plugins dll in `/lib/spacegate/plugins`.
    /// `-p /lib/spacegate/plugins`
    #[arg(short, long, env)]
    #[cfg_attr(target_family = "unix", arg(default_value = "/lib/spacegate/plugins"))]
    pub plugins: Option<PathBuf>,
}