Add a generic bounded post commit operations framework

[abhisheknath2011]

Summary

Introduce a generic, best-effort post-commit operations framework in the internal catalog. This is pure infrastructure that lets arbitrary logic run after a successful table commit without the catalog knowing what that logic does, and without any such operation being able to destabilize the commit path.

Motivation (per review on #712): rather than a single-purpose "stats publisher" seam, model post-commit work as a collection of N operations with bounded guarantees. The business logic (commit-stats publishing) is added in follow-up PRs — this PR contains only the framework and its wiring.

Details

New abstractions (iceberg/openhouse/internalcatalog/.../internal/catalog/):

• PostCommitOperation — interface (getName(), execute(PostCommitContext));
  best-effort, interruptible contract that must never affect commit correctness.
• PostCommitContext — immutable value object carrying the committed TableIdentifier
  and TableMetadata; operations extract whatever they need.
• PostCommitOperationRunner (@component) owns the execution safety envelope:
  • Bounded concurrency & memory: fixed-size ThreadPoolExecutor with a bounded queue;
    daemon, named threads that time out when idle (an unused runner holds zero threads).
  • Drop-on-saturation: AbortPolicy sheds work (drop + metric) instead of blocking the
    committer or growing memory unbounded.
  • Hard per-operation timeout: a single-thread timeoutScheduler cancels/interrupts any
    op exceeding the configured timeout, so a slow/hung op cannot pin a worker.
  • Failure isolation: each op runs independently; runAll() never throws.
  • Uniform observability: submitted / success / failed / timeout / rejected counters,
    tagged by operation name.
  • Configurable via cluster.tables.postcommit.{max-threads,queue-capacity,operation-timeout-ms}
    (defaults 4 / 1000 / 10000ms).

Wiring:

• OpenHouseInternalCatalog autowires the runner and passes it into newTableOps.
• OpenHouseInternalTableOperations invokes runner.runAll(...) only in the doCommit
  finally SUCCESS branch, so operations fire only after a durably successful commit.
  A backward-compatible 7-arg constructor keeps the runner optional (null-guarded), so
  existing callers/tests are unaffected.

No behavioral change for OSS/dev: those deployments register zero PostCommitOperation
beans, so runAll is a no-op.

Example operation (illustrative)

Adding post-commit behavior is just a Spring bean — no changes to the catalog or
OpenHouseInternalTableOperations. The runner auto-collects every PostCommitOperation
into its List, so presence of the bean is the only switch.

@Component
@Profile("!dev") // production only; OSS/dev registers no ops, so runAll(...) is a no-op
public class CommitStatsPublishOperation implements PostCommitOperation {

  private final CommitStatsPublisher publisher; // transport to the stats/optimizer service

  @Autowired public CommitStatsPublishOperation(CommitStatsPublisher publisher) {
    this.publisher = publisher; }

  @Override public String getName() {
    return "commit-stats-publish"; // low-cardinality; tags all metrics/logs }

  @Override public void execute(PostCommitContext context) {
    Snapshot snapshot = context.getCommittedMetadata().currentSnapshot();
    if (snapshot == null) {
      return;
    }
    Map<String, String> summary = snapshot.summary();
    CommitStats stats =
        CommitStats.builder()
            .tableId(context.getTableIdentifier().toString())
            .snapshotId(snapshot.snapshotId())
            .totalDataFiles(Long.parseLong(summary.getOrDefault("total-data-files", "0")))
            .totalFileSizeBytes(Long.parseLong(summary.getOrDefault("total-files-size", "0")))
            .build();
    publisher.publish(stats); // best-effort; runner enforces timeout + isolation }
}

The runner handles the hard parts around this bean: bounded async execution, the per-op
timeout (interrupts a stuck  publish ), failure isolation, and success/failed/timeout/
rejected metrics tagged  name="commit-stats-publish" . The real implementation lands in a
follow-up PR stacked on this one.

Issue] Briefly discuss the summary of the changes made in this
pull request in 2-3 lines.

Changes

• Client-facing API Changes
• Internal API Changes
• Bug Fixes
• New Features
• Performance Improvements
• Code Style
• Refactoring
• Documentation
• Tests

For all the boxes checked, please include additional details of the changes made in this pull request.

Testing Done

• New PostCommitOperationRunnerTest: runs all registered ops, isolates a throwing op,
  enforces the per-op timeout (interrupts a slow op), drops overflow work when the pool is
  saturated (rejected metric), and is a safe no-op for null context / empty op list.
• New OpenHouseInternalTableOperationsTest cases: post-commit ops run exactly once on a
  successful commit (context carries identity + committed metadata) and do NOT run on a
  failed commit.
• Full :iceberg:openhouse:internalcatalog:test suite passes (Java 17).

• Manually Tested on local docker setup. Please include commands ran, and their output.
• Added new tests for the changes made.
• Updated existing tests to reflect the changes made.
• No tests added or updated. Please explain why. If unsure, please feel free to ask for help.
• Some other form of testing like staging or soak time in production. Please explain.

For all the boxes checked, include a detailed description of the testing done for the changes made in this pull request.

Additional Information

• Breaking Changes
• Deprecations
• Large PR broken into smaller PRs, and PR plan linked in the description.

For all the boxes checked, include additional details of the changes made in this pull request.

[mkuchenbecker]

Can we see an example stacked on top?

[abhisheknath2011]

Can we see an example stacked on top?

Yes added example usage in the PR description.