expected (), found Result<ServiceResponse<B>, _> using midleware in actix_web trying to return Ok

[meiry]

i see many issues with using actix-web middleware features ... im trying to do very simple thing .
return ok on success fail on failure . but keep getting errors :
my code
//heartbeat.rs

use std::future::{ready, Ready};

use actix_http::header::{HeaderValue, HeaderName};
use actix_web::{
    dev::{self, Service, ServiceRequest, ServiceResponse, Transform},
    Error,http::Method
};
use futures_util::future::LocalBoxFuture;
//use crate::constants;

pub struct Heartbeat;

impl<S, B> Transform<S, ServiceRequest> for Heartbeat
where
    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
    B: 'static,
{
    type Response = ServiceResponse<B>;
    type Error = Error;
    type InitError = ();
    type Transform = HeartMiddleware<S>;
    type Future = Ready<Result<Self::Transform, Self::InitError>>;

    fn new_transform(&self, service: S) -> Self::Future {
        ready(Ok(HeartMiddleware { service }))
    }
}

pub struct HeartMiddleware<S> {
    service: S,
}


impl<S, B> Service<ServiceRequest> for HeartMiddleware<S>
where
    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
    B: 'static,
{
    type Response = ServiceResponse<B>;
    type Error = Error;
    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;

    dev::forward_ready!(service);

    fn call(&self, req: ServiceRequest) -> Self::Future {
        

        let fut = self.service.call(req);
        
        

        Box::pin(async move {
            
            let mut res = fut.await?;
            let headers = res.headers_mut();
            headers.insert(
                 HeaderName::from_static("Content-Type"), HeaderValue::from_static("text/plain")
             );
            
            if (Method::POST == req.method() || 
                 Method::GET  == req.method()  ||
                 Method::HEAD == req.method()) && req.path() == "/ping" {
                 Ok(res)
            }
             
            Err(actix_web::error::ErrorImATeapot("Tea"))
        })
    }
}


 

//main.rs

use actix_web::{get,web,http,Result,App,HttpServer,HttpRequest, Responder, HttpResponse};
use serde::{Deserialize,Serialize};
use actix_cors::Cors;

mod heartbeat;

static PORT :u16 = 9091;

#[get("/")]
async fn index()->impl Responder {
    
    HttpResponse::Ok().body("template")
}

 

#[derive(Serialize)]
pub struct Response {
    pub message: String,
}

async fn not_found() ->Result<HttpResponse> {
    let response = Response {
        message: "Resource not found".to_string(),
    };
    Ok(HttpResponse::NotFound().json(response))
}


#[actix_web::main]
async fn main()-> std::io::Result<()> {
    std::env::set_var("RUST_LOG", "debug");
    env_logger::init();
    HttpServer::new(|| App::new()
    .wrap(
        Cors::default()
            .allowed_origin("http://*") // Allow all http origins
            .allowed_origin("https://*") // Allow all https origins
            .allowed_methods(vec!["GET","POST","PUT","DELETE","OPTIONS"])
            .allowed_headers(vec![http::header::AUTHORIZATION,http::header::CONTENT_TYPE,
                http::header::ACCEPT,http::header::LINK])
            .allowed_header("X-CSRF-TOKEN")
            .supports_credentials()
            .max_age(300)
    )
    .wrap(heartbeat::Heartbeat)
    .service(index)
    .service(web::resource("/ping"))
    .default_service(web::route().to(not_found)))
    .bind(("127.0.0.1",PORT))?
    .run()
    .await        
}

The error :

$ cargo build
   Compiling broker-service v0.1.0 (C:\dev\my\rust\workspace\broker-service)
error[E0308]: mismatched types
  --> src\heartbeat.rs:65:18
   |
62 | /             if (Method::POST == req.method() ||
63 | |                  Method::GET  == req.method()  ||
64 | |                  Method::HEAD == req.method()) && req.path() == "/ping" {
65 | |                  Ok(res)
   | |                  ^^^^^^^ expected `()`, found `Result<ServiceResponse<B>, _>`
66 | |             }
   | |_____________- expected this to be `()`
   |
   = note: expected unit type `()`
                   found enum `Result<ServiceResponse<B>, _>`
note: return type inferred to be `()` here
  --> src\heartbeat.rs:56:27
   |
56 |             let mut res = fut.await?;
   |                           ^^^^^^^^^^

For more information about this error, try `rustc --explain E0308`.
warning: `broker-service` (bin "broker-service") generated 2 warnings
error: could not compile `broker-service` (bin "broker-service") due to previous error; 2 warnings emitted

[robjtede]

              if (Method::POST == req.method() || 
                   Method::GET  == req.method()  ||
                   Method::HEAD == req.method()) && req.path() == "/ping" {
-                  Ok(res)
+                  return Ok(res);
                }

[meiry]

It doesn't work. It seems that the function call fn call(&self, req: ServiceRequest) is consuming the value of ServiceRequest. (Where is this written?) So, if I move the if statement to be :

fn call(&self, req: ServiceRequest) -> Self::Future {
        
        let condition = (Method::POST == req.method() || 
                 Method::GET  == req.method()  ||
                 Method::HEAD == req.method()) && req.path() == "/ping";                       
            

        let fut = self.service.call(req);
        Box::pin(async move {
            
            let mut res = fut.await?;
            let headers = res.headers_mut();
            headers.insert(
                 HeaderName::from_static("Content-Type"), HeaderValue::from_static("text/plain")
             );
            
            if condition {
                return Ok(res)
            }          
            Err(actix_web::error::ErrorImATeapot("Tea"))
        })
    }
        

it is compies but now i have somekind of warning :

$ ./target/debug/broker-service.exe 
[2023-08-31T12:43:58Z INFO  actix_server::builder] starting 8 workers
[2023-08-31T12:43:58Z INFO  actix_server::server] Actix runtime found; starting in Actix runtime
thread 'actix-rt|system:0|arbiter:0' panicked at 'index out of bounds: the len is 0 but the index is 0', C:\Users\xxx\.cargo\registry\src\index.crates.io-6f17d22bba15001f\http-0.2.9\src\header\name.rs:1270:13
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
thread 'actix-rt|system:0|arbiter:1' panicked at 'index out of bounds: the len is 0 but the index is 0', C:\Users\xxx\.cargo\registry\src\index.crates.io-6f17d22bba15001f\http-0.2.9\src\header\name.rs:1270:13
thread 'actix-rt|system:0|arbiter:2' panicked at 'index out of bounds: the len is 0 but the index is 0', C:\Users\xxx\.cargo\registry\src\index.crates.io-6f17d22bba15001f\http-0.2.9\src\header\name.rs:1270:13
thread 'actix-rt|system:0|arbiter:3' panicked at 'index out of bounds: the len is 0 but the index is 0', C:\Users\xxx\.cargo\registry\src\index.crates.io-6f17d22bba15001f\http-0.2.9\src\header\name.rs:1270:13
thread 'actix-rt|system:0|arbiter:4' panicked at 'index out of bounds: the len is 0 but the index is 0', C:\Users\xxx\.cargo\registry\src\index.crates.io-6f17d22bba15001f\http-0.2.9\src\header\name.rs:1270:13

[robjtede]

The panic is caused by:

HeaderName::from_static("Content-Type")

Check the docs for this function:

This function requires the static string to only contain lowercase characters ...

- https://docs.rs/http/latest/http/header/struct.HeaderName.html#method.from_static