tunnels 0.1.0

Dev Tunnels SDK
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

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT license.

use std::{error::Error, fmt::Display};

use reqwest::StatusCode;
use url::Url;

use crate::contracts::ProblemDetails;

/// Type of result returned from HTTP operations.
pub type HttpResult<R> = Result<R, HttpError>;

/// Type of error returned from HTTP operations.
#[derive(Debug)]
pub enum HttpError {
    /// An error during connection to the remote.
    ConnectionError(reqwest::Error),
    /// An error returned from the remote server.
    ResponseError(ResponseError),
    /// An error was returned from the authorization callback.
    AuthorizationError(String),
}

impl Error for HttpError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            HttpError::ConnectionError(e) => Some(e),
            _ => None,
        }
    }
}

impl Display for HttpError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            HttpError::ConnectionError(e) => write!(f, "connection error: {}", e),
            HttpError::ResponseError(e) => write!(f, "response error: {}", e),
            HttpError::AuthorizationError(e) => write!(f, "authorization error: {}", e),
        }
    }
}

/// Part of the `HttpError` returned from a non-successfl response.
#[derive(Debug)]
pub struct ResponseError {
    /// Original request URL.
    pub url: Url,
    /// Response status code
    pub status_code: StatusCode,
    /// Error contents of the response, if any
    pub data: Option<String>,
    /// Request ID for debugging purposes
    pub request_id: Option<String>,
}

impl ResponseError {
    /// Attempts to get service problem details, if available.
    pub fn get_details(&self) -> Option<ProblemDetails> {
        self.data
            .as_deref()
            .and_then(|d| serde_json::from_str(d).ok())
    }
}

impl Display for ResponseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "HTTP status {} from {} (request ID {}): {}",
            self.status_code,
            self.url,
            self.request_id.as_deref().unwrap_or("<none>"),
            self.data.as_deref().unwrap_or("(empty body)")
        )
    }
}