Access the endpoint from http::Request in a custom Connector

[gagbo]

Hello,

I'm currently implementing my own connector adapter to use the SDK in a wasm binary with custom bindings:

// Adapter is an empty struct. (I tried to use connector_fn but had that function future freezing, never woken up by my runtime somehow)
impl Service<http::Request<SdkBody>> for Adapter {
    type Response = http::Response<SdkBody>;

    type Error = ConnectorError;

    #[allow(clippy::type_complexity)]
    type Future = std::pin::Pin<
        Box<dyn std::future::Future<Output = Result<Self::Response, Self::Error>> + Send + 'static>,
    >;

    fn poll_ready(
        &mut self,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Result<(), Self::Error>> {
        Poll::Ready(Ok(()))
    }

    fn call(&mut self, req: http::Request<SdkBody>) -> Self::Future {
        log(format!(
            "CloudWatch: adapter: sending request to {}",
            req.uri()
        ));
        // The specific bindings call that is a future
        let fut = make_http_request(self.try_into_bindings_request(req).unwrap());
        Box::pin(async move {
            Ok(http::Response::new(SdkBody::from(
                fut.await.map_err(downcast_error)?.body,
            )))
        })
    }
}

Everything works fine, except that the request req doesn't contain the endpoint I want to hit for some reason. req.uri() is just / for a request to list metrics in cloudwatch:

Request { method: POST, uri: /, version: HTTP/1.1, headers: {"content-type": "application/x-www-form-urlencoded", "content-length": "94"}, body: SdkBody { inner: Once(Some(b"Action=ListMetrics&Version=2010-08-01&Namespace=AWS%2FRDS&MetricName=MaximumUsedTransactionIDs")), retryable: true } }

is what I'm getting as req basically (with some parameters added to the query). How would I get back the base URL to use to make the request?

[gagbo]

From inspecting the SdkConfig that I build, it seems that I don't have any endpoint resolver setup. I only hard code the credentials, and then insert the region in the SdkConfiguration I'm building. I assumed that passing the region would be enough to have a default resolver that would work.

// Building a SdkConfig from the wasm app configuration:
impl From<&Config> for SdkConfig {
    fn from(conf: &Config) -> Self {
        SdkConfig::builder()
            .region(Region::new(conf.region.clone()))
            .credentials_provider(SharedCredentialsProvider::new(Credentials::from_keys(
                &conf.access_key_id.0,
                &conf.secret_access_key.0,
                None,
            )))
            .build()
    }
}

And then this assertion fails when I call it

    let shared_config = SdkConfig::from(&config);
    shared_config
        .endpoint_resolver()
        .ok_or_else(|| Error::Invocation {
            message: "The shared config does not have an endpoint resolver!!".to_string(),
        })?;
            let config = aws_sdk_cloudwatch::config::Builder::from(&shared_config)
        .retry_config(RetryConfig::disabled())
        .build();

// ...

Since I'm never mentioning an override of the endpoint resolver, I was expecting to obtain a default one that works. I'm mostly trying to avoid aws_config because I have no environment to pull configuration from.

[rcoh]

ah I see—if you overwrite the middleware basically nothing will work. You want to use https://docs.rs/aws-config/0.51.0/aws_config/struct.ConfigLoader.html#method.http_connector to change the http connector—that's available in both SdkConfig and the local service config (then you don't need any other overrides).

This method was added pretty recently.

[gagbo]

I see, I got that part working I think, I'll still be using a custom-made API wrapper: it seems that the default middleware uses standard library time to get the date (which is expected), but that also means that on wasm targets (probably without bindgen), that leads to a panic CloudWatch panic: panicked at 'time not implemented on this platform', library/std/src/sys/wasm/../unsupported/time.rs:31:9.

At least, for the record, here's what I ended up with:

use aws_sdk_cloudwatch::Client;
/// Build an AWS SDK Cloudwatch client relying on runtime provided http client.
pub async fn new_client(config: Config) -> Client {
    let shared_config = config.generate_sdk_config().await;
    let config = aws_sdk_cloudwatch::config::Builder::from(&shared_config)
        .retry_config(RetryConfig::disabled())
        .build();

    Client::from_conf_conn(config, Adapter::new())
}

[jdisanti]

I suspect it's grabbing the time to create the SigV4 signature. Currently, we have a AsyncSleep trait for making the async sleep implementation configurable. I'm now thinking maybe we should rename that to AsyncTimer or something, and give it the ability to both sleep and tell time so that this use-case is supportable.

[amitu]

@gagbo I am also going to try to use aws sdk in wasm environment (wasm32-unknown-unknown), how did it go for you eventually?

[gagbo]

I rewrote the deserialization/serialization/signature from scratch on every endpoint I wanted to use, see for example https://github.com/fiberplane/providers/blob/main/providers/cloudwatch/src/client/cloudwatch.rs and https://github.com/fiberplane/providers/blob/main/providers/cloudwatch/src/client/canonical_request.rs

Note that since then, I thought the AWS SDK got rid of the version of ring that was triggering the compilation issues for the wasm32-unknown-unknown targets. Maybe just compiling will work

EDIT: Or rather. as mentionned above, that a trait was created (AsyncTimer but it might have changed name) that allows to inject your time function into the SDK