vane 0.9.2

A flow-based reverse proxy with multi-layer routing and programmable pipelines.
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

/* src/layers/l4/tcp.rs */

use crate::engine::interfaces::{Layer, ProcessingStep};
use serde::{Deserialize, Serialize};
use validator::{Validate, ValidationErrors};

use super::legacy;

// --- New `connection` (Flow) Format ---

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
pub struct FlowConfig {
	// Cannot use #[validate(nested)] on HashMap
	pub connection: ProcessingStep,
}

impl Validate for FlowConfig {
	fn validate(&self) -> Result<(), ValidationErrors> {
		// Fix: Explicitly pass Layer::L4 context for validation
		super::validator::validate_flow_config(&self.connection, Layer::L4, "tcp")
	}
}

// --- Unified Configuration Enum ---

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
#[serde(untagged)]
pub enum TcpConfig {
	Flow(FlowConfig),
	Legacy(legacy::LegacyTcpConfig),
}

impl Validate for TcpConfig {
	fn validate(&self) -> Result<(), ValidationErrors> {
		match self {
			Self::Legacy(config) => {
				let mut result = config.validate();
				if let Err(e) = legacy::validate_tcp_rules(&config.rules) {
					match result {
						Ok(()) => {
							let mut errors = ValidationErrors::new();
							errors.add("rules", e);
							result = Err(errors);
						}
						Err(ref mut errors) => {
							errors.add("rules", e);
						}
					}
				}
				result
			}
			Self::Flow(config) => config.validate(),
		}
	}
}