^^^^^^^ expected `()`, found `Result<ServiceResponse<B>, _>` ??? not related not informative ..

[meiry]

Code

//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        
}


//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"))
        })
    }
}

Current output

cargo build
   Compiling broker-service v0.1.0 (C:\dev\my\rust\workspace\broker-service)
warning: unused import: `HttpRequest`
 --> src\main.rs:1:52
  |
1 | use actix_web::{get,web,http,Result,App,HttpServer,HttpRequest, Responder, HttpResponse};
  |                                                    ^^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

warning: unused import: `Deserialize`
 --> src\main.rs:2:13
  |
2 | use serde::{Deserialize,Serialize};
  |             ^^^^^^^^^^^

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

Desired output

the real Cause for the error 
what is :
^^^^^^^ expected `()`, found `Result<ServiceResponse<B>, _>` ???

Rationale and extra context

using letest actix-web

Other cases

No response

Anything else?

No response

[ShE3py]

An else block is required:

if [Method::POST, Method::GET, Method::HEAD].contains(req.method()) && req.path() == "/ping" {
    Ok(res)
}
else {
    Err(actix_web::error::ErrorImATeapot("Tea"))
}

See E0317.

[meiry]

@ShE3py did you test it ? i guess not ,
The problem was that the "req" object got somehow consort and not available ,
if you do :

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 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 CONTANT_TYPE: &'static str = "content-type";
            let TEXT_PLAIN: &'static str = "text/plain";

            let headers = res.headers_mut();
            headers.insert(
                 HeaderName::from_static(CONTANT_TYPE), HeaderValue::from_static(TEXT_PLAIN)
             );
            
            if condition {
                return Ok(res)
            }          
            Err(actix_web::error::ErrorImATeapot("Tea"))
        })
    }

all working 

[Taaitaaiger]

You either need to write return Ok(res) or add the else block so both the if and else blocks return the same type.

[meiry]

@Taaitaaiger not working in this case of actix_web

[kusabana]

@Taaitaaiger not working in this case of actix_web

I don't quite understand?
Replicating your issue, adding an else block like

if (Method::POST == req.method() || 
     Method::GET  == req.method()  ||
     Method::HEAD == req.method()) && req.path() == "/ping" {
     Ok(res)
} else {
    Err(actix_web::error::ErrorImATeapot("Tea"))
}

solves the error you posted, however this uncovers a new error due to you using a value after move.

[estebank]

@compiler-errors this is the issue I was mentioning just now. Returning the Ok(_) would be correct, because return corresponds to the async block, not the whole function, but we use the same logic both for checking whether return would be appropriate in its scope and to find the enclosing return type. I'm looking into it and trying to fix this today.