apache/cassandra · error · InconsistentEntryException

{} durability: refusing to report {} ({}): a failed update b

Error message

{} durability: refusing to report {} ({}): a failed update blocks progress for {}

What it means

Accord durability reporting refuses to report a cache entry as durable when the entry is 'inconsistent' (a failed update), because acknowledging durability would block progress for that key. It throws InconsistentEntryException instead of reporting a false durable state.

Source

Thrown at src/java/org/apache/cassandra/service/accord/AccordCommandStore.java:702

        logger.debug("{} durability: ensuring for {} ({})", this, onCommandStoreDurable, reportId);
        executor().afterSubmittedAndConsequences(() -> {
            logger.debug("{} durability: saving intersecting keys ({})", this, reportId);
            class Ready extends CountingResult implements BiConsumer<Void, Throwable>
            {
                public Ready() { super(1); }

                @Override
                public void accept(Void success, Throwable failure)
                {
                    if (failure == null) decrement();
                    else tryFailure(failure);
                }

                void maybeFlush(ExclusiveCaches caches, AccordCacheEntry<RoutingKey, CommandsForKey, ?> e)
                {
                    if (e.isInconsistent())
                    {
                        noSpamLogger.warn("{} durability: refusing to report {} ({}): a failed update blocks progress for {}",
                                          AccordCommandStore.this, onCommandStoreDurable, reportId, e.key());
                        throw new InconsistentEntryException(e.key());
                    }

                    if (e.isModified())
                    {
                        increment();
                        caches.global().saveWhenReadyExclusive(e, this);
                    }
                }
            }

            Ready ready = new Ready();
            try (ExclusiveCaches caches = lockCaches())
            {
                int count = 0;
                if (ranges == null)
                {

View on GitHub (pinned to 88fd0f6a0e)

Solutions

1. Inspect the failing key's journal state; let Accord retry/reconcile the failed update
2. Restart the node so the entry is reloaded from the journal rather than the cache
3. If persistent, report to the project - may indicate a journal consistency bug

catch (InconsistentEntryException e) { /* let Accord retry the key's updates; do not treat as fatal */ }

When it happens

Trigger: maybeFlush during journal durability processing encounters a CommandsForKey cache entry marked inconsistent (a failed update) that is the report target.

Common situations: Accord transactions that partially failed leaving inconsistent journal entries; nodes recovering from crashes with failed writes in the durability pipeline.

Understand the failure class

Background: "This is a bug, please report it": internal invariant violations, unreachable panics, and SNH errors explained — this error's family across 47 libraries.

Related errors

• Stop marker is older than start marker ({stopMarker}<{startM
• Stop marker is older than start marker ({}<{}), so cannot as
• Cannot reset state and replay from a save point; must modify
• Cannot return configuration when accord.enabled = false in c
• Gave up waiting on journal index to be ready

AI-assisted analysis of apache/cassandra@88fd0f6a0e (2026-09-10). Data as JSON: /api/errors/7a406352062efd9b. Report an issue: GitHub.