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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use std::sync::atomic::{AtomicUsize, Ordering};

use actix::Message;
use serde::de::DeserializeOwned;
use serde::{Deserialize, Serialize};
use serde_json::Value;

use crate::proxy_error::ProxyResult;

static COUNT: AtomicUsize = AtomicUsize::new(1);

/// A serde (serializable/deserializable) message which contains a message id for resolving the
/// correct message pair
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct WrappedMessage<M>
where
    M: Clone,
{
    pub id: usize,
    pub message: M,
}

impl<M> WrappedMessage<M>
where
    M: Clone + Serialize + DeserializeOwned,
{
    /// Creates a new WrappedMessage from the given message and a newly generated message id
    pub fn new(message: M) -> Self {
        Self {
            message,
            id: COUNT.fetch_add(1, Ordering::Relaxed),
        }
    }

    /// Creates a new WrappedMessage with the given message and the message id of the already existing
    /// message
    pub fn answer<A>(&self, message: A) -> WrappedMessage<A>
    where
        A: Clone + Serialize + DeserializeOwned,
    {
        WrappedMessage {
            message,
            id: self.id,
        }
    }

    /// Converts the inner message into a more general `serde_json::Value`
    pub fn into_value(self) -> WrappedMessage<Value> {
        WrappedMessage::<Value>::identified(serde_json::to_value(self.message).unwrap(), self.id)
    }

    /// Converts the inner message into the specified message type
    pub fn into_specific<S>(self) -> ProxyResult<WrappedMessage<S>>
    where
        S: Clone + Serialize + DeserializeOwned,
    {
        let id = self.id;
        let message: S = serde_json::from_value::<S>(self.into_value().message)?;

        Ok(WrappedMessage::<S>::identified(message, id))
    }

    /// Returns the inner message object
    pub fn into_inner(self) -> M {
        self.message
    }

    /// Creates a new WrappedMessage with a given message and message id
    fn identified(message: M, id: usize) -> WrappedMessage<M> {
        Self { message, id }
    }
}

impl Message for WrappedMessage<ProxyRequest> {
    type Result = ();
}

impl Message for WrappedMessage<ProxyResponse> {
    type Result = ();
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ProxyRequest {
    pub method: String,
    pub url: String,
    pub origin: String,
    pub request_body: Value,
    pub username: String,
    pub password: String,
}

/// This struct contains the fields required from the client
#[derive(Serialize, Deserialize, Debug, Clone, Default)]
pub struct ProxyResponse {
    /// Contains a json value
    /// This value might be a `Value::String` if the content_type is not "application/json"
    pub response: Value,

    /// Contains the content for the `Content-Type` header
    /// if "application/json" the response is send as a true JSON object
    pub content_type: String,
}

pub struct WebsocketCommand(pub WebsocketSignal);

impl Message for WebsocketCommand {
    type Result = ();
}

pub enum WebsocketSignal {
    Close,
    CheckPing,
    Ping,
}