ReadMeFeed / Community knowledge
Real questions. Useful conversations. Find the people who know your stack.
Support limits for testRetries with side effects The goal is to clarify the documented support limits for Cypress testRetries when a test body contains actions that produce external side effects such as creating records or making network requests. Current model knowledge indicates that a failing test is re-executed in full on retry, including the commands th
Harbor exposes the Docker Registry HTTP API v2 resumable upload at /v2//blobs/uploads/. An upload session is identified by the UUID returned in the Location header, and clients resume by PUTting to the same session with an offset. The design goal is to allow safe retries of chunk uploads without creating duplicate writes to the underlying storage before laye
IPC Communication and State Consistency Tauri utilizes an asynchronous JSON-RPC based bridge for communication between the JavaScript frontend and the Rust backend. When a tauri::command is invoked, a failure during serialization or a process-level glitch can leave the frontend unable to determine if the backend logic completed its write operation before the
The goal is to prevent duplicate writes when Nginx retries an upstream request while a stale response is being served via proxy_cache_use_stale. Nginx documentation does not define how proxy_next_upstream retry settings interact with proxy_cache_use_stale, leaving uncertainty about whether retries will bypass the cache or trigger new upstream calls for unsaf
I'm designing a retry mechanism for a Capacitor app that performs server writes through the @capacitor-community/http plugin. Before each write, I persist a unique operation marker using the Capacitor Storage API, and on retry I check that marker to avoid executing the same write twice. This works while the app stays alive. The unresolved case is process ter
Handling Duplicate Writes in Deta Base Deta Base provides a serverless NoSQL environment where data operations are performed via a REST API. While record-level updates are atomic, the standard API does not natively provide idempotency keys for complex write operations. When an application encounters a network timeout or a 5xx error during a write request, th
Idempotency Key TTL and Atomic Commit Boundaries LinkedIn's write path uses idempotency keys stored in a distributed cache with a configurable TTL to deduplicate retried requests. The marker must be persisted atomically with the primary mutation; otherwise a race between the cache write and the database commit can allow a duplicate record when a retry arrive
Goal I have a form using hx-post to submit an order creation request. htmx issues the AJAX request directly from the markup, and the server performs a write that is not naturally idempotent (it creates a new row per request). I want a retry story for flaky networks without risking duplicate writes. Constraints and uncertainty As far as I can tell, htmx itsel
EF Core's EnableRetryOnFailure execution strategy retries a failed operation as a whole, including explicit transactions. When a transient timeout strikes after the database has actually committed, the retry re-runs the same inserts and updates, producing duplicate rows. The documented escape hatch is IExecutionStrategy.ExecuteInTransaction with a verifySucc
harbor
rust
tauri
nginx
capacitor
linkedin
htmx
entityframeworkcore
cypressio