trz-gateway-client 0.2.0

Secure Proxy / Agents implementation in Rust
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

use tonic::Status;
use tonic::async_trait;
use tracing::info;
use trz_gateway_common::protos::terrazzo::remote::tests::Expression;
use trz_gateway_common::protos::terrazzo::remote::tests::Operator;
use trz_gateway_common::protos::terrazzo::remote::tests::Value;
use trz_gateway_common::protos::terrazzo::remote::tests::expression;
use trz_gateway_common::protos::terrazzo::remote::tests::test_tunnel_service_server::TestTunnelService;
use trz_gateway_common::protos::terrazzo::remote::tests::value;

pub struct Calculator;

#[async_trait]
impl TestTunnelService for Calculator {
    async fn calculate(
        &self,
        request: tonic::Request<Expression>,
    ) -> Result<tonic::Response<Value>, Status> {
        let expression = request.get_ref();
        let result = calculate_impl(expression);
        let result_str = match &result {
            Ok(result) => result.to_string(),
            Err(error) => error.to_string(),
        };
        info!("Calculate {expression} = {result_str}");
        result.map(tonic::Response::new)
    }
}

fn calculate_impl(request: &Expression) -> Result<Value, Status> {
    let result = match request
        .kind
        .as_ref()
        .ok_or_else(|| Status::invalid_argument("null"))?
    {
        expression::Kind::Operation(operation) => {
            let operands = [&operation.left, &operation.right]
                .map(Option::as_ref)
                .map(|e| e.ok_or_else(|| Status::invalid_argument("null operand")))
                .map(|e| e.map(|e| calculate_impl(e)));
            let [a, b] = operands;
            let operands = [a??, b??].map(|e| {
                e.kind
                    .ok_or_else(|| Status::invalid_argument("null result"))
            });
            let [a, b] = operands;
            let operands = (a?, b?);
            match operation.operator() {
                Operator::UndefinedOperand => {
                    return Err(Status::invalid_argument("null operator"));
                }
                Operator::Plus => match operands {
                    (value::Kind::I(a), value::Kind::I(b)) => (a + b).into(),
                    (value::Kind::I(a), value::Kind::F(b)) => (a as f64 + b).into(),
                    (value::Kind::F(a), value::Kind::I(b)) => (a + b as f64).into(),
                    (value::Kind::F(a), value::Kind::F(b)) => (a + b).into(),
                },
                Operator::Minus => match operands {
                    (value::Kind::I(a), value::Kind::I(b)) => (a - b).into(),
                    (value::Kind::I(a), value::Kind::F(b)) => (a as f64 - b).into(),
                    (value::Kind::F(a), value::Kind::I(b)) => (a - b as f64).into(),
                    (value::Kind::F(a), value::Kind::F(b)) => (a - b).into(),
                },
                Operator::Multiply => match operands {
                    (value::Kind::I(a), value::Kind::I(b)) => (a * b).into(),
                    (value::Kind::I(a), value::Kind::F(b)) => (a as f64 * b).into(),
                    (value::Kind::F(a), value::Kind::I(b)) => (a * b as f64).into(),
                    (value::Kind::F(a), value::Kind::F(b)) => (a * b).into(),
                },
                Operator::Divide => match operands {
                    (value::Kind::I(a), value::Kind::I(b)) => (a / b).into(),
                    (value::Kind::I(a), value::Kind::F(b)) => (a as f64 / b).into(),
                    (value::Kind::F(a), value::Kind::I(b)) => (a / b as f64).into(),
                    (value::Kind::F(a), value::Kind::F(b)) => (a / b).into(),
                },
            }
        }
        expression::Kind::Value(value) => *value,
    };
    Ok(result)
}