graph: Speed up some tests by using shorter timeouts in debug builds

This also makes the timeouts used for IPFS requests configurable; the
default of 1s in debug builds is too short for the runner tests in CI and
we therefore set it to the 60s for release builds for those tests.

Author: lutter

.github/workflows/ci.yml

@@ -79,7 +79,8 @@ jobs:
         ports:
           - 5432:5432
     env:
-      RUSTFLAGS: "-C link-arg=-fuse-ld=lld -D warnings"
+      GRAPH_IPFS_REQUEST_TIMEOUT: "60"
+      RUSTFLAGS: "-C link-arg=-fuse-ld=lld -D warnings --cfg test_with_ipfs"
       RUNNER_TESTS_WAIT_FOR_SYNC_SECS: "600"
     steps:
       - name: Tune GitHub hosted runner to reduce flakiness

graph/src/env/mod.rs

@@ -248,6 +248,11 @@ pub struct EnvVars {
     /// Set by the environment variable `GRAPH_FIREHOSE_BLOCK_BATCH_SIZE`.
     /// The default value is 10.
     pub firehose_block_batch_size: usize,
+    /// Timeouts to use for various IPFS requests set by
+    /// `GRAPH_IPFS_REQUEST_TIMEOUT`. Defaults to 60 seconds for release
+    /// builds and one second for debug builds to speed up tests. The value
+    /// is in seconds.
+    pub ipfs_request_timeout: Duration,
 }
 
 impl EnvVars {
@@ -256,6 +261,16 @@ impl EnvVars {
         let graphql = InnerGraphQl::init_from_env()?.into();
         let mapping_handlers = InnerMappingHandlers::init_from_env()?.into();
         let store = InnerStore::init_from_env()?.try_into()?;
+        let ipfs_request_timeout = match inner.ipfs_request_timeout {
+            Some(timeout) => Duration::from_secs(timeout),
+            None => {
+                if cfg!(debug_assertions) {
+                    Duration::from_secs(1)
+                } else {
+                    Duration::from_secs(60)
+                }
+            }
+        };
 
         Ok(Self {
             graphql,
@@ -330,6 +345,7 @@ impl EnvVars {
             firehose_block_fetch_retry_limit: inner.firehose_block_fetch_retry_limit,
             firehose_block_fetch_timeout: inner.firehose_block_fetch_timeout,
             firehose_block_batch_size: inner.firehose_block_fetch_batch_size,
+            ipfs_request_timeout,
         })
     }
 
@@ -510,6 +526,8 @@ struct Inner {
     firehose_block_fetch_timeout: u64,
     #[envconfig(from = "GRAPH_FIREHOSE_FETCH_BLOCK_BATCH_SIZE", default = "10")]
     firehose_block_fetch_batch_size: usize,
+    #[envconfig(from = "GRAPH_IPFS_REQUEST_TIMEOUT")]
+    ipfs_request_timeout: Option<u64>,
 }
 
 #[derive(Clone, Debug)]

graph/src/ipfs/gateway_client.rs

@@ -1,5 +1,4 @@
 use std::sync::Arc;
-use std::time::Duration;
 
 use anyhow::anyhow;
 use async_trait::async_trait;
@@ -9,6 +8,7 @@ use http::header::CACHE_CONTROL;
 use reqwest::StatusCode;
 use slog::Logger;
 
+use crate::env::ENV_VARS;
 use crate::ipfs::IpfsClient;
 use crate::ipfs::IpfsError;
 use crate::ipfs::IpfsRequest;
@@ -17,10 +17,6 @@ use crate::ipfs::IpfsResult;
 use crate::ipfs::RetryPolicy;
 use crate::ipfs::ServerAddress;
 
-/// The request that verifies that the IPFS gateway is accessible is generally fast because
-/// it does not involve querying the distributed network.
-const TEST_REQUEST_TIMEOUT: Duration = Duration::from_secs(60);
-
 /// A client that connects to an IPFS gateway.
 ///
 /// Reference: <https://specs.ipfs.tech/http-gateways/path-gateway>
@@ -99,7 +95,7 @@ impl IpfsGatewayClient {
                 }
             });
 
-        let ok = tokio::time::timeout(TEST_REQUEST_TIMEOUT, fut)
+        let ok = tokio::time::timeout(ENV_VARS.ipfs_request_timeout, fut)
             .await
             .map_err(|_| anyhow!("request timed out"))??;
 
@@ -151,6 +147,8 @@ impl IpfsClient for IpfsGatewayClient {
 
 #[cfg(test)]
 mod tests {
+    use std::time::Duration;
+
     use bytes::BytesMut;
     use futures03::TryStreamExt;
     use wiremock::matchers as m;

graph/src/ipfs/retry_policy.rs

@@ -1,15 +1,10 @@
-use std::time::Duration;
-
 use slog::Logger;
 
 use crate::ipfs::error::IpfsError;
 use crate::prelude::*;
 use crate::util::futures::retry;
 use crate::util::futures::RetryConfig;
 
-/// The default maximum delay between retries.
-const DEFAULT_MAX_DELAY: Duration = Duration::from_secs(60);
-
 /// Describes retry behavior when IPFS requests fail.
 #[derive(Clone, Copy, Debug)]
 pub enum RetryPolicy {
@@ -33,7 +28,7 @@ impl RetryPolicy {
     ) -> RetryConfig<O, IpfsError> {
         retry(operation_name, logger)
             .limit(ENV_VARS.mappings.ipfs_max_attempts)
-            .max_delay(DEFAULT_MAX_DELAY)
+            .max_delay(ENV_VARS.ipfs_request_timeout)
             .when(move |result: &Result<O, IpfsError>| match result {
                 Ok(_) => false,
                 Err(err) => match self {

graph/src/ipfs/rpc_client.rs

@@ -9,6 +9,7 @@ use reqwest::Response;
 use reqwest::StatusCode;
 use slog::Logger;
 
+use crate::env::ENV_VARS;
 use crate::ipfs::IpfsClient;
 use crate::ipfs::IpfsError;
 use crate::ipfs::IpfsRequest;
@@ -17,10 +18,6 @@ use crate::ipfs::IpfsResult;
 use crate::ipfs::RetryPolicy;
 use crate::ipfs::ServerAddress;
 
-/// The request that verifies that the IPFS RPC API is accessible is generally fast because
-/// it does not involve querying the distributed network.
-const TEST_REQUEST_TIMEOUT: Duration = Duration::from_secs(60);
-
 /// A client that connects to an IPFS RPC API.
 ///
 /// Reference: <https://docs.ipfs.tech/reference/kubo/rpc>
@@ -60,7 +57,7 @@ impl IpfsRpcClient {
             server_address: ServerAddress::new(server_address)?,
             http_client: reqwest::Client::new(),
             logger: logger.to_owned(),
-            test_request_timeout: TEST_REQUEST_TIMEOUT,
+            test_request_timeout: ENV_VARS.ipfs_request_timeout,
         })
     }
 
@@ -88,7 +85,7 @@ impl IpfsRpcClient {
                 }
             });
 
-        let ok = tokio::time::timeout(TEST_REQUEST_TIMEOUT, fut)
+        let ok = tokio::time::timeout(ENV_VARS.ipfs_request_timeout, fut)
             .await
             .map_err(|_| anyhow!("request timed out"))??;