Пишем простой веб сервис на языке программирования Rust

/// входящий PushEvent из Github Webhook.
#[derive(Deserialize)]
struct PushEvent {
    #[serde(rename = "ref")]
    reference: String,
}

use  actix_web::Json;

fn index(push: Json<PushEvent>)  -> ...

use actix_web::HttpRequest;
use actix_web::middleware::{Middleware, Started};
use actix_web::error::{ErrorUnauthorized, ParseError};
use actix_web::Result;

struct VerifySignature;

impl<S> Middleware<S> for VerifySignature {
    fn start(&self, req: &mut HttpRequest<S>) -> Result<Started> {
        use std::io::Read;

        let r = req.clone();
        let s = r.headers()
            .get("X-Hub-Signature")
            .ok_or(ErrorUnauthorized(ParseError::Header))?
            .to_str()
            .map_err(ErrorUnauthorized)?;
        // получаем "sha1=" из заголовка
        let (_, sig) = s.split_at(5);

        let secret = env::var("GITHUB_SECRET").unwrap();
        let mut body = String::new();
        req.read_to_string(&mut body)
            .map_err(ErrorInternalServerError)?;

        if is_valid_signature(&sig, &body, &secret) {
            Ok(Started::Done)
        } else {
            Err(ErrorUnauthorized(ParseError::Header))
        }
    }
}

header! { (TravisAPIVersion, "Travis-API-Version") => [u16] }

#[derive(Serialize)]
struct TravisRequest {
    message: String,
    branch: String,
}

fn travis_request(url: &str) -> Result<reqwest::Response> {
    let client = reqwest::Client::new();
    let res = client
        .post(url)
        .header(reqwest::header::ContentType::json())
        .header(TravisAPIVersion(3))
        .header(reqwest::header::Authorization(auth_str()))
        .json(&TravisRequest {
            message: "API Request triggered by zigbee2mqtt update".to_string(),
            branch: "master".to_string(),
        })
        .send()
        .map_err(ErrorInternalServerError)?;
    Ok(res)

fn auth_str() -> String {
    format!("token {}", std::env::var("TRAVIS_TOKEN").unwrap()).to_owned()
}

fn index(push: Json<PushEvent>) -> impl Responder {} // очень причудливый и новый `impl Trait` в выходном значении функции

use actix_web::{Responder, HttpRequest, HttpResponse, Error};

#[derive(Serialize)]
struct ServerMessage(String)

impl Responder for ServerMessage {
    type Item = HttpResponse;
    type Error = Error;

    fn respond_to<S>(self, _req: &HttpRequest<S>) -> Result<HttpResponse, Error> {
        let body = serde_json::to_string(&self)?;
        Ok(HttpResponse::Ok()
            .content_type("application/json")
            .body(body))
    }
}

use std::env;
use actix_web::{Json, Responder, HttpRequest, HttpResponse, Error};
use actix_web::error::ErrorInternalServerError;

fn index(push: Json<PushEvent>) -> impl Responder {
    let travis_url = env::var("TRAVIS_URL").unwrap();
    if push.reference.ends_with("master") {
        match travis_request("https://api.travis-ci.org/repo/19145006/requests") {
            Ok(_) => ServerMessage(format!(
                "PushEvent on branch master found, request sent to {}",
                travis_url).to_owned()),
            Err(e) => ErrorInternalServerError(e),
        }
    } else {
        ServerMessage("PushEvent is not for master branch".to_owned())
    }
}

use actix_web::Either;

type ServerResponse = Either<ServerMessage, Error>;

fn index(push: Json<PushEvent>) -> impl Responder {
    let travis_url = env::var("TRAVIS_URL").unwrap();
    if push.reference.ends_with("master") {
        match travis_request("https://api.travis-ci.org/repo/19145006/requests") {
            Ok(_) => Either::A(
                ServerMessage(format!(
                    "PushEvent on branch master found, request sent to {}",
                    travis_url)
                .to_owned())
            ),
            Err(e) => Either::B(ErrorInternalServerError(e)),
        }
    } else {
        Either::A(ServerMessage("PushEvent is not for master branch".to_owned()))
    }
}

#[derive(Serialize)]
struct ServerMessage {
    message: String,

    // нам не нужно сериализовать ошибку,
    // она будет передана в
    // составе структуры `ServerMessage` в `HTTPResponse`
    #[serde(skip_serializing)]
    e: Option<Error>,
}


impl Responder for ServerMessage {
    type Item = HttpResponse;
    type Error = Error;

    fn respond_to<S>(self, _req: &HttpRequest<S>) -> Result<HttpResponse, Error> {
        if self.e.is_some() {
            return Err(self.e.unwrap());
        } else {
            let body = serde_json::to_string(&self)?;
            Ok(HttpResponse::Ok()
                .content_type("application/json")
                .body(body))
        }
    }
}

impl ServerMessage {
    fn success<T: ToString>(s: T) -> ServerMessage {
        ServerMessage {
            message: s.to_string(),
            e: None,
        }
    }

    fn error(e: Error) -> ServerMessage {
        ServerMessage {
            message: "".to_owned(),
            e: Some(e),
        }
    }
}

fn index(push: Json<PushEvent>) -> impl Responder {
    let travis_url = env::var("TRAVIS_URL").unwrap();
    if push.reference.ends_with("master") {
        match travis_request("https://api.travis-ci.org/repo/19145006/requests") {
            Ok(_) => ServerMessage::success(format!(
                "PushEvent on branch master found, request sent to {}",
                travis_url
            )),
            Err(e) => ServerMessage::error(e),
        }
    } else {
        ServerMessage::success("PushEvent is not for master branch")
    }
}

/// функция utility из примера проекта `heroku buildpack`
fn get_server_port() -> u16 {
    env::var("PORT")
        .ok()
        .and_then(|p| p.parse().ok())
        .unwrap_or(8080)
}

fn main() {
    use std::net::{SocketAddr, ToSocketAddrs};
    let sys = actix::System::new("updater");
    let addr = SocketAddr::from(([0, 0, 0, 0], get_server_port()));

    server::new(|| {
        App::new()
            .middleware(HeaderCheck)
            .resource("/", |r| r.method(http::Method::POST).with(index))
    }).bind(addr)
        .unwrap()
        .start();

    let _ = sys.run();
}