async_http_router 0.0.4

mod view;
use chrono;
use futures;
use hyper;
use hyper_tls;
use tokio;

use futures::{future, Future, Stream};
use tokio::sync::RwLock;
// use hyper::client::HttpConnector;
use async_http_router::class_view::HttpWays;
use async_http_router::router::{handle_url, Router};
use hyper::service::{make_service_fn, service_fn};
use hyper::{Body, Method, Request, Response, Result, Server, StatusCode};
use std::collections::HashMap;
use std::fmt;
use std::net::SocketAddr;
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use tokio::net::TcpListener;
use tokio::prelude::*;
use view::Test;

use tokio::runtime::Runtime;

use async_http_router::constraint::NOTFOUND;

type GenericError = Box<dyn std::error::Error + Send + Sync>;
type MyResult<T> = std::result::Result<T, GenericError>;

//#[test]
#[tokio::main]
async fn main() {
    const UNIT_AK: &str = "sss";
    const UNIT_SK: &str = "sss";
    let addr = "127.0.0.1:1337".parse().unwrap();
    let mut c_router = Router::new();
    c_router.register(r"/test", Test::as_view());
    c_router.register(r"^/year/(?P<year>\d{4})", Test::as_view());

    let shared = Arc::new(c_router);

    // This is the connection handler.
    let make_service = make_service_fn(|_| {
        let shared = shared.clone();
        async {
            // This is the request handler.
            Ok::<_, GenericError>(service_fn(move |req| {
                let shared = shared.clone();
                Router::handle_url(shared, req)
            }))
        }
    });
    let server = Server::bind(&addr).serve(make_service);

    println!("Starting server on http://localhost:1337/");
    if let Err(e) = server.await {
        eprintln!("server error: {}", e);
    }
}