reinhardt-core 0.1.0

Core components for Reinhardt framework
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

//! Request lifecycle events

use super::core::SignalName;
use super::registry::get_signal;
use super::signal::Signal;
use std::collections::HashMap;

/// Request started signal - sent when an HTTP request starts
#[derive(Debug, Clone)]
pub struct RequestStartedEvent {
	/// Request environment variables and metadata.
	pub environ: HashMap<String, String>,
}

impl RequestStartedEvent {
	/// Creates a new request-started event with an empty environment.
	pub fn new() -> Self {
		Self {
			environ: HashMap::new(),
		}
	}

	/// Sets the request environment variables.
	pub fn with_environ(mut self, environ: HashMap<String, String>) -> Self {
		self.environ = environ;
		self
	}
}

impl Default for RequestStartedEvent {
	fn default() -> Self {
		Self::new()
	}
}

/// Returns the request-started signal.
pub fn request_started() -> Signal<RequestStartedEvent> {
	get_signal::<RequestStartedEvent>(SignalName::REQUEST_STARTED)
}

/// Request finished signal - sent when an HTTP request finishes
#[derive(Debug, Clone)]
pub struct RequestFinishedEvent {
	/// Request environment variables and metadata.
	pub environ: HashMap<String, String>,
}

impl RequestFinishedEvent {
	/// Creates a new request-finished event with an empty environment.
	pub fn new() -> Self {
		Self {
			environ: HashMap::new(),
		}
	}

	/// Sets the request environment variables.
	pub fn with_environ(mut self, environ: HashMap<String, String>) -> Self {
		self.environ = environ;
		self
	}
}

impl Default for RequestFinishedEvent {
	fn default() -> Self {
		Self::new()
	}
}

/// Returns the request-finished signal.
pub fn request_finished() -> Signal<RequestFinishedEvent> {
	get_signal::<RequestFinishedEvent>(SignalName::REQUEST_FINISHED)
}

/// Got request exception signal - sent when an exception occurs during request handling
#[derive(Debug, Clone)]
pub struct GotRequestExceptionEvent {
	/// The error message describing the exception.
	pub error_message: String,
	/// Additional request information at the time of the exception.
	pub request_info: HashMap<String, String>,
}

impl GotRequestExceptionEvent {
	/// Creates a new exception event with the given error message.
	pub fn new(error_message: impl Into<String>) -> Self {
		Self {
			error_message: error_message.into(),
			request_info: HashMap::new(),
		}
	}

	/// Sets additional request information for the exception event.
	pub fn with_request_info(mut self, request_info: HashMap<String, String>) -> Self {
		self.request_info = request_info;
		self
	}
}

/// Returns the got-request-exception signal.
pub fn got_request_exception() -> Signal<GotRequestExceptionEvent> {
	get_signal::<GotRequestExceptionEvent>(SignalName::GOT_REQUEST_EXCEPTION)
}

/// Setting changed signal - sent when a setting is changed
#[derive(Debug, Clone)]
pub struct SettingChangedEvent {
	/// Name of the setting that changed.
	pub setting_name: String,
	/// Previous value of the setting, if any.
	pub old_value: Option<String>,
	/// New value of the setting.
	pub new_value: String,
}

impl SettingChangedEvent {
	/// Creates a new setting-changed event.
	pub fn new(
		setting_name: impl Into<String>,
		old_value: Option<String>,
		new_value: impl Into<String>,
	) -> Self {
		Self {
			setting_name: setting_name.into(),
			old_value,
			new_value: new_value.into(),
		}
	}
}

/// Returns the setting-changed signal.
pub fn setting_changed() -> Signal<SettingChangedEvent> {
	get_signal::<SettingChangedEvent>(SignalName::SETTING_CHANGED)
}