new-home-proxy 0.1.2

This is a part of the New Home IoT System. It is used to make the core available in the www.
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

use std::error::Error;
use std::fmt::{Debug, Display, Result};
use std::io;
use std::result;
use std::sync::mpsc::{RecvTimeoutError, SendError};

use serde::export::Formatter;

use crate::communication::ProxyResponse;

/// The basic result type filled with the `ProxyError`
pub type ProxyResult<T> = result::Result<T, ProxyError>;

/// This is the main error type inside the proxy.
/// This error can be create from all other errors (that are handled in the application)
pub struct ProxyError {
    message: String,
    debug: String,
}

impl ProxyError {
    pub fn new(message: String, debug: String) -> Self {
        Self { message, debug }
    }

    pub fn message(message: impl ToString) -> Self {
        Self {
            debug: message.to_string().clone(),
            message: message.to_string().clone(),
        }
    }
}

impl Error for ProxyError {}

impl Display for ProxyError {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> Result {
        formatter.write_str(&self.message)
    }
}

impl Debug for ProxyError {
    fn fmt(&self, formatter: &mut Formatter<'_>) -> Result {
        formatter.write_str(&self.debug)
    }
}

impl From<io::Error> for ProxyError {
    fn from(parent: io::Error) -> Self {
        Self {
            message: format!("{}", parent),
            debug: format!("{:?}", parent),
        }
    }
}

impl From<serde_json::error::Error> for ProxyError {
    fn from(parent: serde_json::error::Error) -> Self {
        Self {
            message: format!("{}", parent),
            debug: format!("{:?}", parent),
        }
    }
}

impl From<serde_yaml::Error> for ProxyError {
    fn from(parent: serde_yaml::Error) -> Self {
        Self {
            message: format!("{}", parent),
            debug: format!("{:?}", parent),
        }
    }
}

impl From<SendError<ProxyResponse>> for ProxyError {
    fn from(parent: SendError<ProxyResponse>) -> Self {
        Self {
            message: format!("{}", parent),
            debug: format!("{:?}", parent),
        }
    }
}
impl From<RecvTimeoutError> for ProxyError {
    fn from(parent: RecvTimeoutError) -> Self {
        Self {
            message: format!("{}", parent),
            debug: format!("{:?}", parent),
        }
    }
}