cube-js/cube · critical

not implemented

Error message

not implemented

What it means

CubeStore's cluster configuration maps FileStoreProvider variants to storage backends. FileStoreProvider::Local has no implementation in this code path (marked TODO), so selecting it panics with a bare unimplemented!().

Source

Thrown at rust/cubestore/cubestore/src/config/mod.rs:2554

                    })
                    .await;
            }
            FileStoreProvider::MINIO {
                bucket_name,
                sub_path,
            } => {
                let data_dir = self.config_obj.data_dir.clone();
                let bucket_name = bucket_name.to_string();
                let sub_path = sub_path.clone();
                self.injector
                    .register("original_remote_fs", async move |_| {
                        let arc: Arc<dyn DIService> =
                            MINIORemoteFs::new(data_dir, bucket_name, sub_path).unwrap();
                        arc
                    })
                    .await;
            }
            FileStoreProvider::Local => unimplemented!(), // TODO
        };
    }

    pub async fn configure_cache_store(&self) {
        let (cachestore_event_sender, _) = broadcast::channel(2048); // TODO config
        let cachestore_event_sender_to_move = cachestore_event_sender.clone();

        if uses_remote_metastore(&self.injector).await {
            self.injector
                .register_typed::<dyn CacheStore, _, _, _>(async move |_| {
                    Arc::new(ClusterCacheStoreClient {})
                })
                .await;
        } else {
            self.injector
                .register("cachestore_fs", async move |i| {
                    // TODO metastore works with non queue remote fs as it requires loops to be started prior to load_from_remote call
                    let original_remote_fs: Arc<dyn ExtendedRemoteFs> =

View on GitHub (pinned to 7d981676b3)

Solutions

1. Switch the config to FileStoreProvider::MinIO (or S3-compatible) with proper bucket_name/sub_path
2. Run storage via the supported MinIO/S3 backend instead of Local
3. If local storage is required, implement the Local arm or use a code path that supports it
4. Check the CubeStore version — local storage support may exist in other code paths

Example fix

// before
FileStoreProvider::Local => unimplemented!(),
// after
FileStoreProvider::Local => LocalFs::new(data_dir).await?,

match cfg.file_store_provider {
    FileStoreProvider::Local => return Err(anyhow!("Local file store not supported in this configuration; use MinIO/S3")),
    _ => {}
}

fn is_remote_storage(p: &FileStoreProvider) -> bool {
    matches!(p, FileStoreProvider::MinIO { .. })
}

match config_result {
    Err(e) if e.to_string().contains("not implemented") => init_minio_fallback().await?,
    other => other?,
}

When it happens

Trigger: Configuring CubeStore with file_store provider set to Local in a code path that only supports MinIO/S3 remote filesystems (the async configure routine in config/mod.rs).

Common situations: Deploying CubeStore with a local-disk storage provider config where the operator expects local storage to work but the distributed/remote setup path never implemented it; misconfigured store_type in the cluster config.

Related errors

• Cube Store request size of ${formatSize(buffer.length)} exce
• externalDriverFactory is not provided. Please use CUBEJS_DEV
• Request of {} bytes exceeds the maximum message size of {} b
• Could not parse environment variable '{}' with '{}' value: {
• wrong configuration for environment variable '{}' with '{}'

AI-assisted analysis of cube-js/cube@7d981676b3 (2026-09-02). Data as JSON: /api/errors/1fd8275b07450399. Report an issue: GitHub.