Add util::option_layer and ServiceBuilder::option_layer

[kazk]

Hi, thanks for tower. kube is now using it under the hood (replaced reqwest with tower + hyper) 🎉

We have a conditional Layer to handle certain authentication methods and found ServiceBuilderExt::optional_layer in tonic very useful. Can we have that included in tower?

We use it like the following:

let maybe_auth = match &auth {
    Authentication::None => None,
    Authentication::Basic(s) => {
        default_headers.insert(
            AUTHORIZATION,
            HeaderValue::from_str(s).map_err(Error::InvalidBasicAuth)?,
        );
        None
    }
    Authentication::Token(s) => {
        default_headers.insert(
            AUTHORIZATION,
            HeaderValue::from_str(s).map_err(Error::InvalidBearerToken)?,
        );
        None
    }
    Authentication::RefreshableToken(r) => Some(AuthLayer::new(r.clone())),
};
let common = ServiceBuilder::new()
    // ... omitted
    .map_request(move |r| set_default_headers(r, default_headers.clone()))
    .into_inner();
ServiceBuilder::new()
    .layer(common)
    .optional_layer(maybe_auth)
    .service(client)

[hawkw]

I think something like that would be great --- are you interested in opening a PR?

[kazk]

Sure, I can try. The credit goes to @LucioFranco.

impl<L> ServiceBuilder<L> {
    // ...
    #[cfg(feature = "util")]
    #[cfg_attr(docsrs, doc(cfg(feature = "util")))]
    fn optional_layer<T>(self, inner: Option<T>) -> ServiceBuilder<Stack<OptionalLayer<T>, L>> {
        self.layer(OptionalLayer::new(inner))
    }
}


#[derive(Clone, Debug)]
pub struct OptionalLayer<L> {
    inner: Option<L>,
}
impl<L> OptionalLayer<L> {
    pub fn new(inner: Option<L>) -> Self {
        OptionalLayer { inner }
    }
}
impl<S, L> Layer<S> for OptionalLayer<L>
where
    L: Layer<S>,
{
    type Service = crate::util::Either<L::Service, S>;
    fn layer(&self, s: S) -> Self::Service {
        if let Some(inner) = &self.inner {
            crate::util::Either::A(inner.layer(s))
        } else {
            crate::util::Either::B(s)
        }
    }
}

Where should OptionalLayer go? Looking at other methods, it should probably be under tower/src/util/, but there's already another Optional.

[davidpdrsn]

Great idea! We actually have basically the same thing at Embark but I didn't consider upstreaming it. What we have:

use tower::{layer::util::Identity, util::Either};

/// Convert an `Option<Layer>` into a `Layer`
pub fn option_layer<L>(layer: Option<L>) -> Either<L, Identity> {
    if let Some(layer) = layer {
        Either::A(layer)
    } else {
        Either::B(Identity::new())
    }
}

This uses the fact that Either<Layer1, Layer2> is also a Layer.

I think a decent setup would be to have an option_layer function exposed at tower::util::option_layer and then adding another method to ServiceBuilder that calls it with an Option<L>.

In my opinion we don't need a new OptionalLayer type.

I also prefer the name OptionLayer (or option_layer) rather than OptionalLayer as the former is more closely aligned to Option.