// Clear failover state on success
            failoverStates.remove(channel.getChannelId());

            log.info("Successfully recovered channel {}", channel.getChannelId());

        } catch (Exception e) {
            log.warn("Failed to recover channel {}: {}", channel.getChannelId(), e.getMessage());

            // Schedule next retry or remove
            handleFailure(channel, e);
        }

        
        PersistentHandleManager manager2 = new PersistentHandleManager(context);
        HandleInfo recovered = manager2.getHandleForReconnect("/test/file.txt");
        
        assertNotNull(recovered);
        assertEquals(HandleType.PERSISTENT, recovered.type);
        assertArrayEquals(fileId, recovered.fileId);
    }
}
```

### 8.2 Integration Tests
```java
@Test

                log.warn("RDMA recovery attempt {} failed: {}", retryCount, recoveryError.getMessage());

                // If this was the last attempt, log the full error
                if (retryCount >= maxRetries) {
                    log.error("All RDMA recovery attempts failed", recoveryError);
                }
            }
        }

  /**
   * Returns true if there's more route plans to try.
   *
   * @param failedConnection an optional connection that was resulted in a failure. If the failure
   *     is recoverable, the connection's route may be recovered for the retry.
   */
  fun hasNext(failedConnection: RealConnection? = null): Boolean

  /**
   * Returns true if the host and port are unchanged from when this was created. This is used to

mc: Encrypted file data successfully downloaded as inspect.ad2b43d8.enc
mc: Decryption key: ad2b43d847fdb14e54c5836200177f7158b3f745433525f5d23c0e0208e50c9948540b54

mc: The decryption key will ONLY be shown here. It cannot be recovered.
mc: The encrypted file can safely be shared without the decryption key.
mc: Even with the decryption key, data stored with encryption cannot be accessed.
```

This file can be decrypted using the decryption tool below:

      }
    }
  }

  /**
   * Report and attempt to recover from a failure to communicate with a server. Returns true if
   * `e` is recoverable, or false if the failure is permanent. Requests with a body can only
   * be recovered if the body is buffered or if the failure occurred before the request has been
   * sent.
   */
  private fun recover(
    e: IOException,
    call: RealCall,
    userRequest: Request,

 *
 * The circuit breaker has three states:
 * - CLOSED: Normal operation, requests pass through
 * - OPEN: Service is failing, requests are blocked
 * - HALF_OPEN: Testing if service has recovered
 */
public class SmbCircuitBreaker {

    private static final Logger log = LoggerFactory.getLogger(SmbCircuitBreaker.class);

    /**
     * Circuit breaker states
     */
    public enum State {

            } catch (Exception e) {
                log.error("Failed to recover RDMA connection", e);
                fallbackToTcp(connection);
            }
        } else {
            // Non-recoverable error, fall back to TCP
            fallbackToTcp(connection);
        }
    }
    
    private boolean isRecoverableError(Exception error) {

                failoverStates.remove(channel.getChannelId());
                
                log.info("Successfully recovered channel {}", channel.getChannelId());
                
            } catch (Exception e) {
                log.warn("Failed to recover channel {}: {}", 
                    channel.getChannelId(), e.getMessage());
                
                // Schedule next retry or remove

    `okhttp-tls` module.

 *  Upgrade: [Kotlin 1.3.71][kotlin_1_3_71].


## Version 4.5.0

_2020-04-06_

**This release fixes a severe bug where OkHttp incorrectly detected and recovered from unhealthy
connections.** Stale or canceled connections were incorrectly attempted when they shouldn't have
been, leading to rare cases of infinite retries. Please upgrade to this release!