Static with fallback about staticfile HOT 5 OPEN

struct Fallback;

impl AroundMiddleware for Fallback {
    fn around(self, handler: Box<Handler>) -> Box<Handler> {
        Box::new(FallbackHandler(handler))
    }
}

struct FallbackHandler(Box<Handler>);

impl Handler for FallbackHandler {
    fn handle(&self, req: &mut Request) -> IronResult<Response> {
        let resp = self.0.handle(req);

        match resp {
            Err(err) => {
                match err.response.status {
                    Some(status::NotFound) => {
                        let file = File::open("/tmp/example").unwrap();
                        Ok(Response::with((status::Ok, file)))
                    }
                    _ => Err(err),
                }
            }
            other => other
        }
    }
}

use std::collections::HashSet;

use iron::prelude::*;
use iron::{BeforeMiddleware, Url};

pub struct Remap {
    new_path: String,
    routes: HashSet<&'static str>,
}

impl Remap {
    pub fn new(path: &str) -> Remap {
        Remap {
            new_path: path.into(),
            routes: HashSet::new(),
        }
    }

    pub fn get(&mut self, path: &'static str) {
        self.routes.insert(path);
    }
}

impl BeforeMiddleware for Remap {
    fn before(&self, req: &mut Request) -> IronResult<()> {
        // TODO: do we really need to clone?
        let original_url = req.url.clone().into_generic_url();

        if self.routes.contains(original_url.path()) {
            let mut changed_url = original_url;
            changed_url.set_path(&self.new_path);
            let changed_url = Url::from_generic_url(changed_url).expect("Unable to rebuild URL");
            req.url = changed_url;
        }

        Ok(())
    }
}

mod remap;
use remap::Remap;

fn main() {
    let mut mount = Mount::new();
    mount.mount("/", Static::new(&root));

    // Routes that are handled client-side
    let mut remap = Remap::new("/");
    remap.get("/about");

    let mut remapped = Chain::new(mount);
    remapped.link_before(remap);

    info!("Starting the server on {}:{}", address, port);
    Iron::new(remapped).http((&*address, port)).expect("Unable to start server");
}

let static_files = Static::new("assets");

let remap = Remap::new("assets/index.html")
    .get("/users")
    .get("/users/:id")
    .get("/posts")
    .get("/posts/:id");

let fallback = Fallback::new(static_files, remap);