Add cloudflare tunnel endpoints

cloudflare/src/endpoints/cfd_tunnel/create_tunnel.rs

@@ -45,8 +45,9 @@ pub struct Params<'a> {
     pub name: &'a str,
     /// The byte array (with 32 or more bytes) representing a secret for the tunnel. This is
     /// encoded into JSON as a base64 String. This secret is necessary to run the tunnel.
-    #[serde_as(as = "Base64<Standard, Padded>")]
-    pub tunnel_secret: &'a Vec<u8>,
+    #[serde_as(as = "Option<Base64<Standard, Padded>>")]
+    #[serde(default)]
+    pub tunnel_secret: Option<&'a [u8]>,
 
     pub config_src: &'a ConfigurationSrc,
 

cloudflare/src/endpoints/cfd_tunnel/data_structures.rs

@@ -1,9 +1,23 @@
+use crate::framework::response::ApiResult;
 use chrono::{offset::Utc, DateTime};
 use serde::{Deserialize, Serialize};
 use std::net::IpAddr;
 use uuid::Uuid;
 
-use crate::framework::response::ApiResult;
+#[derive(Deserialize, Serialize, Debug, Clone, PartialEq, Eq)]
+pub struct TunnelToken(String);
+
+impl From<String> for TunnelToken {
+    fn from(s: String) -> TunnelToken {
+        TunnelToken(s)
+    }
+}
+
+impl From<TunnelToken> for String {
+    fn from(s: TunnelToken) -> String {
+        s.0
+    }
+}
 
 /// A Cfd Tunnel
 /// This is a Cfd Tunnel that has been created. It can be used for routing and subsequent running.
@@ -68,8 +82,76 @@ pub struct ActiveConnection {
     pub client_version: String,
 }
 
+#[derive(Serialize, Deserialize, Eq, PartialEq, Debug, Clone, Hash)]
+#[serde(rename_all = "camelCase")]
+pub struct TunnelConfiguration {
+    pub ingress: Option<Vec<Ingress>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(default)]
+    pub origin_request: Option<OriginRequest>,
+    #[serde(rename = "warp-routing")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(default)]
+    pub warp_routing: Option<WarpRouting>,
+}
+
+#[derive(Serialize, Deserialize, Eq, PartialEq, Debug, Clone, Hash)]
+pub struct WarpRouting {
+    pub enabled: bool,
+}
+
+#[derive(Serialize, Deserialize, Eq, PartialEq, Debug, Clone, Hash)]
+#[serde(rename_all = "camelCase")]
+pub struct Ingress {
+    pub hostname: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "warp-routing")]
+    pub origin_request: Option<OriginRequest>,
+    pub path: Option<String>,
+    pub service: String,
+}
+
+#[derive(Serialize, Deserialize, Eq, PartialEq, Debug, Clone, Hash)]
+#[serde(rename_all = "camelCase")]
+pub struct OriginRequestAccress {
+    pub aud_tag: Vec<String>,
+    pub required: bool,
+    pub team_name: String,
+}
+
+#[derive(Serialize, Deserialize, Eq, PartialEq, Debug, Clone, Hash)]
+#[serde(rename_all = "camelCase")]
+pub struct OriginRequest {
+    pub access: Option<OriginRequestAccress>,
+    pub ca_pool: Option<String>,
+    pub connection_timeout: i32,
+    pub disable_chunked_encoding: bool,
+    pub http2origin: bool,
+    pub http_host_header: Option<String>,
+    pub keep_alive_connections: i32,
+    pub keep_alive_timeout: i32,
+    pub no_happy_eyeballs: bool,
+    pub no_tls_verify: bool,
+    pub origin_server_name: Option<String>,
+    pub proxy_type: Option<String>,
+    pub tcp_keep_alive: i32,
+    pub tls_timeout: i32,
+}
+
+impl ApiResult for TunnelConfiguration {}
 impl ApiResult for Tunnel {}
 impl ApiResult for Vec<Tunnel> {}
+impl ApiResult for TunnelToken {}
+
+#[derive(Deserialize, Serialize, Debug, Clone, PartialEq, Eq)]
+pub struct TunnelConfigurationResult {
+    pub account_id: Option<String>,
+    pub created_at: DateTime<Utc>,
+    pub config: Option<TunnelConfiguration>,
+    pub source: String,
+    pub tunnel_id: Uuid,
+    pub version: i32,
+}
 
 /// The result of a route request for a Cfd Tunnel
 #[derive(Deserialize, Serialize, Debug, Clone, PartialEq, Eq)]
@@ -100,4 +182,5 @@ pub enum Change {
     Updated,
 }
 
+impl ApiResult for TunnelConfigurationResult {}
 impl ApiResult for RouteResult {}

cloudflare/src/endpoints/cfd_tunnel/get_configuration.rs

