fips 1.0.1

A powerful mock server supported by a plugin system
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

// Type definitions for logging, implementation is left to the respective crates
use std::collections::HashMap;
use hyper::{Response, Request};
use std::sync::atomic::{AtomicU64, Ordering};
use once_cell::sync::Lazy;

// Global atomic counter for correlation IDs (simple, fast). Could be replaced by UUID if needed.
static CORRELATION_COUNTER: Lazy<AtomicU64> = Lazy::new(|| AtomicU64::new(1));

pub fn next_correlation_id() -> u64 {
    CORRELATION_COUNTER.fetch_add(1, Ordering::Relaxed)
}

#[derive(Debug, Clone)]
pub struct RequestInfo {
    pub request_type: String,
    pub method: String,
    pub uri: String,
    pub version: String,
    pub headers: HashMap<String, String>,
    pub correlation_id: u64,
}

impl RequestInfo {
    pub fn from_with_id<B>(request: &Request<B>, correlation_id: u64) -> RequestInfo {
        let method = String::from(request.method().as_str());
        let uri = request.uri().to_string();
        let version = format!("{:?}", request.version());
        let mut headers = HashMap::new();
        for (k, v) in request.headers() {
            headers.insert(
                String::from(k.as_str()),
                String::from(v.to_str().unwrap()),
            );
        }
        RequestInfo{
            request_type: String::from("placeholder"),
            method,
            uri,
            version,
            headers,
            correlation_id,
        }
    }
}

#[derive(Debug, Clone)]
pub struct ResponseInfo {
    pub response_type: String,
    pub status: String,
    pub version: String,
    pub headers: HashMap<String, String>,
    pub correlation_id: u64,
}

impl ResponseInfo {
    pub fn from_with_id<B>(response: &Response<B>, correlation_id: u64) -> ResponseInfo {
        let status = String::from(response.status().as_str());
        let version = format!("{:?}", response.version());
        let mut headers = HashMap::new();
        for (k, v) in response.headers() {
            headers.insert(
                String::from(k.as_str()),
                String::from(v.to_str().unwrap()),
            );
        }
        ResponseInfo{
            response_type: String::from("placeholder"),
            status,
            version,
            headers,
            correlation_id,
        }
    }
}

#[derive(Debug, Clone)]
pub enum LoggableType {
  IncomingRequestAtFfips(RequestInfo),
  OutGoingResponseFromFips(ResponseInfo),
  OutgoingRequestToServer(RequestInfo),
  IncomingResponseFromServer(ResponseInfo),
  Plain
}

pub struct Loggable {
  pub message_type: LoggableType,
  pub message: String,
}