kong_rs 0.2.0

Plugin Development Kit for developing Kong plugins 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

use kong_rs_protos::{AuthenticateArgs, AuthenticatedCredential, Consumer, ConsumerSpec};
use strum::{EnumString, IntoStaticStr};

use crate::{stream::Stream, KongResult};


#[derive(Debug, PartialEq, IntoStaticStr, EnumString)]
pub(crate) enum Methods {
  #[strum(serialize = "kong.client.get_ip")]
  GetIp,
  #[strum(serialize = "kong.client.get_forwarded_ip")]
  GetForwardedIp,
  #[strum(serialize = "kong.client.get_port")]
  GetPort,
  #[strum(serialize = "kong.client.get_forwarded_port")]
  GetForwardedPort,
  #[strum(serialize = "kong.client.get_credential")]
  GetCredential,
  #[strum(serialize = "kong.client.load_consumer")]
  LoadConsumer,
  #[strum(serialize = "kong.client.get_consumer")]
  GetConsumer,
  #[strum(serialize = "kong.client.authenticate")]
  Authenticate,
  #[strum(serialize = "kong.client.get_protocol")]
  GetProtocol,
}

#[derive(Clone)]
pub struct ClientPDK {
  stream: Stream
}

impl ClientPDK {
  pub fn new(stream: Stream) -> Self {
    Self { stream }
  }

  pub async fn get_ip(&self) -> KongResult<String> {
    self.stream.ask_string(Methods::GetIp.into()).await
  }

  pub async fn get_forwarded_ip(&self) -> KongResult<String> {
    self.stream.ask_string(Methods::GetForwardedIp.into()).await
  }

  pub async fn get_port(&self) -> KongResult<usize> {
    self.stream.ask_int(Methods::GetPort.into()).await.map(|port| port as usize)
  }

  pub async fn get_forwarded_port(&self) -> KongResult<usize> {
    self.stream.ask_int(Methods::GetForwardedPort.into()).await.map(|port| port as usize)
  }

  pub async fn get_credential(&self) -> KongResult<AuthenticatedCredential> {
    self.stream.ask_message(Methods::GetCredential.into()).await
  }

  pub async fn load_consumer(&self, consumer: ConsumerSpec) -> KongResult<Consumer> {
    self.stream.ask_message_with_args(Methods::LoadConsumer.into(), &consumer).await
  }

  pub async fn get_consumer(&self) -> KongResult<Consumer> {
    self.stream.ask_message(Methods::GetConsumer.into()).await
  }

  pub async fn authenticate(&self, auth: AuthenticateArgs) -> KongResult<()> {
    self.stream.ask(Methods::Authenticate.into(), &auth).await
  }

  pub async fn get_protocol(&self, allow_terminated: bool) -> KongResult<String> {
    self.stream.ask_string_with_args(Methods::GetProtocol.into(), &kong_rs_protos::Bool { v: allow_terminated }).await
  }
}