praxis-proxy-core 0.7.5

Configuration, error types, and server factory for Praxis
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

// SPDX-License-Identifier: Apache-2.0
// Copyright (c) 2026 Praxis Contributors

//! The stand-in connector for a build with no network backend.
//!
//! Library consumers can compile the Praxis crates without selecting a
//! backend (the lean-build checks do), and every type that defaults to the
//! build's connector still needs one to name. This one refuses every
//! connection and can never hand out a session.

use std::time::Duration;

use bytes::Bytes;

use super::{Completion, Connector, EgressError, PeerSpec, RequestHead, ResponseHead, Session};

// -----------------------------------------------------------------------------
// Unavailable
// -----------------------------------------------------------------------------

/// Connector for a build that carries no network backend; every connect fails.
#[derive(Clone, Copy, Debug, Default)]
pub struct Unavailable;

impl Connector for Unavailable {
    type Session = UnavailableSession;

    fn new(keepalive_pool_size: usize) -> Self {
        _ = keepalive_pool_size;
        Self
    }

    async fn connect(&self, peer: &PeerSpec, timeout: Duration) -> Result<UnavailableSession, EgressError> {
        _ = (peer, timeout);
        Err(EgressError::Unavailable)
    }

    async fn release(&self, session: UnavailableSession, keepalive: bool) {
        _ = keepalive;
        match session {}
    }
}

// -----------------------------------------------------------------------------
// UnavailableSession
// -----------------------------------------------------------------------------

/// A session that cannot exist: [`Unavailable`] never opens one.
#[derive(Debug)]
pub enum UnavailableSession {}

impl Session for UnavailableSession {
    fn reused(&self) -> bool {
        match *self {}
    }

    async fn send_request_head(&mut self, head: RequestHead) -> Result<(), EgressError> {
        drop(head);
        match *self {}
    }

    async fn send_request_body(&mut self, chunk: Bytes, end_of_stream: bool) -> Result<(), EgressError> {
        drop((chunk, end_of_stream));
        match *self {}
    }

    async fn finish_request(&mut self) -> Result<(), EgressError> {
        match *self {}
    }

    async fn read_response_head(&mut self) -> Result<(), EgressError> {
        match *self {}
    }

    fn response_head(&self) -> Result<ResponseHead<'_>, EgressError> {
        match *self {}
    }

    fn response_done(&mut self) -> bool {
        match *self {}
    }

    async fn read_response_body(&mut self) -> Result<Option<Bytes>, EgressError> {
        match *self {}
    }

    fn completion(&mut self) -> Result<Completion, EgressError> {
        match *self {}
    }

    fn clear_read_timeout(&mut self) {
        match *self {}
    }

    async fn shutdown(&mut self) {
        match *self {}
    }
}

// -----------------------------------------------------------------------------
// Tests
// -----------------------------------------------------------------------------

#[cfg(test)]
#[expect(clippy::allow_attributes, reason = "blanket test suppressions")]
#[allow(clippy::unwrap_used, clippy::expect_used, reason = "tests")]
mod tests {
    use super::*;

    #[tokio::test]
    async fn unavailable_refuses_every_connection() {
        let connector = Unavailable::new(8);
        let peer = PeerSpec::plain("127.0.0.1:9".parse().unwrap());

        let err = connector
            .connect(&peer, Duration::from_secs(1))
            .await
            .expect_err("an unavailable backend never connects");

        assert!(
            matches!(err, EgressError::Unavailable),
            "the error must say no backend is compiled in"
        );
    }
}