proxy-sdk 1.1.0

Write extensions for Proxy-WASM for WASM or Native environments
Documentation 
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

use std::borrow::Cow;

use prost::Message;

use crate::upstream::Upstream;

use self::grpc_service::grpc_service::{
    google_grpc::{channel_credentials::CredentialSpecifier, ChannelCredentials, SslCredentials},
    EnvoyGrpc, GoogleGrpc, TargetSpecifier,
};

mod grpc_service {
    include!(concat!(env!("OUT_DIR"), "/envoy.config.core.v3.rs"));
}

impl<'a> Upstream<'a> {
    /// Creates an Envoy-compatible upstream configuration for the given upstream cluster name
    pub fn envoy_upstream(cluster_name: impl ToString, authority: impl ToString) -> Self {
        let cluster_name = cluster_name.to_string();
        let service = grpc_service::GrpcService {
            target_specifier: Some(TargetSpecifier::EnvoyGrpc(EnvoyGrpc {
                authority: authority.to_string(),
                cluster_name,
            })),
            ..Default::default()
        };
        Self(Cow::Owned(service.encode_to_vec()))
    }

    /// like grpc_upstream, but without TLS. used for testing purposes
    pub fn insecure_grpc_upstream(target_uri: impl ToString) -> Self {
        let service = grpc_service::GrpcService {
            target_specifier: Some(TargetSpecifier::GoogleGrpc(GoogleGrpc {
                target_uri: target_uri.to_string(),
                channel_credentials: None,
                call_credentials: vec![],
                channel_args: Default::default(),
                config: Default::default(),
                credentials_factory_name: String::new(),
                per_stream_buffer_limit_bytes: None,
                stat_prefix: "leaksignal_command".to_string(),
            })),
            ..Default::default()
        };
        Self(Cow::Owned(service.encode_to_vec()))
    }

    pub fn grpc_upstream(target_uri: impl ToString) -> Self {
        let target_uri = target_uri.to_string();
        let is_plaintext = target_uri.starts_with("http://");
        let target_uri = target_uri
            .strip_prefix(if is_plaintext { "http://" } else { "https://" })
            .unwrap_or(&*target_uri)
            .to_string();
        let service = grpc_service::GrpcService {
            target_specifier: Some(TargetSpecifier::GoogleGrpc(GoogleGrpc {
                channel_credentials: if is_plaintext {
                    None
                } else {
                    Some(ChannelCredentials {
                        credential_specifier: Some(CredentialSpecifier::SslCredentials(
                            SslCredentials {
                                root_certs: None,
                                private_key: None,
                                cert_chain: None,
                            },
                        )),
                    })
                },
                target_uri,
                call_credentials: vec![],
                channel_args: Default::default(),
                config: Default::default(),
                credentials_factory_name: String::new(),
                per_stream_buffer_limit_bytes: None,
                stat_prefix: "leaksignal_command".to_string(),
            })),
            ..Default::default()
        };
        Self(Cow::Owned(service.encode_to_vec()))
    }
}