use crate::{GurtError, Result, GURT_VERSION};
use crate::protocol::{GurtStatusCode, PROTOCOL_PREFIX, HEADER_SEPARATOR, BODY_SEPARATOR};
use serde::{Serialize, Deserialize};
use std::collections::HashMap;
use std::fmt;
use chrono::Utc;
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum GurtMethod {
GET,
POST,
PUT,
DELETE,
HEAD,
OPTIONS,
PATCH,
HANDSHAKE,
}
impl GurtMethod {
pub fn parse(s: &str) -> Result<Self> {
match s.to_uppercase().as_str() {
"GET" => Ok(Self::GET),
"POST" => Ok(Self::POST),
"PUT" => Ok(Self::PUT),
"DELETE" => Ok(Self::DELETE),
"HEAD" => Ok(Self::HEAD),
"OPTIONS" => Ok(Self::OPTIONS),
"PATCH" => Ok(Self::PATCH),
"HANDSHAKE" => Ok(Self::HANDSHAKE),
_ => Err(GurtError::invalid_message(format!("Unsupported method: {}", s))),
}
}
}
impl fmt::Display for GurtMethod {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let s = match self {
Self::GET => "GET",
Self::POST => "POST",
Self::PUT => "PUT",
Self::DELETE => "DELETE",
Self::HEAD => "HEAD",
Self::OPTIONS => "OPTIONS",
Self::PATCH => "PATCH",
Self::HANDSHAKE => "HANDSHAKE",
};
write!(f, "{}", s)
}
}
pub type GurtHeaders = HashMap<String, String>;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GurtRequest {
pub method: GurtMethod,
pub path: String,
pub version: String,
pub headers: GurtHeaders,
pub body: Vec<u8>,
}
impl GurtRequest {
pub fn new(method: GurtMethod, path: String) -> Self {
Self {
method,
path,
version: GURT_VERSION.to_string(),
headers: GurtHeaders::new(),
body: Vec::new(),
}
}
pub fn with_header<K: Into<String>, V: Into<String>>(mut self, key: K, value: V) -> Self {
self.headers.insert(key.into().to_lowercase(), value.into());
self
}
pub fn with_body<B: Into<Vec<u8>>>(mut self, body: B) -> Self {
self.body = body.into();
self
}
pub fn with_string_body<S: AsRef<str>>(mut self, body: S) -> Self {
self.body = body.as_ref().as_bytes().to_vec();
self
}
pub fn header(&self, key: &str) -> Option<&String> {
self.headers.get(&key.to_lowercase())
}
pub fn text(&self) -> Result<String> {
std::str::from_utf8(&self.body)
.map(|s| s.to_string())
.map_err(|e| GurtError::invalid_message(format!("Invalid UTF-8 body: {}", e)))
}
pub fn parse(data: &str) -> Result<Self> {
Self::parse_bytes(data.as_bytes())
}
pub fn parse_bytes(data: &[u8]) -> Result<Self> {
let body_separator = BODY_SEPARATOR.as_bytes();
let body_separator_pos = data.windows(body_separator.len())
.position(|window| window == body_separator);
let (headers_section, body) = if let Some(pos) = body_separator_pos {
let headers_part = &data[..pos];
let body_part = &data[pos + body_separator.len()..];
(headers_part, body_part.to_vec())
} else {
(data, Vec::new())
};
let headers_str = std::str::from_utf8(headers_section)
.map_err(|_| GurtError::invalid_message("Invalid UTF-8 in headers"))?;
let lines: Vec<&str> = headers_str.split(HEADER_SEPARATOR).collect();
if lines.is_empty() {
return Err(GurtError::invalid_message("Empty request"));
}
let request_line = lines[0];
let parts: Vec<&str> = request_line.split_whitespace().collect();
if parts.len() != 3 {
return Err(GurtError::invalid_message("Invalid request line format"));
}
let method = GurtMethod::parse(parts[0])?;
let path = parts[1].to_string();
if !parts[2].starts_with(PROTOCOL_PREFIX) {
return Err(GurtError::invalid_message("Invalid protocol identifier"));
}
let version_str = &parts[2][PROTOCOL_PREFIX.len()..];
let version = version_str.to_string();
let mut headers = GurtHeaders::new();
for line in lines.iter().skip(1) {
if line.is_empty() {
break;
}
if let Some(colon_pos) = line.find(':') {
let key = line[..colon_pos].trim().to_lowercase();
let value = line[colon_pos + 1..].trim().to_string();
headers.insert(key, value);
}
}
Ok(Self {
method,
path,
version,
headers,
body,
})
}
pub fn to_string(&self) -> String {
let mut message = format!("{} {} {}{}{}",
self.method, self.path, PROTOCOL_PREFIX, self.version, HEADER_SEPARATOR);
let mut headers = self.headers.clone();
if !headers.contains_key("content-length") {
headers.insert("content-length".to_string(), self.body.len().to_string());
}
if !headers.contains_key("user-agent") {
headers.insert("user-agent".to_string(), format!("GURT-Client/{}", GURT_VERSION));
}
for (key, value) in &headers {
message.push_str(&format!("{}: {}{}", key, value, HEADER_SEPARATOR));
}
message.push_str(HEADER_SEPARATOR);
if !self.body.is_empty() {
if let Ok(body_str) = std::str::from_utf8(&self.body) {
message.push_str(body_str);
}
}
message
}
pub fn to_bytes(&self) -> Vec<u8> {
let mut message = format!("{} {} {}{}{}",
self.method, self.path, PROTOCOL_PREFIX, self.version, HEADER_SEPARATOR);
let mut headers = self.headers.clone();
if !headers.contains_key("content-length") {
headers.insert("content-length".to_string(), self.body.len().to_string());
}
if !headers.contains_key("user-agent") {
headers.insert("user-agent".to_string(), format!("GURT-Client/{}", GURT_VERSION));
}
for (key, value) in &headers {
message.push_str(&format!("{}: {}{}", key, value, HEADER_SEPARATOR));
}
message.push_str(HEADER_SEPARATOR);
let mut bytes = message.into_bytes();
bytes.extend_from_slice(&self.body);
bytes
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GurtResponse {
pub version: String,
pub status_code: u16,
pub status_message: String,
pub headers: GurtHeaders,
pub body: Vec<u8>,
}
impl GurtResponse {
pub fn new(status_code: GurtStatusCode) -> Self {
Self {
version: GURT_VERSION.to_string(),
status_code: status_code as u16,
status_message: status_code.message().to_string(),
headers: GurtHeaders::new(),
body: Vec::new(),
}
}
pub fn ok() -> Self {
Self::new(GurtStatusCode::Ok)
}
pub fn not_found() -> Self {
Self::new(GurtStatusCode::NotFound)
}
pub fn bad_request() -> Self {
Self::new(GurtStatusCode::BadRequest)
}
pub fn forbidden() -> Self {
Self::new(GurtStatusCode::Forbidden)
}
pub fn internal_server_error() -> Self {
Self::new(GurtStatusCode::InternalServerError)
}
pub fn with_header<K: Into<String>, V: Into<String>>(mut self, key: K, value: V) -> Self {
self.headers.insert(key.into().to_lowercase(), value.into());
self
}
pub fn with_body<B: Into<Vec<u8>>>(mut self, body: B) -> Self {
self.body = body.into();
self
}
pub fn with_string_body<S: AsRef<str>>(mut self, body: S) -> Self {
self.body = body.as_ref().as_bytes().to_vec();
self
}
pub fn with_json_body<T: Serialize>(mut self, data: &T) -> Result<Self> {
let json = serde_json::to_string(data)?;
self.body = json.into_bytes();
self.headers.insert("content-type".to_string(), "application/json".to_string());
Ok(self)
}
pub fn header(&self, key: &str) -> Option<&String> {
self.headers.get(&key.to_lowercase())
}
pub fn text(&self) -> Result<String> {
std::str::from_utf8(&self.body)
.map(|s| s.to_owned())
.map_err(|e| GurtError::invalid_message(format!("Invalid UTF-8 body: {}", e)))
}
pub fn is_success(&self) -> bool {
self.status_code >= 200 && self.status_code < 300
}
pub fn is_client_error(&self) -> bool {
self.status_code >= 400 && self.status_code < 500
}
pub fn is_server_error(&self) -> bool {
self.status_code >= 500
}
pub fn parse(data: &str) -> Result<Self> {
Self::parse_bytes(data.as_bytes())
}
pub fn parse_bytes(data: &[u8]) -> Result<Self> {
let body_separator = BODY_SEPARATOR.as_bytes();
let body_separator_pos = data.windows(body_separator.len())
.position(|window| window == body_separator);
let (headers_section, body) = if let Some(pos) = body_separator_pos {
let headers_part = &data[..pos];
let body_part = &data[pos + body_separator.len()..];
(headers_part, body_part.to_vec())
} else {
(data, Vec::new())
};
let headers_str = std::str::from_utf8(headers_section)
.map_err(|_| GurtError::invalid_message("Invalid UTF-8 in headers"))?;
let lines: Vec<&str> = headers_str.split(HEADER_SEPARATOR).collect();
if lines.is_empty() {
return Err(GurtError::invalid_message("Empty response"));
}
let status_line = lines[0];
let parts: Vec<&str> = status_line.splitn(3, ' ').collect();
if parts.len() < 2 {
return Err(GurtError::invalid_message("Invalid status line format"));
}
if !parts[0].starts_with(PROTOCOL_PREFIX) {
return Err(GurtError::invalid_message("Invalid protocol identifier"));
}
let version_str = &parts[0][PROTOCOL_PREFIX.len()..];
let version = version_str.to_string();
let status_code: u16 = parts[1].parse()
.map_err(|_| GurtError::invalid_message("Invalid status code"))?;
let status_message = if parts.len() > 2 {
parts[2].to_string()
} else {
GurtStatusCode::from_u16(status_code)
.map(|sc| sc.message().to_string())
.unwrap_or_else(|| "Unknown".to_string())
};
let mut headers = GurtHeaders::new();
for line in lines.iter().skip(1) {
if line.is_empty() {
break;
}
if let Some(colon_pos) = line.find(':') {
let key = line[..colon_pos].trim().to_lowercase();
let value = line[colon_pos + 1..].trim().to_string();
headers.insert(key, value);
}
}
Ok(Self {
version,
status_code,
status_message,
headers,
body,
})
}
pub fn to_string(&self) -> String {
let mut message = format!("{}{} {} {}{}",
PROTOCOL_PREFIX, self.version, self.status_code, self.status_message, HEADER_SEPARATOR);
let mut headers = self.headers.clone();
if !headers.contains_key("content-length") {
headers.insert("content-length".to_string(), self.body.len().to_string());
}
if !headers.contains_key("server") {
headers.insert("server".to_string(), format!("GURT/{}", GURT_VERSION));
}
if !headers.contains_key("date") {
let now = Utc::now();
let date_str = now.format("%a, %d %b %Y %H:%M:%S GMT").to_string();
headers.insert("date".to_string(), date_str);
}
for (key, value) in &headers {
message.push_str(&format!("{}: {}{}", key, value, HEADER_SEPARATOR));
}
message.push_str(HEADER_SEPARATOR);
if !self.body.is_empty() {
if let Ok(body_str) = std::str::from_utf8(&self.body) {
message.push_str(body_str);
}
}
message
}
pub fn to_bytes(&self) -> Vec<u8> {
let mut message = format!("{}{} {} {}{}",
PROTOCOL_PREFIX, self.version, self.status_code, self.status_message, HEADER_SEPARATOR);
let mut headers = self.headers.clone();
if !headers.contains_key("content-length") {
headers.insert("content-length".to_string(), self.body.len().to_string());
}
if !headers.contains_key("server") {
headers.insert("server".to_string(), format!("GURT/{}", GURT_VERSION));
}
if !headers.contains_key("date") {
let now = Utc::now();
let date_str = now.format("%a, %d %b %Y %H:%M:%S GMT").to_string();
headers.insert("date".to_string(), date_str);
}
for (key, value) in &headers {
message.push_str(&format!("{}: {}{}", key, value, HEADER_SEPARATOR));
}
message.push_str(HEADER_SEPARATOR);
let mut bytes = message.into_bytes();
bytes.extend_from_slice(&self.body);
bytes
}
}
#[derive(Debug, Clone)]
pub enum GurtMessage {
Request(GurtRequest),
Response(GurtResponse),
}
impl GurtMessage {
pub fn parse(data: &str) -> Result<Self> {
Self::parse_bytes(data.as_bytes())
}
pub fn parse_bytes(data: &[u8]) -> Result<Self> {
let header_separator = HEADER_SEPARATOR.as_bytes();
let first_line_end = data.windows(header_separator.len())
.position(|window| window == header_separator)
.unwrap_or(data.len());
let first_line = std::str::from_utf8(&data[..first_line_end])
.map_err(|_| GurtError::invalid_message("Invalid UTF-8 in first line"))?;
if first_line.starts_with(PROTOCOL_PREFIX) {
Ok(GurtMessage::Response(GurtResponse::parse_bytes(data)?))
} else {
Ok(GurtMessage::Request(GurtRequest::parse_bytes(data)?))
}
}
pub fn is_request(&self) -> bool {
matches!(self, GurtMessage::Request(_))
}
pub fn is_response(&self) -> bool {
matches!(self, GurtMessage::Response(_))
}
pub fn as_request(&self) -> Option<&GurtRequest> {
match self {
GurtMessage::Request(req) => Some(req),
_ => None,
}
}
pub fn as_response(&self) -> Option<&GurtResponse> {
match self {
GurtMessage::Response(res) => Some(res),
_ => None,
}
}
}
impl fmt::Display for GurtMessage {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
GurtMessage::Request(req) => write!(f, "{}", req.to_string()),
GurtMessage::Response(res) => write!(f, "{}", res.to_string()),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_request_parsing() {
let raw = "GET /test GURT/1.0.0\r\nHost: example.com\r\nAccept: text/html\r\n\r\ntest body";
let request = GurtRequest::parse(raw).expect("Failed to parse request");
assert_eq!(request.method, GurtMethod::GET);
assert_eq!(request.path, "/test");
assert_eq!(request.version, GURT_VERSION.to_string());
assert_eq!(request.header("host"), Some(&"example.com".to_string()));
assert_eq!(request.header("accept"), Some(&"text/html".to_string()));
assert_eq!(request.text().unwrap(), "test body");
}
#[test]
fn test_response_parsing() {
let raw = "GURT/1.0.0 200 OK\r\nContent-Type: text/html\r\n\r\n<html></html>";
let response = GurtResponse::parse(raw).expect("Failed to parse response");
assert_eq!(response.version, GURT_VERSION.to_string());
assert_eq!(response.status_code, 200);
assert_eq!(response.status_message, "OK");
assert_eq!(response.header("content-type"), Some(&"text/html".to_string()));
assert_eq!(response.text().unwrap(), "<html></html>");
}
#[test]
fn test_request_building() {
let request = GurtRequest::new(GurtMethod::GET, "/test".to_string())
.with_header("Host", "example.com")
.with_string_body("test body");
let raw = request.to_string();
let parsed = GurtRequest::parse(&raw).expect("Failed to parse built request");
assert_eq!(parsed.method, request.method);
assert_eq!(parsed.path, request.path);
assert_eq!(parsed.body, request.body);
}
#[test]
fn test_response_building() {
let response = GurtResponse::ok()
.with_header("Content-Type", "text/html")
.with_string_body("<html></html>");
let raw = response.to_string();
let parsed = GurtResponse::parse(&raw).expect("Failed to parse built response");
assert_eq!(parsed.status_code, response.status_code);
assert_eq!(parsed.body, response.body);
}
}