Add AddOrigin middleware

AddOrigin adds a constant origin to all requests.

Author: carllerche

.gitignore

@@ -0,0 +1,4 @@
+
+/target/
+**/*.rs.bk
+Cargo.lock

Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "tower-http"
+version = "0.1.0"
+authors = ["Carl Lerche <me@carllerche.com>"]
+
+[workspace]
+members = [
+  "tower-add-origin",
+]
+
+[dependencies]
+tower-add-origin = { path = "tower-add-origin" }

LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2018 tower-http authors.
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,15 @@
+# Tower HTTP
+
+Tower utilities for HTTP clients and servers
+
+[![Build Status](https://travis-ci.org/tower-rs/tower-http.svg?branch=master)](https://travis-ci.org/tower-rs/tower-http)
+
+More information about this crate can be found in the [crate documentation][dox]
+
+[dox]: https://tower-rs.github.io/tower-http/tower_http
+
+**This library is not production ready. Do not try to use it in a production
+environment or you will regret it!** This crate is still under active
+development and there has not yet been any focus on documentation (because you
+shouldn't be using it yet!).
+

src/lib.rs

@@ -0,0 +1,3 @@
+extern crate tower_add_origin;
+
+pub use tower_add_origin::AddOrigin;

tower-add-origin/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "tower-add-origin"
+version = "0.1.0"
+authors = ["Carl Lerche <me@carllerche.com>"]
+
+[dependencies]
+futures = "0.1"
+http = "0.1"
+tower = { git = "https://github.com/tower-rs/tower" }
+
+[dev-dependencies]
+tower-mock = { git = "https://github.com/tower-rs/tower" }

tower-add-origin/README.md

@@ -0,0 +1,3 @@
+Add Origin
+
+HTTP specific Tower middleware that adds a constant origin to all requests.

tower-add-origin/src/lib.rs

@@ -0,0 +1,85 @@
+extern crate futures;
+extern crate http;
+extern crate tower;
+
+use futures::Poll;
+use http::Request;
+use http::uri::{Authority, Scheme};
+use tower::Service;
+
+/// Wraps an HTTP service, injecting authority and scheme on every request.
+pub struct AddOrigin<T> {
+    inner: T,
+    scheme: Scheme,
+    authority: Authority,
+}
+
+impl<T> AddOrigin<T> {
+    /// Create a new `AddOrigin`
+    pub fn new(inner: T, scheme: Scheme, authority: Authority) -> Self {
+        AddOrigin {
+            inner,
+            authority,
+            scheme,
+        }
+    }
+
+    /// Return a reference to the HTTP scheme that is added to all requests.
+    pub fn scheme(&self) -> &Scheme {
+        &self.scheme
+    }
+
+    /// Return a reference to the HTTP authority that is added to all requests.
+    pub fn authority(&self) -> &Authority {
+        &self.authority
+    }
+
+    /// Returns a reference to the inner service.
+    pub fn get_ref(&self) -> &T {
+        &self.inner
+    }
+
+    /// Returns a mutable reference to the inner service.
+    pub fn get_mut(&mut self) -> &mut T {
+        &mut self.inner
+    }
+
+    /// Consumes `self`, returning the inner service.
+    pub fn into_inner(self) -> T {
+        self.inner
+    }
+}
+
+impl<T, B> Service for AddOrigin<T>
+where T: Service<Request = Request<B>>,
+{
+    type Request = Request<B>;
+    type Response = T::Response;
+    type Error = T::Error;
+    type Future = T::Future;
+
+    fn poll_ready(&mut self) -> Poll<(), Self::Error> {
+        self.inner.poll_ready()
+    }
+
+    fn call(&mut self, req: Self::Request) -> Self::Future {
+        // Split the request into the head and the body.
+        let (mut head, body) = req.into_parts();
+
+        // Split the request URI into parts.
+        let mut uri: http::uri::Parts = head.uri.into();
+
+        // Update the URI parts, setting hte scheme and authority
+        uri.scheme = Some(self.scheme.clone());
+        uri.authority = Some(self.authority.clone());
+
+        // Update the the request URI
+        head.uri = http::Uri::from_parts(uri)
+            .expect("valid uri");
+
+        let request = Request::from_parts(head, body);
+
+        // Call the inner service
+        self.inner.call(request)
+    }
+}

tower-add-origin/tests/add_origin.rs

@@ -0,0 +1,40 @@
+extern crate http;
+extern crate tower;
+extern crate tower_add_origin;
+extern crate tower_mock;
+
+use http::{Request, Response};
+use http::uri::*;
+use tower::Service;
+use tower_add_origin::*;
+use tower_mock::*;
+
+#[test]
+fn adds_origin_to_requests() {
+    let scheme = Scheme::HTTP;
+    let authority: Authority = "www.example.com".parse().unwrap();
+
+    let (mock, mut handle) = Mock::<_, _, ()>::new();
+    let mut add_origin = AddOrigin::new(mock, scheme.clone(), authority.clone());
+
+    let request = Request::get("/")
+        .body(())
+        .unwrap();
+
+    let _response = add_origin.call(request);
+
+    // Get the request
+    let request = handle.next_request().unwrap();
+    let (request, send_response) = request.into_parts();
+
+    // Assert that the origin is set
+    assert_eq!(request.uri().scheme_part().unwrap(), &scheme);
+    assert_eq!(request.uri().authority_part().unwrap(), &authority);
+
+    // Make everything happy:
+    let response = Response::builder()
+        .status(204)
+        .body(());
+
+    send_response.respond(response);
+}