vrr/g3
2
0
Fork 0
mirror of https://github.com/bytedance/g3.git synced 2026-05-06 08:01:42 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

simplify code

Browse source
This commit is contained in:
Zhang Jingqiang 2023-09-11 16:24:36 +08:00
parent a981782761
commit 086b00a9be
16 changed files with 85 additions and 230 deletions
Download patch file Download diff file Expand all files Collapse all files

26
g3proxy/src/config/auth/site/yaml.rs
View file

@ -39,36 +39,24 @@ impl UserSiteConfig {
Ok(())
}
"exact_match" => {
if let Yaml::Array(seq) = v {
for (i, v) in seq.iter().enumerate() {
let host = g3_yaml::value::as_host(v)
.context(format!("invalid host value for {k}#{i}"))?;
self.add_exact_host(host);
}
} else {
let host = g3_yaml::value::as_host(v)
.context(format!("invalid host value(s) for key {k}"))?;
let hosts = g3_yaml::value::as_list(v, g3_yaml::value::as_host)
.context(format!("invalid host list value for key {k}"))?;
for host in hosts {
self.add_exact_host(host);
}
Ok(())
}
"subnet_match" => {
let nets = g3_yaml::foreach_maybe_list_v(v, g3_yaml::value::as_ip_network)?;
let nets = g3_yaml::value::as_list(v, g3_yaml::value::as_ip_network)?;
for net in nets {
self.subnet_match_ipaddr.insert(net);
}
Ok(())
}
"child_match" => {
if let Yaml::Array(seq) = v {
for (i, v) in seq.iter().enumerate() {
let domain = g3_yaml::value::as_domain(v)
.context(format!("invalid domain value for {k}#{i}"))?;
self.child_match_domain.insert(domain);
}
} else {
let domain = g3_yaml::value::as_domain(v)
.context(format!("invalid domain value(s) for key {k}"))?;
let domains = g3_yaml::value::as_list(v, g3_yaml::value::as_domain)
.context(format!("invalid domain list value for key {k}"))?;
for domain in domains {
self.child_match_domain.insert(domain);
}
Ok(())

24
g3proxy/src/config/escaper/direct_fixed.rs
View file

@ -15,7 +15,6 @@
*/
use std::net::IpAddr;
use std::str::FromStr;
use std::sync::Arc;
use anyhow::{anyhow, Context};
@ -108,20 +107,14 @@ impl DirectFixedEscaperConfig {
self.extra_metrics_tags = Some(Arc::new(tags));
Ok(())
}
"bind_ip" => match v {
Yaml::String(ip) => self.add_bind_address(ip),
Yaml::Array(seq) => {
for (i, ip) in seq.iter().enumerate() {
if let Yaml::String(ip) = ip {
self.add_bind_address(ip)?;
} else {
return Err(anyhow!("invalid string value for {k}#{i}"));
}
}
Ok(())
"bind_ip" => {
let ips = g3_yaml::value::as_list(v, g3_yaml::value::as_ipaddr)
.context(format!("invalid ip address list value for key {k}"))?;
for ip in ips {
self.add_bind_address(ip)?;
}
_ => Err(anyhow!("invalid value type for key {k}")),
},
Ok(())
}
"resolver" => {
self.resolver = g3_yaml::value::as_metrics_name(v)?;
Ok(())
@ -218,8 +211,7 @@ impl DirectFixedEscaperConfig {
Ok(())
}
fn add_bind_address(&mut self, ip: &str) -> anyhow::Result<()> {
let ip = IpAddr::from_str(ip)?;
fn add_bind_address(&mut self, ip: IpAddr) -> anyhow::Result<()> {
match ip {
IpAddr::V4(_) => self.bind4.push(ip),
IpAddr::V6(_) => self.bind6.push(ip),

27
g3proxy/src/config/escaper/proxy_float/source/redis_cluster.rs
View file

@ -14,7 +14,6 @@
* limitations under the License.
*/
use std::str::FromStr;
use std::time::Duration;
use anyhow::{anyhow, Context};
@ -69,20 +68,12 @@ impl ProxyFloatRedisClusterSource {
fn set(&mut self, k: &str, v: &Yaml) -> anyhow::Result<()> {
match g3_yaml::key::normalize(k).as_str() {
super::CONFIG_KEY_SOURCE_TYPE => Ok(()),
"initial_nodes" | "startup_nodes" => match v {
Yaml::String(addr) => self.add_initial_node(addr),
Yaml::Array(seq) => {
for (i, v) in seq.iter().enumerate() {
if let Yaml::String(addr) = v {
self.add_initial_node(addr)?;
} else {
return Err(anyhow!("invalid string value for {k}#{i}"));
}
}
Ok(())
}
_ => Err(anyhow!("invalid value type for key {k}")),
},
"initial_nodes" | "startup_nodes" => {
self.initial_nodes =
g3_yaml::value::as_list(v, |v| g3_yaml::value::as_upstream_addr(v, 0))
.context(format!("invalid upstream addr list value for key {k}"))?;
Ok(())
}
"username" => {
let username = g3_yaml::value::as_string(v)?;
self.username = Some(username);
@ -110,10 +101,4 @@ impl ProxyFloatRedisClusterSource {
_ => Err(anyhow!("invalid key {k}")),
}
}
fn add_initial_node(&mut self, addr: &str) -> anyhow::Result<()> {
let upstream = UpstreamAddr::from_str(addr)?;
self.initial_nodes.push(upstream);
Ok(())
}
}

20
g3proxy/src/config/escaper/proxy_http.rs
View file

@ -125,20 +125,12 @@ impl ProxyHttpEscaperConfig {
Ok(())
}
"proxy_addr" => {
match v {
Yaml::String(_) => {
let node = g3_yaml::value::as_weighted_upstream_addr(v, 3128)?;
self.proxy_nodes.push(node);
}
Yaml::Array(seq) => {
for (i, v) in seq.iter().enumerate() {
let node = g3_yaml::value::as_weighted_upstream_addr(v, 3128)
.context(format!("invalid value for {k}#{i}"))?;
self.proxy_nodes.push(node);
}
}
_ => return Err(anyhow!("invalid value type for key {k}")),
}
self.proxy_nodes = g3_yaml::value::as_list(v, |v| {
g3_yaml::value::as_weighted_upstream_addr(v, 3128)
})
.context(format!(
"invalid weighted upstream address list value for key {k}"
))?;
Ok(())
}
"proxy_addr_pick_policy" => {

20
g3proxy/src/config/escaper/proxy_https.rs
View file

@ -129,20 +129,12 @@ impl ProxyHttpsEscaperConfig {
Ok(())
}
"proxy_addr" => {
match v {
Yaml::String(_) => {
let node = g3_yaml::value::as_weighted_upstream_addr(v, 3128)?;
self.proxy_nodes.push(node);
}
Yaml::Array(seq) => {
for (i, v) in seq.iter().enumerate() {
let node = g3_yaml::value::as_weighted_upstream_addr(v, 3128)
.context(format!("invalid value for {k}#{i}"))?;
self.proxy_nodes.push(node);
}
}
_ => return Err(anyhow!("invalid value type for key {k}")),
}
self.proxy_nodes = g3_yaml::value::as_list(v, |v| {
g3_yaml::value::as_weighted_upstream_addr(v, 3128)
})
.context(format!(
"invalid weighted upstream address list value for key {k}"
))?;
Ok(())
}
"proxy_addr_pick_policy" => {

20
g3proxy/src/config/escaper/proxy_socks5.rs
View file

@ -122,20 +122,12 @@ impl ProxySocks5EscaperConfig {
Ok(())
}
"proxy_addr" => {
match v {
Yaml::String(_) => {
let node = g3_yaml::value::as_weighted_upstream_addr(v, 1080)?;
self.proxy_nodes.push(node);
}
Yaml::Array(seq) => {
for (i, v) in seq.iter().enumerate() {
let node = g3_yaml::value::as_weighted_upstream_addr(v, 1080)
.context(format!("invalid value for {k}#{i}"))?;
self.proxy_nodes.push(node);
}
}
_ => return Err(anyhow!("invalid value type for key {k}")),
}
self.proxy_nodes = g3_yaml::value::as_list(v, |v| {
g3_yaml::value::as_weighted_upstream_addr(v, 1080)
})
.context(format!(
"invalid weighted upstream address list value for key {k}"
))?;
Ok(())
}
"proxy_addr_pick_policy" => {

9
g3proxy/src/config/escaper/route_geoip.rs
View file

@ -155,14 +155,14 @@ impl RouteGeoIpEscaperConfig {
Ok(())
}
"net" | "network" | "networks" => {
let nets = g3_yaml::foreach_maybe_list_v(v, g3_yaml::value::as_ip_network)?;
let nets = g3_yaml::value::as_list(v, g3_yaml::value::as_ip_network)?;
for net in nets {
networks.insert(net);
}
Ok(())
}
"asn" | "as_number" | "as_numbers" => {
let all_as = g3_yaml::foreach_maybe_list_v(v, g3_yaml::value::as_u32)?;
let all_as = g3_yaml::value::as_list(v, g3_yaml::value::as_u32)?;
for asn in all_as {
asn_set.insert(asn);
}
@ -170,15 +170,14 @@ impl RouteGeoIpEscaperConfig {
}
"country" | "countries" => {
let all_countries =
g3_yaml::foreach_maybe_list_v(v, g3_yaml::value::as_iso_country_code)?;
g3_yaml::value::as_list(v, g3_yaml::value::as_iso_country_code)?;
for country in all_countries {
countries.insert(country);
}
Ok(())
}
"continent" | "continents" => {
let all_continents =
g3_yaml::foreach_maybe_list_v(v, g3_yaml::value::as_continent_code)?;
let all_continents = g3_yaml::value::as_list(v, g3_yaml::value::as_continent_code)?;
for continent in all_continents {
continents.insert(continent);
}

24
g3proxy/src/config/escaper/route_select.rs
View file

@ -64,23 +64,13 @@ impl RouteSelectEscaperConfig {
self.name = g3_yaml::value::as_metrics_name(v)?;
Ok(())
}
"next_nodes" => match v {
Yaml::String(_) => {
let item = g3_yaml::value::as_weighted_metrics_name(v)
.context(format!("invalid weighted metrics name value for key {k}"))?;
self.next_nodes.push(item);
Ok(())
}
Yaml::Array(seq) => {
for (i, v) in seq.iter().enumerate() {
let item = g3_yaml::value::as_weighted_metrics_name(v)
.context(format!("invalid weighted metrics name value for {k}#{i}"))?;
self.next_nodes.push(item);
}
Ok(())
}
_ => Err(anyhow!("invalid value type for key {k}")),
},
"next_nodes" => {
self.next_nodes =
g3_yaml::value::as_list(v, g3_yaml::value::as_weighted_metrics_name).context(
format!("invalid weighted metrics name list value for key {k}"),
)?;
Ok(())
}
"next_pick_policy" => {
self.next_pick_policy = g3_yaml::value::as_selective_pick_policy(v)
.context(format!("invalid selective pick policy value for key {k}"))?;

19
g3proxy/src/config/server/tcp_stream.rs
View file

@ -156,20 +156,11 @@ impl TcpStreamServerConfig {
Ok(())
}
"upstream" | "proxy_pass" => {
match v {
Yaml::String(_) => {
let node = g3_yaml::value::as_weighted_upstream_addr(v, 0)?;
self.upstream.push(node);
}
Yaml::Array(seq) => {
for (i, v) in seq.iter().enumerate() {
let node = g3_yaml::value::as_weighted_upstream_addr(v, 0)
.context(format!("invalid value for {k}#{i}"))?;
self.upstream.push(node);
}
}
_ => return Err(anyhow!("invalid value type for key {k}")),
}
self.upstream =
g3_yaml::value::as_list(v, |v| g3_yaml::value::as_weighted_upstream_addr(v, 0))
.context(format!(
"invalid weighted upstream address value for key {k}"
))?;
Ok(())
}
"upstream_pick_policy" => {

19
g3proxy/src/config/server/tls_stream.rs
View file

@ -165,20 +165,11 @@ impl TlsStreamServerConfig {
Ok(())
}
"upstream" | "proxy_pass" => {
match v {
Yaml::String(_) => {
let node = g3_yaml::value::as_weighted_upstream_addr(v, 0)?;
self.upstream.push(node);
}
Yaml::Array(seq) => {
for (i, v) in seq.iter().enumerate() {
let node = g3_yaml::value::as_weighted_upstream_addr(v, 0)
.context(format!("invalid value for {k}#{i}"))?;
self.upstream.push(node);
}
}
_ => return Err(anyhow!("invalid value type for key {k}")),
}
self.upstream =
g3_yaml::value::as_list(v, |v| g3_yaml::value::as_weighted_upstream_addr(v, 0))
.context(format!(
"invalid weighted upstream address list value for key {k}"
))?;
Ok(())
}
"upstream_pick_policy" => {

40
g3tiles/src/config/server/openssl_proxy/host.rs
View file

@ -258,39 +258,23 @@ impl YamlMapCallback for OpensslHostConfig {
}
"cert_pairs" => {
let lookup_dir = g3_daemon::config::get_lookup_dir(doc)?;
if let Yaml::Array(seq) = value {
for (i, v) in seq.iter().enumerate() {
let pair = g3_yaml::value::as_openssl_certificate_pair(v, Some(lookup_dir))
.context(format!("invalid openssl cert pair value for {key}#{i}"))?;
self.cert_pairs.push(pair);
}
} else {
let pair = g3_yaml::value::as_openssl_certificate_pair(value, Some(lookup_dir))
.context(format!("invalid openssl cert pair value for key {key}"))?;
self.cert_pairs.push(pair);
}
self.cert_pairs = g3_yaml::value::as_list(value, |v| {
g3_yaml::value::as_openssl_certificate_pair(v, Some(lookup_dir))
})
.context(format!(
"invalid openssl cert pair list value for key {key}"
))?;
Ok(())
}
#[cfg(feature = "vendored-tongsuo")]
"tlcp_cert_pairs" => {
let lookup_dir = g3_daemon::config::get_lookup_dir(doc)?;
if let Yaml::Array(seq) = value {
for (i, v) in seq.iter().enumerate() {
let pair =
g3_yaml::value::as_openssl_tlcp_certificate_pair(v, Some(lookup_dir))
.context(format!(
"invalid openssl tlcp cert pair value for {key}#{i}"
))?;
self.tlcp_cert_pairs.push(pair);
}
} else {
let pair =
g3_yaml::value::as_openssl_tlcp_certificate_pair(value, Some(lookup_dir))
.context(format!(
"invalid openssl tlcp cert pair value for key {key}"
))?;
self.tlcp_cert_pairs.push(pair);
}
self.tlcp_cert_pairs = g3_yaml::value::as_list(value, |v| {
g3_yaml::value::as_openssl_tlcp_certificate_pair(v, Some(lookup_dir))
})
.context(format!(
"invalid openssl tlcp cert pair list value for key {key}"
))?;
Ok(())
}
"enable_client_auth" => {

16
g3tiles/src/config/server/openssl_proxy/service.rs
View file

@ -50,18 +50,10 @@ impl YamlMapCallback for OpensslServiceConfig {
) -> anyhow::Result<()> {
match g3_yaml::key::normalize(key).as_str() {
"addrs" => {
if let Yaml::Array(seq) = value {
for (i, v) in seq.iter().enumerate() {
let addr = g3_yaml::value::as_weighted_sockaddr(v).context(format!(
"invalid weighted sockaddr string value for {key}#{i}"
))?;
self.addrs.push(addr);
}
} else {
let addr = g3_yaml::value::as_weighted_sockaddr(value)
.context(format!("invalid weighted sockaddr string value for {key}"))?;
self.addrs.push(addr);
}
self.addrs = g3_yaml::value::as_list(value, g3_yaml::value::as_weighted_sockaddr)
.context(format!(
"invalid weighted socket address list value for key {key}"
))?;
Ok(())
}
"pick_policy" => {

15
g3tiles/src/config/server/rustls_proxy/host.rs
View file

@ -135,17 +135,10 @@ impl YamlMapCallback for RustlsHostConfig {
}
"cert_pairs" => {
let lookup_dir = g3_daemon::config::get_lookup_dir(doc)?;
if let Yaml::Array(seq) = value {
for (i, v) in seq.iter().enumerate() {
let pair = g3_yaml::value::as_rustls_certificate_pair(v, Some(lookup_dir))
.context(format!("invalid rustls cert pair value for {key}#{i}"))?;
self.cert_pairs.push(pair);
}
} else {
let pair = g3_yaml::value::as_rustls_certificate_pair(value, Some(lookup_dir))
.context(format!("invalid rustls cert pair value for key {key}"))?;
self.cert_pairs.push(pair);
}
self.cert_pairs = g3_yaml::value::as_list(value, |v| {
g3_yaml::value::as_rustls_certificate_pair(v, Some(lookup_dir))
})
.context(format!("invalid rustls cert pair list value for key {key}"))?;
Ok(())
}
"enable_client_auth" => {

16
g3tiles/src/config/server/rustls_proxy/service.rs
View file

@ -50,18 +50,10 @@ impl YamlMapCallback for RustlsServiceConfig {
) -> anyhow::Result<()> {
match g3_yaml::key::normalize(key).as_str() {
"addrs" => {
if let Yaml::Array(seq) = value {
for (i, v) in seq.iter().enumerate() {
let addr = g3_yaml::value::as_weighted_sockaddr(v).context(format!(
"invalid weighted sockaddr string value for {key}#{i}"
))?;
self.addrs.push(addr);
}
} else {
let addr = g3_yaml::value::as_weighted_sockaddr(value)
.context(format!("invalid weighted sockaddr string value for {key}"))?;
self.addrs.push(addr);
}
self.addrs = g3_yaml::value::as_list(value, g3_yaml::value::as_weighted_sockaddr)
.context(format!(
"invalid weighted socket address list for key {key}"
))?;
Ok(())
}
"pick_policy" => {

17
lib/g3-yaml/src/hash.rs
View file

@ -31,23 +31,6 @@ where
Ok(())
}
pub fn foreach_maybe_list_v<F, T>(value: &Yaml, mut f: F) -> anyhow::Result<Vec<T>>
where
F: FnMut(&Yaml) -> anyhow::Result<T>,
{
if let Yaml::Array(seq) = value {
let mut list = Vec::new();
for (i, v) in seq.iter().enumerate() {
let r = f(v).context(format!("invalid value for array index #{i}"))?;
list.push(r);
}
Ok(list)
} else {
let r = f(value)?;
Ok(vec![r])
}
}
pub fn get_required<'a>(map: &'a yaml::Hash, k: &str) -> anyhow::Result<&'a Yaml> {
let key = Yaml::String(k.to_owned());
match map.get(&key) {

3
lib/g3-yaml/src/lib.rs
View file

@ -25,8 +25,7 @@ pub mod value;
pub use callback::YamlMapCallback;
pub use hash::{
foreach_kv, foreach_maybe_list_v, get_required as hash_get_required,
get_required_str as hash_get_required_str,
foreach_kv, get_required as hash_get_required, get_required_str as hash_get_required_str,
};
pub use hybrid::HybridParser;
pub use util::{foreach_doc, load_doc, YamlDocPosition};