dsh_sdk 0.8.1

SDK for KPN Data Services Hub
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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use log::trace;

use crate::Dsh;

use super::SchemaStoreError;

const DEFAULT_CONTENT_TYPE: &str = "application/vnd.schemaregistry.v1+json";

pub trait Request {
    fn new_client() -> Self;
    fn get_request<R>(
        &self,
        url: String,
    ) -> impl std::future::Future<Output = Result<R, SchemaStoreError>> + Send
    where
        R: serde::de::DeserializeOwned;
    fn get_request_plain(
        &self,
        url: String,
    ) -> impl std::future::Future<Output = Result<String, SchemaStoreError>> + Send;
    fn post_request<R, B>(
        &self,
        url: String,
        body: B,
    ) -> impl std::future::Future<Output = Result<R, SchemaStoreError>> + Send
    where
        R: serde::de::DeserializeOwned,
        B: serde::Serialize + Send;
    fn put_request<R, B>(
        &self,
        url: String,
        body: B,
    ) -> impl std::future::Future<Output = Result<R, SchemaStoreError>> + Send
    where
        R: serde::de::DeserializeOwned,
        B: serde::Serialize + Send;
}

impl Request for reqwest::Client {
    fn new_client() -> Self {
        // TODO: replace with hyper client (optional)
        Dsh::get()
            .reqwest_client_config()
            .build()
            .expect("Failed to build reqwest client")
    }
    async fn get_request<R>(&self, url: String) -> Result<R, SchemaStoreError>
    where
        R: serde::de::DeserializeOwned,
    {
        trace!("GET {}", url);
        let request = self
            .get(&url)
            .header("Content-Type", DEFAULT_CONTENT_TYPE)
            .header("Accept", DEFAULT_CONTENT_TYPE);
        let response = request.send().await?;
        trace!("Response: {:?}", response);
        if response.status().is_success() {
            Ok(response.json().await?)
        } else {
            Err(SchemaStoreError::InvalidStatusCode {
                status_code: response.status().as_u16(),
                url: url.to_string(),
                error: response.text().await.unwrap_or_default(),
            })
        }
    }

    async fn get_request_plain(&self, url: String) -> Result<String, SchemaStoreError> {
        trace!("GET {}", url);
        let request = self.get(&url);
        let response = request.send().await?;
        trace!("Response: {:?}", response);
        if response.status().is_success() {
            Ok(response.text().await?)
        } else {
            Err(SchemaStoreError::InvalidStatusCode {
                status_code: response.status().as_u16(),
                url: url.to_string(),
                error: response.text().await.unwrap_or_default(),
            })
        }
    }

    /// Helper function to send a POST request and return the response with the expected type (serde with as JSON)
    async fn post_request<R, B>(&self, url: String, body: B) -> Result<R, SchemaStoreError>
    where
        R: serde::de::DeserializeOwned,
        B: serde::Serialize + Send,
    {
        trace!("POST {}", url);
        let json_body = serde_json::to_vec(&body)?;
        let request = self
            .post(&url)
            .body(json_body)
            .header("Content-Type", DEFAULT_CONTENT_TYPE)
            .header("Accept", DEFAULT_CONTENT_TYPE);
        let response = request.send().await?;
        trace!("Response {:?}", response);
        if response.status().is_success() {
            Ok(response.json().await?)
        } else {
            Err(SchemaStoreError::InvalidStatusCode {
                status_code: response.status().as_u16(),
                url: url.to_string(),
                error: response.text().await.unwrap_or_default(),
            })
        }
    }

    /// Helper function to send a PUT request and return the response with the expected type (serde with as JSON)
    async fn put_request<R, B>(&self, url: String, body: B) -> Result<R, SchemaStoreError>
    where
        R: serde::de::DeserializeOwned,
        B: serde::Serialize + Send,
    {
        trace!("PUT {}", url);
        let json_body = serde_json::to_vec(&body)?;
        let request = self
            .put(&url)
            .body(json_body)
            .header("Content-Type", DEFAULT_CONTENT_TYPE)
            .header("Accept", DEFAULT_CONTENT_TYPE);
        let response = request.send().await?;
        trace!("Response {:?}", response);
        if response.status().is_success() {
            Ok(response.json().await?)
        } else {
            Err(SchemaStoreError::InvalidStatusCode {
                status_code: response.status().as_u16(),
                url: url.to_string(),
                error: response.text().await.unwrap_or_default(),
            })
        }
    }
}