try {
            rateLimiter.checkAttempt(username, ip);
            fail("Should be locked out");
        } catch (SmbException e) {
            // Expected
        }

        // Wait for lockout to expire
        Thread.sleep(2100); // Lockout is 2 seconds in test setup

        // Should be allowed again
        assertTrue(rateLimiter.checkAttempt(username, ip), "Should be allowed after lockout expiry");

		return nil, err
	}

	return obj, nil
}

// TransferError will catch network errors during transfer.
// When TransferError() is called Close() will also
// be called, so we do not need to Wait() here.
func (w *writerAt) TransferError(err error) {
	_ = w.w.CloseWithError(err)
	_ = w.r.CloseWithError(err)
	w.err = err
}

func (w *writerAt) Close() (err error) {
	switch {

						Name:    volInfo.Name,
						Created: volInfo.Created,
						count:   1,
					}, false
				})
			}

			return nil
		}, index)
	}

	if err := reduceReadQuorumErrs(ctx, g.Wait(), bucketMetadataOpIgnoredErrs, readQuorum); err != nil {
		return err
	}

	healBuckets.Range(func(volName string, volInfo VolInfo) bool {
		if volInfo.count < readQuorum {
			healBuckets.Delete(volName)
		}

 *   <li>Exception tracking and aggregation</li>
 *   <li>Request lifecycle monitoring through listener</li>
 * </ul>
 *
 * <p>By default, it will:</p>
 * <ul>
 *   <li>Retry up to 5 times</li>
 *   <li>Wait 500ms between retries</li>
 * </ul>
 *
 */
public class FaultTolerantClient implements CrawlerClient {

    /** Logger instance for this class */

                log.debug("Error closing server socket", e);
            }
        }

        if (serverThread != null) {
            try {
                serverThread.join(5000); // Wait up to 5 seconds
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }

        registrations.clear();

## Test the setup

The next time the backup job runs, you can use the  `mc admin trace myminio` command and verify traffic is flowing to the MinIO nodes. For Veeam Backup and Replication you will need to wait for the backup to complete to the performance tier before it migrates data to the capacity tier (i.e., MinIO).

```

		return http.ErrServerClosed
	}

	// Close underneath HTTP listener.
	srv.listenerMutex.Lock()
	err := srv.listener.Close()
	srv.listenerMutex.Unlock()
	if err != nil {
		return err
	}

	// Wait for opened connection to be closed up to Shutdown timeout.
	return nil
}

// UseIdleTimeout configure idle connection timeout
func (srv *Server) UseIdleTimeout(d time.Duration) *Server {
	srv.IdleTimeout = d

            return "Free up disk space or use a different location";
        case QUOTA:
            return "Contact administrator to increase quota limits";
        case LOCK:
            return "Release existing locks or wait for them to be released";
        case BUFFER:
            return "Reduce buffer usage or increase buffer pool size";
        case THREAD_POOL:
            return "Reduce concurrent operations or increase thread pool size";

2. Start Prometheus server and AlertManager
3. Bring down couple of MinIO instances to bring down the Erasure Set tolerance to -1 and verify the same with `mc admin prometheus metrics ALIAS | grep minio_cluster_health_erasure_set_status`
4. Wait for 5 mins (as alert is configured to be firing after 5 mins), and verify that you see an entry in webhook for the alert as well as in Prometheus console as shown below

```json
{
  "receiver": "web\\.hook",

		wg.Add(1)
		go func(key int) {
			defer wg.Done()
			if err := batch.Add(testItem); err != nil {
				t.Errorf("failed to add item %v; %v", key, err)
				return
			}
		}(i)
	}
	wg.Wait()

	batchLen := batch.Len()
	if batchLen != int(limit) {
		t.Fatalf("Expected batch.Len() %v; but got %v", limit, batchLen)
	}

	keys := store.List()
	if len(keys) > 0 {