if err != nil {
		atomic.AddInt64(&h.failedMessages, 1)
		return err
	}
	// Delete the event from store.
	return h.store.Del(key)
}

// Cancel - cancels the target
func (h *Target) Cancel() {
	// If queuestore is configured, cancel it's context to
	// stop the replay go-routine.
	if h.store != nil {
		h.storeCtxCancel()
	}

	// Set logch to nil and close it.

  }

  public void testListenerCalledOnCancelFromRunning() throws Exception {
    exec.execute(task);
    runLatch.await();

    // Task has started up, cancel it while it's running.
    task.cancel(true);
    assertTrue(task.isDone());
    assertTrue(task.isCancelled());
    assertEquals(1, taskLatch.getCount());

    // Wait for the listeners to be called.

  object : BufferedSocket {
    private val delegate = this@asBufferedSocket
    override val source = delegate.source.buffer()
    override val sink = delegate.sink.buffer()

    override fun cancel() {
      delegate.cancel()
    }

name: Helm Chart linting

on:
  pull_request:
    branches:
      - master

# This ensures that previous jobs for the PR are canceled when the PR is
# updated.
concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref }}
  cancel-in-progress: true

permissions:
  contents: read

jobs:
  release:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4

    val server = serverListener.assertOpen()

    // Initiate a close on the client, which will schedule a hard cancel in 500 ms.
    val closeAtNanos = System.nanoTime()
    webSocket.close(1000, "goodbye", 500L)
    serverListener.assertClosing(1000, "goodbye")

    // Confirm that the hard cancel occurred after 500 ms.
    clientListener.assertFailure()
    val elapsedUntilFailure = System.nanoTime() - closeAtNanos

  }

  public void testCancelled() throws Exception {
    TrustedListenableFutureTask<Integer> task = TrustedListenableFutureTask.create(returning(2));
    assertFalse(task.isDone());
    task.cancel(false);
    assertTrue(task.isDone());
    assertTrue(task.isCancelled());
    assertFalse(task.wasInterrupted());
    assertThrows(CancellationException.class, () -> getDone(task));
    verifyThreadWasNotInterrupted();

  override val isReady = false

  override fun connectTcp() = result

  override fun connectTlsEtc() = result

  override fun handleSuccess() = error("unexpected call")

  override fun cancel() = error("unexpected cancel")

  override fun retry() = error("unexpected retry")

	}

	// Start profiling on remote servers.
	for _, profiler := range profiles {
		// Limit start time to max 10s.
		ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
		globalNotificationSys.StartProfiling(ctx, profiler)
		// StartProfiling blocks, so we can cancel now.
		cancel()

		// Start profiling locally as well.
		prof, err := startProfiler(profiler)
		if err == nil {

 *       next task will wait for any running callable (or pending {@code Future} returned by an
 *       {@code AsyncCallable}) to complete, without interrupting it (and without calling {@code
 *       cancel} on the {@code Future}). So beware: <i>Even if you cancel every preceding {@code
 *       Future} returned by this class, the next task may still have to wait.</i>.
 *   <li>Once an {@code AsyncCallable} returns a {@code Future}, this class considers that task to

 *       next task will wait for any running callable (or pending {@code Future} returned by an
 *       {@code AsyncCallable}) to complete, without interrupting it (and without calling {@code
 *       cancel} on the {@code Future}). So beware: <i>Even if you cancel every preceding {@code
 *       Future} returned by this class, the next task may still have to wait.</i>.
 *   <li>Once an {@code AsyncCallable} returns a {@code Future}, this class considers that task to