2f11d69
use std::collections::HashMap;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use tokio::io::AsyncRead;
use crate::server::endpoint::EndpointKind;
use crate::server::limits::DEFAULT_OUTPUT_CAP_BYTES;
/// Case-insensitive HTTP header map. Header names are stored lower-cased so
/// lookups match regardless of case (per HTTP semantics), without pulling in
/// the `http` crate.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct HeaderMap {
inner: HashMap<String, String>,
}
impl HeaderMap {
pub fn new() -> Self {
Self {
inner: HashMap::new(),
}
}
/// Insert a header, normalizing the name to lower-case.
pub fn insert(&mut self, key: impl Into<String>, value: impl Into<String>) -> Option<String> {
self.inner
.insert(key.into().to_ascii_lowercase(), value.into())
}
/// Case-insensitive lookup.
pub fn get(&self, key: &str) -> Option<&String> {
self.inner.get(&key.to_ascii_lowercase())
}
pub fn remove(&mut self, key: &str) -> Option<String> {
self.inner.remove(&key.to_ascii_lowercase())
}
pub fn contains_key(&self, key: &str) -> bool {
self.inner.contains_key(&key.to_ascii_lowercase())
}
pub fn len(&self) -> usize {
self.inner.len()
}
pub fn is_empty(&self) -> bool {
self.inner.is_empty()
}
pub fn iter(&self) -> impl Iterator<Item = (&String, &String)> {
self.inner.iter()
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum AuthScheme {
#[default]
Anonymous,
Basic,
Bearer,
Ssh,
}
impl AuthScheme {
pub fn as_str(&self) -> &'static str {
match self {
Self::Anonymous => "anonymous",
Self::Basic => "basic",
Self::Bearer => "bearer",
Self::Ssh => "ssh",
}
}
}
#[derive(Debug, Clone)]
pub struct Principal {
pub name: String,
pub scheme: AuthScheme,
}
impl Principal {
pub fn new(name: impl Into<String>, scheme: AuthScheme) -> Self {
Self {
name: name.into(),
scheme,
}
}
}
#[derive(Debug, Clone, Default)]
pub struct AuthContext {
pub scheme: AuthScheme,
pub principal: Option<Principal>,
pub raw: Option<String>,
}
impl AuthContext {
pub fn anonymous() -> Self {
Self {
scheme: AuthScheme::Anonymous,
principal: None,
raw: None,
}
}
pub fn with_principal(scheme: AuthScheme, principal: Principal) -> Self {
Self {
scheme,
principal: Some(principal),
raw: None,
}
}
}
#[derive(Debug, Clone)]
pub struct RefUpdateEntry {
pub name: String,
pub new_oid: String,
pub old_oid: Option<String>,
}
#[derive(Debug, Clone, Default)]
pub struct RefUpdateBatch {
pub updates: Vec<RefUpdateEntry>,
}
impl RefUpdateBatch {
pub fn new() -> Self {
Self::default()
}
pub fn push(
mut self,
name: impl Into<String>,
new_oid: impl Into<String>,
old_oid: Option<String>,
) -> Self {
self.updates.push(RefUpdateEntry {
name: name.into(),
new_oid: new_oid.into(),
old_oid,
});
self
}
pub fn is_empty(&self) -> bool {
self.updates.is_empty()
}
pub fn len(&self) -> usize {
self.updates.len()
}
}
pub struct ServerRequest {
pub method: String,
pub path: String,
pub query: Option<String>,
pub headers: HeaderMap,
pub body: Box<dyn AsyncRead + Unpin + Send + Sync>,
pub guard: StreamGuard,
pub output_cap: u64,
pub auth: Option<AuthContext>,
pub endpoint: EndpointKind,
pub remote_addr: Option<String>,
pub service: String,
}
impl std::fmt::Debug for ServerRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ServerRequest")
.field("method", &self.method)
.field("path", &self.path)
.field("query", &self.query)
.field("headers", &self.headers)
.field("body", &"<dyn AsyncRead>")
.field("guard", &self.guard)
.field("output_cap", &self.output_cap)
.field("auth", &self.auth)
.field("endpoint", &self.endpoint)
.field("remote_addr", &self.remote_addr)
.field("service", &self.service)
.finish()
}
}
impl ServerRequest {
pub fn new(
method: impl Into<String>,
path: impl Into<String>,
endpoint: EndpointKind,
service: impl Into<String>,
body: Box<dyn AsyncRead + Unpin + Send + Sync>,
) -> Self {
Self {
method: method.into(),
path: path.into(),
query: None,
headers: HeaderMap::new(),
body,
guard: StreamGuard::new(),
output_cap: DEFAULT_OUTPUT_CAP_BYTES as u64,
auth: None,
endpoint,
remote_addr: None,
service: service.into(),
}
}
pub fn with_query(mut self, query: impl Into<String>) -> Self {
self.query = Some(query.into());
self
}
pub fn with_header(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
self.headers.insert(key.into(), value.into());
self
}
pub fn with_auth(mut self, auth: AuthContext) -> Self {
self.auth = Some(auth);
self
}
pub fn with_output_cap(mut self, cap_bytes: u64) -> Self {
self.output_cap = cap_bytes;
self
}
pub fn with_remote_addr(mut self, addr: impl Into<String>) -> Self {
self.remote_addr = Some(addr.into());
self
}
}
#[derive(Debug, Clone)]
pub struct StreamGuard {
cancelled: Arc<AtomicBool>,
}
impl Default for StreamGuard {
fn default() -> Self {
Self::new()
}
}
impl StreamGuard {
pub fn new() -> Self {
Self {
cancelled: Arc::new(AtomicBool::new(false)),
}
}
pub fn cancel(&self) {
self.cancelled.store(true, Ordering::SeqCst);
}
pub fn is_cancelled(&self) -> bool {
self.cancelled.load(Ordering::SeqCst)
}
pub fn handle(&self) -> StreamGuardHandle {
StreamGuardHandle {
cancelled: self.cancelled.clone(),
}
}
}
#[derive(Debug, Clone)]
pub struct StreamGuardHandle {
cancelled: Arc<AtomicBool>,
}
impl StreamGuardHandle {
pub fn is_cancelled(&self) -> bool {
self.cancelled.load(Ordering::SeqCst)
}
pub fn cancel(&self) {
self.cancelled.store(true, Ordering::SeqCst);
}
}