actix-extras/examples/basics/src/main.rs

#![allow(unused_variables)]
#![cfg_attr(feature="cargo-clippy", allow(needless_pass_by_value))]

extern crate actix;
extern crate actix_web;
extern crate env_logger;
extern crate futures;
use futures::Stream;

use std::{io, env};
use actix_web::{error, fs, pred,
                App, HttpRequest, HttpResponse, HttpServer, Result, Error};
use actix_web::http::{Method, StatusCode};
use actix_web::middleware::{self, RequestSession};
use futures::future::{FutureResult, result};

/// favicon handler
fn favicon(req: HttpRequest) -> Result<fs::NamedFile> {
    Ok(fs::NamedFile::open("../static/favicon.ico")?)
}

/// simple index handler
fn index(mut req: HttpRequest) -> Result<HttpResponse> {
    println!("{:?}", req);

    // example of ...
    if let Ok(ch) = req.poll() {
        if let futures::Async::Ready(Some(d)) = ch {
            println!("{}", String::from_utf8_lossy(d.as_ref()));
        }
    }

    // session
    let mut counter = 1;
    if let Some(count) = req.session().get::<i32>("counter")? {
        println!("SESSION value: {}", count);
        counter = count + 1;
        req.session().set("counter", counter)?;
    } else {
        req.session().set("counter", counter)?;
    }

    // html
    let html = format!(r#"<!DOCTYPE html><html><head><title>actix - basics</title><link rel="shortcut icon" type="image/x-icon" href="/favicon.ico" /></head>
<body>
    <h1>Welcome <img width="30px" height="30px" src="/static/actixLogo.png" /></h1>
    session counter = {}
</body>
</html>"#, counter);

    // response
    Ok(HttpResponse::build(StatusCode::OK)
        .content_type("text/html; charset=utf-8")
        .body(&html))

}

/// 404 handler
fn p404(req: HttpRequest) -> Result<HttpResponse> {

    // html
    let html = r#"<!DOCTYPE html><html><head><title>actix - basics</title><link rel="shortcut icon" type="image/x-icon" href="/favicon.ico" /></head>
<body>
    <a href="index.html">back to home</a>
    <h1>404</h1>
</body>
</html>"#;

    // response
    Ok(HttpResponse::build(StatusCode::NOT_FOUND)
        .content_type("text/html; charset=utf-8")
        .body(html))
}


/// async handler
fn index_async(req: HttpRequest) -> FutureResult<HttpResponse, Error>
{
    println!("{:?}", req);

    result(Ok(HttpResponse::Ok()
              .content_type("text/html")
              .body(format!("Hello {}!", req.match_info().get("name").unwrap()))))
}

/// handler with path parameters like `/user/{name}/`
fn with_param(req: HttpRequest) -> HttpResponse
{
    println!("{:?}", req);

    HttpResponse::Ok()
        .content_type("test/plain")
        .body(format!("Hello {}!", req.match_info().get("name").unwrap()))
}

fn main() {
    env::set_var("RUST_LOG", "actix_web=debug");
    env::set_var("RUST_BACKTRACE", "1");
    env_logger::init();
    let sys = actix::System::new("basic-example");

    let addr = HttpServer::new(
        || App::new()
            // enable logger
            .middleware(middleware::Logger::default())
            // cookie session middleware
            .middleware(middleware::SessionStorage::new(
                middleware::CookieSessionBackend::build(&[0; 32])
                    .secure(false)
                    .finish()
            ))
            // register favicon
            .resource("/favicon.ico", |r| r.f(favicon))
            // register simple route, handle all methods
            .resource("/index.html", |r| r.f(index))
            // with path parameters
            .resource("/user/{name}/", |r| r.method(Method::GET).f(with_param))
            // async handler
            .resource("/async/{name}", |r| r.method(Method::GET).a(index_async))
            .resource("/test", |r| r.f(|req| {
                match *req.method() {
                    Method::GET => HttpResponse::Ok(),
                    Method::POST => HttpResponse::MethodNotAllowed(),
                    _ => HttpResponse::NotFound(),
                }
            }))
            .resource("/error.html", |r| r.f(|req| {
                error::InternalError::new(
                    io::Error::new(io::ErrorKind::Other, "test"), StatusCode::OK)
            }))
            // static files
            .handler("/static/", fs::StaticFiles::new("../static/", true))
            // redirect
            .resource("/", |r| r.method(Method::GET).f(|req| {
                println!("{:?}", req);

                HttpResponse::Found()
                    .header("LOCATION", "/index.html")
                    .finish()
            }))
            // default
            .default_resource(|r| {
                r.method(Method::GET).f(p404);
                r.route().filter(pred::Not(pred::Get())).f(
                    |req| HttpResponse::MethodNotAllowed());
            }))

        .bind("127.0.0.1:8080").expect("Can not bind to 127.0.0.1:8080")
        .shutdown_timeout(0)    // <- Set shutdown timeout to 0 seconds (default 60s)
        .start();

    println!("Starting http server: 127.0.0.1:8080");
    let _ = sys.run();
}
basic example 2017-10-22 04:35:50 +02:00			`#![allow(unused_variables)]`
cookie session implementation 2017-11-27 02:30:35 +01:00			`#![cfg_attr(feature="cargo-clippy", allow(needless_pass_by_value))]`

basic example 2017-10-22 04:35:50 +02:00			`extern crate actix;`
			`extern crate actix_web;`
			`extern crate env_logger;`
make possible to use async handler 2017-11-03 21:35:34 +01:00			`extern crate futures;`
refactor payload 2017-12-19 09:18:57 +01:00			`use futures::Stream;`
basic example 2017-10-22 04:35:50 +02:00
Log request processing errors 2018-01-21 05:12:24 +01:00			`use std::{io, env};`
update examples 2018-03-31 03:54:38 +02:00			`use actix_web::{error, fs, pred,`
rename Application 2018-03-31 09:16:55 +02:00			`App, HttpRequest, HttpResponse, HttpServer, Result, Error};`
update examples 2018-03-31 03:54:38 +02:00			`use actix_web::http::{Method, StatusCode};`
			`use actix_web::middleware::{self, RequestSession};`
refactor streaming responses 2017-11-30 23:42:20 +01:00			`use futures::future::{FutureResult, result};`
subscriber to os signals automatically 2018-01-06 01:32:36 +01:00
upd examples basics 2018-01-06 16:43:59 +01:00			`/// favicon handler`
			`fn favicon(req: HttpRequest) -> Result<fs::NamedFile> {`
			`Ok(fs::NamedFile::open("../static/favicon.ico")?)`
			`}`
basic example 2017-10-22 04:35:50 +02:00
upd examples basics 2018-01-06 16:43:59 +01:00			`/// simple index handler`
move state to request object 2017-11-27 06:18:38 +01:00			`fn index(mut req: HttpRequest) -> Result<HttpResponse> {`
basic example 2017-10-22 04:35:50 +02:00			`println!("{:?}", req);`
upd examples basics 2018-01-06 16:43:59 +01:00
			`// example of ...`
refactor payload related futures for HttpRequest 2018-02-25 18:34:26 +01:00			`if let Ok(ch) = req.poll() {`
refactor payload 2017-12-19 09:18:57 +01:00			`if let futures::Async::Ready(Some(d)) = ch {`
			`println!("{}", String::from_utf8_lossy(d.as_ref()));`
add content encoding decompression 2017-11-06 10:24:49 +01:00			`}`
			`}`
cookie session implementation 2017-11-27 02:30:35 +01:00
			`// session`
upd examples basics 2018-01-06 16:43:59 +01:00			`let mut counter = 1;`
cookie session implementation 2017-11-27 02:30:35 +01:00			`if let Some(count) = req.session().get::<i32>("counter")? {`
			`println!("SESSION value: {}", count);`
upd examples basics 2018-01-06 16:43:59 +01:00			`counter = count + 1;`
			`req.session().set("counter", counter)?;`
cookie session implementation 2017-11-27 02:30:35 +01:00			`} else {`
upd examples basics 2018-01-06 16:43:59 +01:00			`req.session().set("counter", counter)?;`
cookie session implementation 2017-11-27 02:30:35 +01:00			`}`

upd examples basics 2018-01-06 16:43:59 +01:00			`// html`
			`let html = format!(r#"<!DOCTYPE html><html><head><title>actix - basics</title><link rel="shortcut icon" type="image/x-icon" href="/favicon.ico" /></head>`
			`<body>`
			`<h1>Welcome <img width="30px" height="30px" src="/static/actixLogo.png" /></h1>`
			`session counter = {}`
			`</body>`
			`</html>"#, counter);`

			`// response`
			`Ok(HttpResponse::build(StatusCode::OK)`
			`.content_type("text/html; charset=utf-8")`
update examples 2018-03-31 08:37:15 +02:00			`.body(&html))`
upd examples basics 2018-01-06 16:43:59 +01:00
			`}`

			`/// 404 handler`
			`fn p404(req: HttpRequest) -> Result<HttpResponse> {`

			`// html`
Log request processing errors 2018-01-21 05:12:24 +01:00			`let html = r#"<!DOCTYPE html><html><head><title>actix - basics</title><link rel="shortcut icon" type="image/x-icon" href="/favicon.ico" /></head>`
upd examples basics 2018-01-06 16:43:59 +01:00			`<body>`
			`<a href="index.html">back to home</a>`
			`<h1>404</h1>`
			`</body>`
Log request processing errors 2018-01-21 05:12:24 +01:00			`</html>"#;`
upd examples basics 2018-01-06 16:43:59 +01:00
			`// response`
			`Ok(HttpResponse::build(StatusCode::NOT_FOUND)`
			`.content_type("text/html; charset=utf-8")`
update examples 2018-03-31 08:37:15 +02:00			`.body(html))`
basic example 2017-10-22 04:35:50 +02:00			`}`

upd examples basics 2018-01-06 16:43:59 +01:00
start working on guide 2017-11-28 01:41:37 +01:00			`/// async handler`
refactor streaming responses 2017-11-30 23:42:20 +01:00			`fn index_async(req: HttpRequest) -> FutureResult<HttpResponse, Error>`
make possible to use async handler 2017-11-03 21:35:34 +01:00			`{`
			`println!("{:?}", req);`

update examples 2018-03-31 08:37:15 +02:00			`result(Ok(HttpResponse::Ok()`
			`.content_type("text/html")`
			`.body(format!("Hello {}!", req.match_info().get("name").unwrap()))))`
make possible to use async handler 2017-11-03 21:35:34 +01:00			`}`

start working on guide 2017-11-28 01:41:37 +01:00			/// handler with path parameters like `/user/{name}/`
update examples 2018-03-31 08:37:15 +02:00			`fn with_param(req: HttpRequest) -> HttpResponse`
better handler function ergonimics 2017-10-30 05:39:59 +01:00			`{`
basic example 2017-10-22 04:35:50 +02:00			`println!("{:?}", req);`

update examples 2018-03-31 08:37:15 +02:00			`HttpResponse::Ok()`
			`.content_type("test/plain")`
			`.body(format!("Hello {}!", req.match_info().get("name").unwrap()))`
basic example 2017-10-22 04:35:50 +02:00			`}`

			`fn main() {`
Log request processing errors 2018-01-21 05:12:24 +01:00			`env::set_var("RUST_LOG", "actix_web=debug");`
			`env::set_var("RUST_BACKTRACE", "1");`
			`env_logger::init();`
add tera example 2017-12-18 22:41:52 +01:00			`let sys = actix::System::new("basic-example");`
basic example 2017-10-22 04:35:50 +02:00
move example/basic.rs to examples/basic 2017-12-30 16:50:17 +01:00			`let addr = HttpServer::new(`
rename Application 2018-03-31 09:16:55 +02:00			`\|\| App::new()`
pass request by ref; added middleware support 2017-10-22 07:59:09 +02:00			`// enable logger`
rename module 2017-12-27 04:59:41 +01:00			`.middleware(middleware::Logger::default())`
cookie session implementation 2017-11-27 02:30:35 +01:00			`// cookie session middleware`
rename module 2017-12-27 04:59:41 +01:00			`.middleware(middleware::SessionStorage::new(`
			`middleware::CookieSessionBackend::build(&[0; 32])`
cookie session implementation 2017-11-27 02:30:35 +01:00			`.secure(false)`
			`.finish()`
			`))`
upd examples basics 2018-01-06 16:43:59 +01:00			`// register favicon`
			`.resource("/favicon.ico", \|r\| r.f(favicon))`
use Route for Applicaiton handlers 2017-12-04 23:53:40 +01:00			`// register simple route, handle all methods`
remove Applicaiton::route, resource is enough 2017-12-06 17:03:08 +01:00			`.resource("/index.html", \|r\| r.f(index))`
add multiple apps example 2017-12-02 08:32:15 +01:00			`// with path parameters`
remove Applicaiton::route, resource is enough 2017-12-06 17:03:08 +01:00			`.resource("/user/{name}/", \|r\| r.method(Method::GET).f(with_param))`
make possible to use async handler 2017-11-03 21:35:34 +01:00			`// async handler`
remove Applicaiton::route, resource is enough 2017-12-06 17:03:08 +01:00			`.resource("/async/{name}", \|r\| r.method(Method::GET).a(index_async))`
			`.resource("/test", \|r\| r.f(\|req\| {`
refactor RouteHandler trait 2017-11-29 22:26:55 +01:00			`match *req.method() {`
update examples 2018-03-31 03:54:38 +02:00			`Method::GET => HttpResponse::Ok(),`
			`Method::POST => HttpResponse::MethodNotAllowed(),`
			`_ => HttpResponse::NotFound(),`
refactor RouteHandler trait 2017-11-29 22:26:55 +01:00			`}`
use Route for Applicaiton handlers 2017-12-04 23:53:40 +01:00			`}))`
Log request processing errors 2018-01-21 05:12:24 +01:00			`.resource("/error.html", \|r\| r.f(\|req\| {`
update example 2018-03-19 00:27:34 +01:00			`error::InternalError::new(`
			`io::Error::new(io::ErrorKind::Other, "test"), StatusCode::OK)`
Log request processing errors 2018-01-21 05:12:24 +01:00			`}))`
basic example 2017-10-22 04:35:50 +02:00			`// static files`
update h2 lib 2018-01-03 04:37:33 +01:00			`.handler("/static/", fs::StaticFiles::new("../static/", true))`
added ServerSettings 2017-12-08 07:54:44 +01:00			`// redirect`
			`.resource("/", \|r\| r.method(Method::GET).f(\|req\| {`
			`println!("{:?}", req);`

add HttpServer::server_hostname method 2017-12-26 23:36:03 +01:00			`HttpResponse::Found()`
added ServerSettings 2017-12-08 07:54:44 +01:00			`.header("LOCATION", "/index.html")`
cleanup examples 2017-12-21 01:32:31 +01:00			`.finish()`
upd examples basics 2018-01-06 16:43:59 +01:00			`}))`
			`// default`
			`.default_resource(\|r\| {`
			`r.method(Method::GET).f(p404);`
update examples 2018-03-31 03:54:38 +02:00			`r.route().filter(pred::Not(pred::Get())).f(`
			`\|req\| HttpResponse::MethodNotAllowed());`
upd examples basics 2018-01-06 16:43:59 +01:00			`}))`

			`.bind("127.0.0.1:8080").expect("Can not bind to 127.0.0.1:8080")`
			`.shutdown_timeout(0) // <- Set shutdown timeout to 0 seconds (default 60s)`
simplify server start method 2017-12-19 18:08:36 +01:00			`.start();`
basic example 2017-10-22 04:35:50 +02:00
refactor multipart stream creation 2017-12-19 18:51:28 +01:00			`println!("Starting http server: 127.0.0.1:8080");`
basic example 2017-10-22 04:35:50 +02:00			`let _ = sys.run();`
			`}`