Kepler.gl is a powerful open source geospatial analysis tool for large-scale data sets.
fix: propagate Zarr tile cancellation to chunk requests (#3946)
Igor Dykhta81829b8c6dde
diff --git a/src/layers/src/zarr-layer/zarr-layer.ts b/src/layers/src/zarr-layer/zarr-layer.tsindex 074682946..a48fd6e65 100644--- a/src/layers/src/zarr-layer/zarr-layer.ts+++ b/src/layers/src/zarr-layer/zarr-layer.ts@@ -706,11 +706,25 @@ export default class ZarrLayer extends Layer {private _createTileDataLoader() {const getTileData = async (arr: zarr.Array<zarr.DataType, zarr.Readable>,- {sliceSpec, width, height}: {sliceSpec: unknown; width: number; height: number}+ {+ sliceSpec,+ width,+ height,+ signal+ }: {+ sliceSpec: unknown;+ width: number;+ height: number;+ signal?: AbortSignal;+ }): Promise<ZarrTileData> => {+ signal?.throwIfAborted();const {nodataValue, needsSampling} = this._tileContext;const {get} = await this._loadRuntime();- const chunk = await get(arr, sliceSpec as any);+ signal?.throwIfAborted();+ const chunk = await get(arr, sliceSpec as any, {signal});+ // An already-running decoder may finish after cancellation.+ signal?.throwIfAborted();const values = (chunk as {data: ArrayLike<number | bigint>}).data;// A callback belongs to one source opening. Even after switching A -> B// -> A, an older request must not set the current source's color range.diff --git a/test/browser/layer-tests/zarr-layer-specs.js b/test/browser/layer-tests/zarr-layer-specs.jsindex 7f71a0639..eb84fa714 100644--- a/test/browser/layer-tests/zarr-layer-specs.js+++ b/test/browser/layer-tests/zarr-layer-specs.js@@ -2,6 +2,7 @@// Copyright contributors to the kepler.gl projectimport test from 'tape-catch';+import * as zarr from 'zarrita';import {KeplerGlLayers,findNearestTimeIndex,@@ -1255,3 +1256,124 @@ test('#ZarrLayer -> renderLayer returns nothing before the store opens', t => {t.end();});++test('#ZarrLayer -> rejects cancellation before or during runtime loading', async t => {+ for (const preAborted of [true, false]) {+ const layer = new ZarrLayer({dataId: 'zarr-cancellation'});+ const controller = new AbortController();+ let runtimeCalls = 0;+ let getCalls = 0;+ let releaseRuntime;+ layer._loadRuntime = async () => {+ runtimeCalls++;+ await new Promise(resolve => {+ releaseRuntime = resolve;+ });+ return {+ get: async () => {+ getCalls++;+ return {data: new Float32Array([1, 2])};+ }+ };+ };+ if (preAborted) controller.abort();+ const result = layer+ ._getTileData({}, {sliceSpec: [], width: 2, height: 1, signal: controller.signal})+ .catch(error => error);+ controller.abort();+ releaseRuntime?.();+ t.equal((await result).name, 'AbortError', 'cancelled request rejects with AbortError');+ t.equal(runtimeCalls, preAborted ? 0 : 1, 'pre-aborted request skips runtime loading');+ t.equal(getCalls, 0, 'cancelled request never starts reading chunks');+ t.equal(layer._sampledRange, null, 'cancelled request does not update sampled range');+ }+ t.end();+});++test('#ZarrLayer -> passes cancellation through zarrita to the FetchStore request', async t => {+ const memory = new Map();+ const source = await zarr.create(memory, {+ shape: [1, 2],+ chunkShape: [1, 2],+ dtype: 'float32',+ codecs: [{name: 'bytes', configuration: {endian: 'little'}}]+ });+ await zarr.set(source, null, {data: new Float32Array([1, 2]), shape: [1, 2], stride: [2, 1]});+ let pending = false;+ let chunkRequest;+ let startRequest;+ let releaseRequest;+ const started = new Promise(resolve => {+ startRequest = resolve;+ });+ const store = new zarr.FetchStore('https://example.com/', {+ fetch: async request => {+ const bytes = memory.get(new URL(request.url).pathname);+ if (!bytes) return new Response(null, {status: 404});+ if (!pending || request.url.endsWith('zarr.json')) return new Response(bytes);+ chunkRequest = request;+ startRequest();+ return new Promise((resolve, reject) => {+ const onAbort = () => reject(request.signal.reason);+ request.signal.addEventListener('abort', onAbort, {once: true});+ releaseRequest = () => {+ request.signal.removeEventListener('abort', onAbort);+ resolve(new Response(bytes));+ };+ });+ }+ });+ const arr = await zarr.open(store, {kind: 'array'});+ const layer = new ZarrLayer({dataId: 'zarr-cancellation'});+ layer._loadRuntime = async () => ({get: zarr.get});+ const options = {sliceSpec: [null, null], width: 2, height: 1};+ const tile = await layer._getTileData(arr, options);+ t.deepEqual(Array.from(tile.values), [1, 2], 'normal requests decode values');+ t.equal(tile.byteLength, 8, 'normal requests preserve byte accounting');+ pending = true;+ const controller = new AbortController();+ const result = layer+ ._getTileData(arr, {...options, signal: controller.signal})+ .catch(error => error);+ await started;+ controller.abort();+ t.ok(chunkRequest.signal.aborted, 'the underlying fetch request receives the abort');+ releaseRequest();+ t.equal(+ (await result).name,+ 'AbortError',+ 'in-flight cancellation rejects instead of returning a tile'+ );+ t.end();+});++test('#ZarrLayer -> preserves genuine read errors and rejects late cancelled results', async t => {+ const layer = new ZarrLayer({dataId: 'zarr-cancellation'});+ const readError = new Error('chunk read failed');+ layer._loadRuntime = async () => ({+ get: async () => {+ throw readError;+ }+ });+ const options = {sliceSpec: [], width: 2, height: 1};+ t.equal(+ await layer._getTileData({}, options).catch(error => error),+ readError,+ 'genuine errors reach deck unchanged'+ );+ const controller = new AbortController();+ layer._tileContext = {...layer._tileContext, needsSampling: true};+ layer._loadRuntime = async () => ({+ get: async () => {+ // A decoder already running may finish even though the fetch signal was aborted.+ controller.abort();+ return {data: new Float32Array([1, 2])};+ }+ });+ const result = await layer+ ._getTileData({}, {...options, signal: controller.signal})+ .catch(error => error);+ t.equal(result.name, 'AbortError', 'late cancelled decode results are rejected');+ t.equal(layer._sampledRange, null, 'late cancelled results do not update sampled range');+ t.end();+});