frpc-lib 0.1.0

Library for Fluid RPC to dynamically invoke gRPC services
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

use std::error::Error;

use anyhow::Result;

use super::{reflection_loader_v1, reflection_loader_v1alpha};

#[derive(Debug)]
pub enum TryGetReflectionVersionResponse {
    DetectedVersion(ReflectionVersion),
    VersionUndetectable,
    ConnectionError { error: Box<dyn Error + Send + Sync> },
}

#[derive(Debug)]
pub enum ReflectionVersion {
    V1,
    V1Alpha,
}

pub(crate) async fn try_get_reflection_version(
    server_url: String,
) -> Result<TryGetReflectionVersionResponse> {
    let v1_implemented = reflection_loader_v1::check_implemented(server_url.clone()).await;

    match v1_implemented {
        Ok(true) => {
            return Ok(TryGetReflectionVersionResponse::DetectedVersion(
                ReflectionVersion::V1,
            ))
        }
        Ok(_) => {}
        Err(e) => {
            if let Some(transport) = &e.downcast_ref::<tonic::transport::Error>() {
                let source = transport.source();

                match source {
                    Some(source) => {
                        if source.is::<tonic::ConnectError>() {
                            return Ok(TryGetReflectionVersionResponse::ConnectionError {
                                error: e.into(),
                            });
                        }
                    }
                    None => {}
                };
            }
        }
    };

    let v1alpha_implemented = reflection_loader_v1alpha::check_implemented(server_url).await;

    match v1alpha_implemented {
        Ok(true) => {
            return Ok(TryGetReflectionVersionResponse::DetectedVersion(
                ReflectionVersion::V1Alpha,
            ))
        }
        Ok(_) => {}
        Err(e) => {
            if let Some(transport) = &e.downcast_ref::<tonic::transport::Error>() {
                let source = transport.source();

                match source {
                    Some(source) => {
                        if source.is::<tonic::ConnectError>() {
                            return Ok(TryGetReflectionVersionResponse::ConnectionError {
                                error: e.into(),
                            });
                        }
                    }
                    None => {}
                };
            }
        }
    };

    Ok(TryGetReflectionVersionResponse::VersionUndetectable)
}