🚧

Cargo.toml

@@ -9,8 +9,11 @@ edition = "2018"
 
 [dependencies]
 
-futures = "0.3.7"
+futures = "0.3"
-hyper = "0.13.8"
+http = "0.2"
+hyper = "0.13"
 reqwest = { version = "0.10.8", features = ["stream"] }
+rmp-serde = "0.14.4"
+serde = {version = "1.0", features = ["derive"]}
 tokio = { version = "0.2", features = ["full"] }
 ulid = "0.4.1"

src/http_serde.rs

@@ -0,0 +1,133 @@
+use std::{
+	collections::*,
+	convert::{TryFrom, TryInto},
+	iter::FromIterator,
+};
+
+use serde::{Deserialize, Serialize};
+
+pub enum Error {
+	Unsupported,
+	InvalidHeaderName,
+}
+
+impl From <hyper::header::InvalidHeaderName> for Error {
+	fn from (x: hyper::header::InvalidHeaderName) -> Self {
+		Self::InvalidHeaderName
+	}
+}
+
+#[derive (Deserialize, Serialize)]
+pub enum Method {
+	// Only GET is supported for now
+	Get,
+}
+
+impl TryFrom <hyper::Method> for Method {
+	type Error = Error;
+	
+	fn try_from (x: hyper::Method) -> Result <Self, Error> {
+		match x {
+			hyper::Method::GET => Ok (Self::Get),
+			_ => Err (Error::Unsupported),
+		}
+	}
+}
+
+impl From <Method> for hyper::Method {
+	fn from (x: Method) -> Self {
+		match x {
+			Method::Get => Self::GET,
+		}
+	}
+}
+
+#[derive (Deserialize, Serialize)]
+pub struct RequestParts {
+	pub method: Method,
+	
+	// Technically URIs are subtle and complex but I don't care
+	pub uri: String,
+	
+	// Technically Hyper has headers in a multi-map
+	// but I don't feel like doing that right now.
+	
+	// Headers are _kinda_ ASCII but they can also be binary.
+	// HTTP is nutty.
+	pub headers: HashMap <String, Vec <u8>>,
+}
+
+impl TryFrom <http::request::Parts> for RequestParts {
+	type Error = Error;
+	
+	fn try_from (x: http::request::Parts) -> Result <Self, Error> {
+		let method = x.method.try_into ()?;
+		let uri = x.uri.to_string ();
+		let headers = HashMap::from_iter (
+			x.headers.into_iter ()
+			.filter_map (|(k, v)| k.map (|k| (k, v)))
+			.map (|(k, v)| (String::from (k.as_str ()), v.as_bytes ().to_vec ()))
+		);
+		
+		Ok (Self {
+			method,
+			uri,
+			headers,
+		})
+	}
+}
+
+impl TryFrom <RequestParts> for http::request::Builder {
+	type Error = Error;
+	
+	fn try_from (x: RequestParts) -> Result <Self, Error> {
+		let method = Method::from (x.method);
+		
+		let mut result = Self::new ()
+			.method (method)
+			.uri (x.uri)
+		;
+		
+		for (k, v) in x.headers.into_iter () {
+			result = result.header (http::header::HeaderName::try_from (&k)?, v);
+		}
+		
+		Ok (result)
+	}
+}
+
+#[derive (Deserialize, Serialize)]
+pub enum StatusCode {
+	Ok,
+	NotFound,
+}
+
+impl TryFrom <hyper::StatusCode> for StatusCode {
+	type Error = Error;
+	
+	fn try_from (x: hyper::StatusCode) -> Result <Self, Error> {
+		match x {
+			hyper::StatusCode::OK => Ok (Self::Ok),
+			hyper::StatusCode::NOT_FOUND => Ok (Self::NotFound),
+			_ => Err (Error::Unsupported),
+		}
+	}
+}
+
+impl From <StatusCode> for hyper::StatusCode {
+	fn from (x: StatusCode) -> Self {
+		match x {
+			StatusCode::Ok => Self::OK,
+			StatusCode::NotFound => Self::NOT_FOUND,
+		}
+	}
+}
+
+#[derive (Deserialize, Serialize)]
+pub struct Response {
+	pub status_code: String,
+	
+	// Technically Hyper has headers in a multi-map
+	// but I don't feel like doing that right now.
+	pub headers: HashMap <String, String>,
+}

src/lib.rs

@@ -1 +1,2 @@
+pub mod http_serde;
 pub mod watcher;