What causes "Failed to hash content of " in quarkusio/quarkus?

Re-run the build — transient IO errors or races with a concurrent clean usually resolve on retry

quarkusio/quarkus · error · UncheckedIOException

Failed to hash content of

Error message

Failed to hash content of

What it means

ToolingUtils.sha1() streams a file through a SHA-1 MessageDigest to fingerprint local artifacts (with caching by path/mtime/size). If reading the file throws an IOException — file deleted between the exists() check and open, permission denied, or a filesystem/IO error — the IOException is wrapped in an UncheckedIOException so callers that handle only Unchecked exceptions are not forced to catch IOException. The message includes the file path being hashed.

Source

Thrown at devtools/gradle/gradle-model/src/main/java/io/quarkus/gradle/tooling/ToolingUtils.java:283

            return cached.hash();
        }
        final String hash = sha1(file);
        DIGEST_CACHE.put(f.getAbsolutePath(), new FileDigest(lastModified, length, hash));
        return hash;
    }

    /**
     * Computes the hex-encoded SHA-1 of a file's content, streaming it without loading it into memory.
     */
    private static String sha1(Path file) {
        final MessageDigest digest = sha1Digest();
        try (InputStream in = Files.newInputStream(file)) {
            final byte[] buffer = new byte[8192];
            for (int read = in.read(buffer); read >= 0; read = in.read(buffer)) {
                digest.update(buffer, 0, read);
            }
        } catch (IOException e) {
            throw new UncheckedIOException("Failed to hash content of " + file, e);
        }
        return HexFormat.of().formatHex(digest.digest());
    }

    private static MessageDigest sha1Digest() {
        try {
            return MessageDigest.getInstance("SHA-1");
        } catch (NoSuchAlgorithmException e) {
            throw new IllegalStateException(e);
        }
    }
}

View on GitHub (pinned to e1c734241f)

Solutions

Re-run the build — transient IO errors or races with a concurrent clean usually resolve on retry
Verify the file exists and is readable by the Gradle daemon user (ls -l, check permissions/ACLs)
Check the cause chain (e.getCause()) to distinguish FileNotFoundException (deleted/moved) from AccessDeniedException (permissions)
Exclude conflicting concurrent tasks (clean running alongside quarkus tooling) or disable build caches that prune files mid-build
Check disk/filesystem health if the error persists on different files

Example fix

// before (no guard)
String hash = ToolingUtils.hash(path);
// after (caller-side guard)
if (!Files.isReadable(path)) {
    throw new IllegalStateException("Cannot read artifact for hashing: " + path);
}
try {
    String hash = ToolingUtils.hash(path);
} catch (UncheckedIOException e) {
    if (e.getCause() instanceof NoSuchFileException) {
        hash = ToolingUtils.hash(path); // re-created after concurrent clean
    } else throw e;
}

Defensive patterns

Strategy: try-catch

Validate before calling

if (!Files.isReadable(file)) {
    throw new IllegalStateException("Cannot hash unreadable file: " + file);
}
try (var in = Files.newInputStream(file)) { /* probe open */ }

Try / catch

try {
    String hash = ToolingUtils.hash(file);
} catch (UncheckedIOException e) {
    if (e.getCause() instanceof NoSuchFileException || e.getCause() instanceof AccessDeniedException) {
        // recover: re-check existence/permissions and retry once
    } else throw new RuntimeException("Hashing failed for " + file, e);
}

Prevention

Verify file readability before hashing
Avoid running clean tasks concurrently with Quarkus tooling tasks
Watch the cause chain: NoSuchFileException vs AccessDeniedException point to different fixes
Keep artifact caches on healthy local filesystems, not flaky network mounts

When it happens

Trigger: Calling ToolingUtils.hash(file) (via sha1) on a file that disappears mid-build (concurrent clean), on a file without read permission, or when the underlying filesystem fails during streaming (e.g. network mount dropped).

Common situations: Gradle daemon builds where a clean task or another process deletes a dependency JAR while Quarkus tooling hashes it; read-protected files under a user cache directory; NFS/overlayfs transient IO errors in CI containers.

Understand the failure class

Background: "failed to read file", EACCES, ENOENT and "could not read <path>" errors: when a program can't read a file from disk — this error's family across 49 libraries.

Related errors

AI-assisted analysis of quarkusio/quarkus@e1c734241f (2026-09-05). Data as JSON: /api/errors/1d4870c55aed76ed. Report an issue: GitHub.