@@ -0,0 +1,27 @@
+use crate::endpoints::cfd_tunnel::TunnelConfigurationResult;
+use crate::framework::endpoint::{EndpointSpec, Method};
+use uuid::Uuid;
+
+#[derive(Debug)]
+pub struct GetTunnelConfiguration<'a> {
+    pub account_identifier: &'a str,
+    pub tunnel_id: Uuid,
+}
+
+impl<'a> EndpointSpec<TunnelConfigurationResult> for GetTunnelConfiguration<'a> {
+    fn method(&self) -> Method {
+        Method::GET
+    }
+
+    fn path(&self) -> String {
+        format!(
+            "accounts/{}/cfd_tunnel/{}/configurations",
+            self.account_identifier, self.tunnel_id
+        )
+    }
+
+    #[inline]
+    fn body(&self) -> Option<String> {
+        None
+    }
+}

cloudflare/src/endpoints/cfd_tunnel/get_tunnel.rs

@@ -0,0 +1,28 @@
+use crate::endpoints::cfd_tunnel::Tunnel;
+use crate::framework::endpoint::{EndpointSpec, Method};
+
+/// Create a Cfd Tunnel
+/// This creates the Tunnel, which can then be routed and ran. Creating the Tunnel per se is only
+/// a metadata operation (i.e. no Tunnel is running at this point).
+/// <https://developers.cloudflare.com/api/operations/cloudflare-tunnel-create-a-cloudflare-tunnel>
+#[derive(Debug)]
+pub struct GetTunnel<'a> {
+    pub account_identifier: &'a str,
+    pub tunnel_id: &'a str,
+}
+
+impl<'a> EndpointSpec<Tunnel> for GetTunnel<'a> {
+    fn method(&self) -> Method {
+        Method::GET
+    }
+    fn path(&self) -> String {
+        format!(
+            "accounts/{}/cfd_tunnel/{}",
+            self.account_identifier, self.tunnel_id
+        )
+    }
+    #[inline]
+    fn body(&self) -> Option<String> {
+        None
+    }
+}

cloudflare/src/endpoints/cfd_tunnel/get_tunnel_token.rs

@@ -0,0 +1,26 @@
+use super::TunnelToken as TunnelTokenResult;
+use crate::framework::endpoint::{EndpointSpec, Method};
+
+/// Delete a tunnel
+/// <https://developers.cloudflare.com/api/operations/cloudflare-tunnel-delete-a-cloudflare-tunnel>
+#[derive(Debug)]
+pub struct TunnelToken<'a> {
+    pub account_identifier: &'a str,
+    pub tunnel_id: &'a str,
+}
+
+impl<'a> EndpointSpec<TunnelTokenResult> for TunnelToken<'a> {
+    fn method(&self) -> Method {
+        Method::GET
+    }
+    fn path(&self) -> String {
+        format!(
+            "accounts/{}/cfd_tunnel/{}/token",
+            self.account_identifier, self.tunnel_id
+        )
+    }
+    #[inline]
+    fn body(&self) -> Option<String> {
+        None
+    }
+}

cloudflare/src/endpoints/cfd_tunnel/mod.rs

@@ -1,8 +1,12 @@
 pub mod create_tunnel;
 mod data_structures;
 pub mod delete_tunnel;
+pub mod get_configuration;
+pub mod get_tunnel;
+pub mod get_tunnel_token;
 pub mod list_tunnels;
 pub mod route_dns;
+pub mod update_configuration;
 pub mod update_tunnel;
 
 pub use data_structures::*;

cloudflare/src/endpoints/cfd_tunnel/update_configuration.rs

@@ -0,0 +1,37 @@
+use crate::endpoints::cfd_tunnel::{TunnelConfiguration, TunnelConfigurationResult};
+use crate::framework::endpoint::{EndpointSpec, Method};
+use serde::Serialize;
+use serde_with::serde_as;
+use uuid::Uuid;
+
+#[derive(Debug)]
+pub struct UpdateTunnelConfiguration<'a> {
+    pub account_identifier: &'a str,
+    pub tunnel_id: Uuid,
+    pub params: Params,
+}
+
+impl<'a> EndpointSpec<TunnelConfigurationResult> for UpdateTunnelConfiguration<'a> {
+    fn method(&self) -> Method {
+        Method::PUT
+    }
+
+    fn path(&self) -> String {
+        format!(
+            "accounts/{}/cfd_tunnel/{}/configurations",
+            self.account_identifier, self.tunnel_id
+        )
+    }
+
+    #[inline]
+    fn body(&self) -> Option<String> {
+        Some(serde_json::to_string(&self.params).unwrap())
+    }
+}
+
+#[serde_as]
+#[serde_with::skip_serializing_none]
+#[derive(Serialize, Clone, Debug)]
+pub struct Params {
+    pub config: TunnelConfiguration,
+}