Allow running the client on wasm32 targets using fetch() for http requests

Author: swallez

.gitignore

@@ -1,4 +1,5 @@
-/target
+target
+pkg
 **/*.rs.bk
 Cargo.lock
 

elasticsearch/src/http/transport.rs

@@ -18,9 +18,9 @@
  */
 //! HTTP transport and connection components
 
-#[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+#[cfg(all(any(feature = "native-tls", feature = "rustls-tls"), not(target_arch = "wasm32")))]
 use crate::auth::ClientCertificate;
-#[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+#[cfg(all(any(feature = "native-tls", feature = "rustls-tls"), not(target_arch = "wasm32")))]
 use crate::cert::CertificateValidation;
 use crate::{
     auth::Credentials,
@@ -134,10 +134,13 @@ pub struct TransportBuilder {
     client_builder: reqwest::ClientBuilder,
     conn_pool: Box<dyn ConnectionPool>,
     credentials: Option<Credentials>,
-    #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+    #[cfg(all(any(feature = "native-tls", feature = "rustls-tls"), not(target_arch = "wasm32")))]
     cert_validation: Option<CertificateValidation>,
+    #[cfg(not(target_arch = "wasm32"))]
     proxy: Option<Url>,
+    #[cfg(not(target_arch = "wasm32"))]
     proxy_credentials: Option<Credentials>,
+    #[cfg(not(target_arch = "wasm32"))]
     disable_proxy: bool,
     headers: HeaderMap,
     meta_header: bool,
@@ -155,10 +158,13 @@ impl TransportBuilder {
             client_builder: reqwest::ClientBuilder::new(),
             conn_pool: Box::new(conn_pool),
             credentials: None,
-            #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+            #[cfg(all(any(feature = "native-tls", feature = "rustls-tls"), not(target_arch = "wasm32")))]
             cert_validation: None,
+            #[cfg(not(target_arch = "wasm32"))]
             proxy: None,
+            #[cfg(not(target_arch = "wasm32"))]
             proxy_credentials: None,
+            #[cfg(not(target_arch = "wasm32"))]
             disable_proxy: false,
             headers: HeaderMap::new(),
             meta_header: true,
@@ -170,6 +176,7 @@ impl TransportBuilder {
     ///
     /// An optional username and password will be used to set the
     /// `Proxy-Authorization` header using Basic Authentication.
+    #[cfg(not(target_arch = "wasm32"))]
     pub fn proxy(mut self, url: Url, username: Option<&str>, password: Option<&str>) -> Self {
         self.proxy = Some(url);
         if let Some(u) = username {
@@ -183,6 +190,7 @@ impl TransportBuilder {
     /// Whether to disable proxies, including system proxies.
     ///
     /// NOTE: System proxies are enabled by default.
+    #[cfg(not(target_arch = "wasm32"))]
     pub fn disable_proxy(mut self) -> Self {
         self.disable_proxy = true;
         self
@@ -197,7 +205,7 @@ impl TransportBuilder {
     /// Validation applied to the certificate provided to establish a HTTPS connection.
     /// By default, full validation is applied. When using a self-signed certificate,
     /// different validation can be applied.
-    #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+    #[cfg(all(any(feature = "native-tls", feature = "rustls-tls"), not(target_arch = "wasm32")))]
     pub fn cert_validation(mut self, validation: CertificateValidation) -> Self {
         self.cert_validation = Some(validation);
         self
@@ -248,11 +256,12 @@ impl TransportBuilder {
             client_builder = client_builder.default_headers(self.headers);
         }
 
+        #[cfg(not(target_arch = "wasm32"))]
         if let Some(t) = self.timeout {
             client_builder = client_builder.timeout(t);
         }
 
-        #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+        #[cfg(all(any(feature = "native-tls", feature = "rustls-tls"), not(target_arch = "wasm32")))]
         {
             if let Some(creds) = &self.credentials {
                 if let Credentials::Certificate(cert) = creds {
@@ -276,7 +285,7 @@ impl TransportBuilder {
             };
         }
 
-        #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
+        #[cfg(all(any(feature = "native-tls", feature = "rustls-tls"), not(target_arch = "wasm32")))]
         if let Some(v) = self.cert_validation {
             client_builder = match v {
                 CertificateValidation::Default => client_builder,
@@ -296,6 +305,7 @@ impl TransportBuilder {
             }
         }
 
+        #[cfg(not(target_arch = "wasm32"))]
         if self.disable_proxy {
             client_builder = client_builder.no_proxy();
         } else if let Some(url) = self.proxy {
@@ -402,6 +412,7 @@ impl Transport {
         headers: HeaderMap,
         query_string: Option<&Q>,
         body: Option<B>,
+        #[allow(unused_variables)]
         timeout: Option<Duration>,
     ) -> Result<Response, Error>
     where
@@ -413,6 +424,7 @@ impl Transport {
         let reqwest_method = self.method(method);
         let mut request_builder = self.client.request(reqwest_method, url);
 
+        #[cfg(not(target_arch = "wasm32"))]
         if let Some(t) = timeout {
             request_builder = request_builder.timeout(t);
         }
@@ -422,7 +434,23 @@ impl Transport {
         // on a specific request, we want it to overwrite.
         if let Some(c) = &self.credentials {
             request_builder = match c {
-                Credentials::Basic(u, p) => request_builder.basic_auth(u, Some(p)),
+                Credentials::Basic(u, p) => {
+                    #[cfg(not(target_arch = "wasm32"))]
+                    {
+                        request_builder.basic_auth(u, Some(p))
+                    }
+                    #[cfg(target_arch = "wasm32")]
+                    {
+                        // Missing basic_auth in the wasm32 target
+                        let mut header_value = b"Basic ".to_vec();
+                        {
+                            let mut encoder = Base64Encoder::new(&mut header_value, base64::STANDARD);
+                            // The unwraps here are fine because Vec::write* is infallible.
+                            write!(encoder, "{}:{}", u, p).unwrap();
+                        }
+                        request_builder.header(reqwest::header::AUTHORIZATION, header_value)
+                    }
+                },
                 Credentials::Bearer(t) => request_builder.bearer_auth(t),
                 #[cfg(any(feature = "native-tls", feature = "rustls-tls"))]
                 Credentials::Certificate(_) => request_builder,

elasticsearch/src/lib.rs

@@ -150,7 +150,7 @@
 //! # }
 //! ```
 //!
-//! More control over how a [Transport](http::transport::Transport) is built can be
+//! More control over how a [e](http::transport::Transport) is built can be
 //! achieved using [TransportBuilder](http::transport::TransportBuilder) to build a transport, and
 //! passing it to [Elasticsearch::new] create a new instance of [Elasticsearch]
 //!
@@ -370,10 +370,12 @@ mod readme {
 extern crate dyn_clone;
 
 pub mod auth;
-pub mod cert;
 pub mod http;
 pub mod params;
 
+#[cfg(not(target_arch = "wasm32"))]
+pub mod cert;
+
 // GENERATED-BEGIN:namespace-modules
 // Generated code - do not edit until the next GENERATED-END marker
 

examples/README.md

@@ -0,0 +1,3 @@
+This directory contains standalone examples that need their own independent build configuration.
+
+Other examples can also be found in [`elasticsearch/examples`](../elasticsearch/examples/).

examples/cloudflare_worker/.gitignore

@@ -0,0 +1,4 @@
+/target
+**/*.rs.bk
+wasm-pack.log
+build/

examples/cloudflare_worker/Cargo.toml

@@ -0,0 +1,34 @@
+[package]
+name = "example_cloudflare_worker"
+version = "0.1.0"
+publish = false
+authors = ["Elastic and Contributors"]
+edition = "2018"
+
+[workspace] # not part of the parent workspace
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[features]
+default = ["console_error_panic_hook"]
+
+[dependencies]
+cfg-if = "0.1.2"
+worker = "0.0.9"
+serde_json = "1.0"
+web-sys = { version = "0.3", features = ["console"] }
+
+elasticsearch = { path = "../../elasticsearch" }
+serde = "1.0"
+url = "2.2"
+
+# The `console_error_panic_hook` crate provides better debugging of panics by
+# logging them with `console.error`. This is great for development, but requires
+# all the `std::fmt` and `std::panicking` infrastructure, so isn't great for
+# code size when deploying.
+console_error_panic_hook = { version = "0.1.1", optional = true }
+
+[profile.release]
+# Tell `rustc` to optimize for small code size.
+opt-level = "s"

examples/cloudflare_worker/README.md

@@ -0,0 +1,19 @@
+# Cloudflare workers
+
+Example using [Cloudflare workers](https://workers.cloudflare.com/). Workers are Javascript function-as-a-service that can run WebAssembly. The [`wrangler` CLI](https://developers.cloudflare.com/workers/) provides everything to compile workers, test them locally and deploy them to Cloudflare.
+
+After setting up the `wrangler` CLI, run locally with:
+
+```
+wrangler secret put ES_URL
+<enter elasticsearch url>
+
+wrangler secret put ES_LOGIN
+<enter elasticsearch login>
+
+wrangler secret put ES_PASSWORD
+<enter elasticsearch password>
+
+wrangler dev
+```
+

examples/cloudflare_worker/src/lib.rs

@@ -0,0 +1,88 @@
+use worker::*;
+use serde::Deserialize;
+use serde::Serialize;
+use elasticsearch::Elasticsearch;
+
+mod utils;
+
+// Types returned by the 'info' endpoint
+#[derive(Debug, Serialize, Deserialize)]
+pub struct VersionInfo {
+    pub number: String,
+    pub build_date: String,
+    pub build_hash: String,
+    pub build_snapshot: bool
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct InfoResponse {
+    pub name: String,
+    pub cluster_name: String,
+    pub version: VersionInfo,
+    pub tagline: String,
+}
+
+// Global application context
+struct AppContext {
+    pub es_client: Elasticsearch,
+}
+
+#[event(fetch)]
+pub async fn main(req: Request, env: Env, _ctx: worker::Context) -> Result<Response> {
+    log_request(&req);
+
+    // Optionally, get more helpful error messages written to the console in the case of a panic.
+    utils::set_panic_hook();
+
+    // Fetch secrets and create ES client
+    let url =  env.secret("ES_URL")?.to_string();
+    let login =  env.secret("ES_LOGIN")?.to_string();
+    let password =  env.secret("ES_PASSWORD")?.to_string();
+
+    let router = Router::with_data(AppContext {
+        es_client: create_client(url, login, password)
+            .map_err(|e| Error::RustError(e.to_string()))?
+    });
+
+    // HTTP request router
+    router
+        .get("/", |_, _| {
+            Response::from_html("Hello from Workers! Please go to <a href='/es'>/es</a>")
+        })
+        .get_async("/es", |mut req, ctx| async move {
+            let result = call_es(ctx.data.es_client).await
+                .map_err(|e| Error::RustError(e.to_string()))?;
+            Response::ok(result)
+        })
+        .run(req, env)
+        .await
+}
+
+fn create_client(url: String, login: String, password: String) -> StdResult<Elasticsearch, elasticsearch::Error> {
+
+    let url = url::Url::parse(&url)?;
+    let pool = elasticsearch::http::transport::SingleNodeConnectionPool::new(url);
+    let credentials = elasticsearch::auth::Credentials::Basic(login.into(), password.into());
+    let transport = elasticsearch::http::transport::TransportBuilder::new(pool)
+        .auth(credentials)
+        .build()?;
+
+    Ok(Elasticsearch::new(transport))
+}
+
+pub async fn call_es(client: Elasticsearch) -> std::result::Result<String, elasticsearch::Error> {
+    let response = client.info().send().await?;
+    let info = response.json::<InfoResponse>().await?;
+
+    Ok(format!("version: {}, build_date: {}", info.version.number, info.version.build_date))
+}
+
+fn log_request(req: &Request) {
+    console_log!(
+        "{} - [{}], located at: {:?}, within: {}",
+        Date::now().to_string(),
+        req.path(),
+        req.cf().coordinates().unwrap_or_default(),
+        req.cf().region().unwrap_or("unknown region".into())
+    );
+}

examples/cloudflare_worker/src/utils.rs

@@ -0,0 +1,12 @@
+use cfg_if::cfg_if;
+
+cfg_if! {
+    // https://github.com/rustwasm/console_error_panic_hook#readme
+    if #[cfg(feature = "console_error_panic_hook")] {
+        extern crate console_error_panic_hook;
+        pub use self::console_error_panic_hook::set_once as set_panic_hook;
+    } else {
+        #[inline]
+        pub fn set_panic_hook() {}
+    }
+}

examples/cloudflare_worker/wrangler.toml

@@ -0,0 +1,27 @@
+name = "cloudflare_worker"
+type = "javascript"
+workers_dev = true
+compatibility_date = "2022-04-06"
+
+[vars]
+WORKERS_RS_VERSION = "0.0.9"
+
+# Secrets:
+# ES_URL
+# ES_LOGIN
+# ES_PASSWORD
+
+[build]
+command = "cargo install -q worker-build && worker-build --release" # required
+
+[build.upload]
+dir = "build/worker"
+format = "modules"
+main = "./shim.mjs"
+
+[[build.upload.rules]]
+globs = ["**/*.wasm"]
+type = "CompiledWasm"
+
+# read more about configuring your Worker via wrangler.toml at:
+# https://developers.cloudflare.com/workers/cli-wrangler/configuration