subrouter.Methods(http.MethodPost).Path(peerRESTVersionPrefix + peerRESTMethodDevNull).HandlerFunc(h(server.DevNull))

	logger.FatalIf(consoleLogRPC.RegisterNoInput(gm, server.ConsoleLogHandler), "unable to register handler")
	logger.FatalIf(deleteBucketMetadataRPC.Register(gm, server.DeleteBucketMetadataHandler), "unable to register handler")

		var loi ListObjectsInfo
		merged, err := z.listPath(ctx, &opts)
		if err != nil && err != io.EOF {
			if !isErrBucketNotFound(err) {
				storageLogOnceIf(ctx, err, "erasure-list-objects-path-"+bucket)
			}
			return loi, toObjectErr(err, bucket)
		}
		merged.forwardPast(opts.Marker)
		defer merged.truncate(0) // Release when returning

		if contextCanceled(ctx) {

				for _, mergedV := range merged {
					if ver.header.VersionID == mergedV.header.VersionID {
						versions[i] = versions[i][1:]
						continue
					}
				}
				// Keep top entry (and remaining)...
				break
			}
		}

		if requestedVersions > 0 && requestedVersions == nVersions {
			merged = append(merged, versions[0]...)
			break
		}
	}

```

MinIO server also supports [NATS Streaming mode](http://nats.io/documentation/streaming/nats-streaming-intro/) that offers additional functionality like `At-least-once-delivery`, and `Publisher rate limiting`. To configure MinIO server to send notifications to NATS Streaming server, update the MinIO server configuration file as follows:

      ),
    )
    server.enqueue(MockResponse(body = "This is the new location!"))
    val call = client.newCall(Request(server.url("/")))
    val response = call.execute()
    assertThat(response.body.string()).isEqualTo("This is the new location!")
    val request1 = server.takeRequest()
    assertThat(request1.url.encodedPath).isEqualTo("/")
    val request2 = server.takeRequest()

 *  Fix: Don't leak a connection when a call is canceled immediately preceding the `onFailure()`
    callback.

 *  Fix: Apply call timeouts when connecting duplex calls, web sockets, and server-sent events.
    Once the streams are established no further timeout is enforced.

 *  Fix: Retain the `Route` when a connection is reused on a redirect or other follow-up. This was

                log.info("Initialized witness support with server: {}", witnessServer);
            }
        } catch (Exception e) {
            log.warn("Failed to initialize witness support", e);
        }
    }

    /**
     * Discover witness service for the current server
     *
     * @return witness server address or null if not found
     * @throws IOException if discovery fails

			<artifactId>jakarta.transaction-api</artifactId>
			<version>${jakarta.transaction.api.version}</version>
		</dependency>
		<dependency>
			<groupId>org.glassfish.jersey.core</groupId>
			<artifactId>jersey-common</artifactId>
			<version>${jersey.common.version}</version>
			<exclusions>
				<exclusion>
					<groupId>jakarta.annotation</groupId>
					<artifactId>jakarta.annotation-api</artifactId>
				</exclusion>

            context = SingletonContext.getInstance();
        }

        // Wait for server to be ready - with proper error handling for CI environments
        try {
            waitForServerReady();
        } catch (RuntimeException e) {
            log.warn("SMB server readiness check failed: {}", e.getMessage());

  /**
   * Returns an immutable list of interceptors that observe the full span of each call: from before
   * the connection is established (if any) until after the response source is selected (either the
   * origin server, cache, or both).
   */
  @get:JvmName("interceptors")
  val interceptors: List<Interceptor> =
    builder.interceptors.toImmutableList()

  /**