restapi 1.1.14

A secure-by-default rest api using hyper, tokio, bb8, kafka-threadpool, postgres, and prometheus for monitoring
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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

//! The CoreServices struct implements the hyper trait:
//! https://docs.rs/hyper/latest/hyper/service/trait.Service.html#
//! for serving HTTP traffic with a customized struct containing:
//! - the static server configuration (``config`` member)
//! - the bb8 postgres db threadpool (``db_pool`` member)
//! - the kafka publisher threadpool (``kafka_pool`` member)
//! - server tls information (``tls_info`` member)
//! - tracking fields for local and remote addresses
//!
use std::convert::Infallible;
use std::future::Future;
use std::pin::Pin;
use std::task::Context;
use std::task::Poll;

use postgres_native_tls::MakeTlsConnector;

use bb8::Pool;
use bb8_postgres::PostgresConnectionManager;

use hyper::service::Service;
use hyper::Body;
use hyper::Request;
use hyper::Response;

use kafka_threadpool::kafka_publisher::KafkaPublisher;

use crate::core::core_config::CoreConfig;
use crate::core::server::core_http_request::CoreHttpRequest;
use crate::handle_request::handle_request;

use crate::tls::tls_info::TlsInfo;

/// CoreServices
///
/// A date type containing the
/// hyper [`Request`](hyper::Request)
/// with the
/// [`CoreConfig`](crate::core::core_config::CoreConfig)
/// server statics,
/// tls information, kafka threadpool
/// [`KafkaPublisher`](kafka_threadpool::kafka_publisher::KafkaPublisher),
/// and postgres client db threadpool
/// ([`Pool`](bb8::Pool))
///
/// ## Core Config
///
/// [`CoreConfig`](crate::core::core_config::CoreConfig)
/// for static configuration values
///
/// ## bb8 Postgres Threadpool
///
/// bb8 thread pool ([`Pool`](bb8::Pool)) containing a
/// [`PostgresConnectionManager`](bb8_postgres::PostgresConnectionManager)
/// client that encrypts the traffic with a
/// [`MakeTlsConnector`](postgres_native_tls::MakeTlsConnector)
/// for db client tls encryption
///
/// ## Kafka Threadpool
///
/// The ``kafka_pool`` (
/// [`KafkaPublisher`](kafka_threadpool::kafka_publisher::KafkaPublisher))
/// supports HTTP requests that need to publish messages to the
/// environment variable-configured kafka cluster.
///
/// ## Socket Data
///
/// `local_addr` - server address
/// `remote_addr` - client address
///
/// ## TLS Info
///
/// [`TlsInfo`](crate::tls::tls_info::TlsInfo) object for tls verification
/// (this is not optional with the default configuration).
///
#[derive(Clone)]
pub struct CoreServices {
    pub config: CoreConfig,
    pub db_pool: Pool<PostgresConnectionManager<MakeTlsConnector>>,
    pub kafka_pool: KafkaPublisher,
    pub local_addr: std::net::SocketAddr,
    pub remote_addr: std::net::SocketAddr,
    pub tls_info: Option<TlsInfo>,
}

// Trait for hyper [`Service`](hyper::service::Service)
// <https://docs.rs/hyper/latest/hyper/service/trait.Service.html#>
impl Service<Request<Body>> for CoreServices {
    type Response = Response<Body>;
    type Error = Infallible;
    type Future = Pin<
        Box<
            dyn Future<
                    Output = std::result::Result<Self::Response, Self::Error>,
                > + Send,
        >,
    >;

    /// poll_ready
    ///
    /// please refer to the hyper docs:
    /// [`poll_ready`](hyper::service::Service::poll_ready)
    /// <https://docs.rs/hyper/latest/hyper/service/trait.Service.html#tymethod.poll_ready>
    ///
    /// # Arguments
    ///
    /// * `_cx` - [`Context`](std::task::Context)
    ///
    fn poll_ready(
        &mut self,
        _cx: &mut Context<'_>,
    ) -> Poll<std::result::Result<(), Self::Error>> {
        Poll::Ready(Ok(()))
    }

    /// call
    ///
    /// Wrap a received hyper [`Request`](hyper::Request) from
    /// the api server in a
    /// [`CoreHttpRequest`](crate::core::server::core_http_request::CoreHttpRequest)
    /// object and consume the
    /// [`CoreHttpRequest`](crate::core::server::core_http_request::CoreHttpRequest)
    /// with the
    /// [`handle_request`](crate::handle_request::handle_request)
    /// function
    ///
    /// Please refer to the hyper docs:
    /// [`call`](hyper::service::Service::call)
    /// <https://docs.rs/hyper/latest/hyper/service/trait.Service.html#tymethod.call>
    ///
    /// # Arguments
    ///
    /// * `req` - a Hyper [`Request`](hyper::Request)
    ///
    fn call(&mut self, req: Request<Body>) -> Self::Future {
        // build a task item containing everything
        // a request needs
        let data = CoreHttpRequest {
            config: self.config.clone(),
            db_pool: self.db_pool.clone(),
            kafka_pool: self.kafka_pool.clone(),
            local_addr: self.local_addr,
            remote_addr: self.remote_addr,
            tls_info: self.tls_info.clone(),
            request: req,
            response: Response::new("".into()),
        };
        // handle request
        Box::pin(handle_request(data))
    }
}