fastforward 0.5.4

a library for implementing custom reverse proxies
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

[![Build Status](https://travis-ci.org/bpmason1/fastforward.svg?branch=master)](https://travis-ci.org/bpmason1/fastforward)
[![minimum rustc 1.31](https://img.shields.io/badge/rustc-1.31+-yellow.svg)

# fastforward

Fastforward is library for writing reverse proxies in rust.


## usage - simple_proxy
To implement a proxy that just receives traffic on `listen_addr`
and forwards the it to `proxy_addr` use the `simple_proxy` function.
```
extern crate fastforward;
extern crate http;

use std::net::SocketAddr;
use proxy::simple_proxy;

fn main() {
    let listen_addr: SocketAddr = "127.0.0.1:8080".parse().unwrap();
    let proxy_addr: SocketAddr = "127.0.0.1:4000".parse().unwrap();

    println!("running on port :8080");
    simple_proxy(listen_addr, proxy_addr);
}
```

## usage - generic_proxy
To implement arbitrary logic for your proxy write a request director function.
The request, after be passed into the director, will be proxied to the address
specified by the "Host" header on the request.
```
extern crate fastforward;
extern crate http;

use http::{
    header::HeaderValue,
    Response
};
use std::io;
use std::net::SocketAddr;
use fastforward::generic_proxy;


// The director function mutates the incoming request before proxying it.
// In this example, the request URI is changed to the proxy URI.
// This examle mimics the functionality of the `simple_proxy` function.
fn req_transform(req: &mut http::Request<Vec<u8>>) -> Option<Response<Vec<u8>>> { 
   // set the variables
   let proxy_addr = HeaderValue::from_str("127.0.0.1:4000").unwrap();

   let req_headers = req.headers_mut();
   req_headers.remove(http::header::HOST);
   req_headers.insert(http::header::HOST, proxy_addr);

   None  // ignore the return type for this example
}

fn resp_transform(resp: &mut http::Response<Vec<u8>>) {
   let x_header_val = HeaderValue::from_str("Foo Bar").unwrap();
    
    let resp_headers = resp.headers_mut();
    resp_headers.insert("X-HEADER-VAL", x_header_val);
}

fn main() {
    let listen_addr: SocketAddr = "127.0.0.1:8080".parse().unwrap();
    generic_proxy(listen_addr, req_transform, resp_transform);
}
```