### Choosing between application and network interceptors

Each interceptor chain has relative merits.

**Application interceptors**

fi

# Start KES Server
(./kes server --dev 2>&1 >kes-server.log) &
kes_pid=$!
sleep 5s
API_KEY=$(grep "API Key" <kes-server.log | awk -F" " '{print $3}')
(openssl s_client -connect 127.0.0.1:7373 2>/dev/null 1>public.crt)

export CI=true
export MINIO_KMS_KES_ENDPOINT=https://127.0.0.1:7373
export MINIO_KMS_KES_API_KEY="${API_KEY}"
export MINIO_KMS_KES_KEY_NAME=minio-default-key

        // Given
        Exception cause = new RuntimeException("Original error");

        // When
        exception = new SmbOperationException(SmbOperationException.ErrorCode.CONNECTION_FAILED, "Failed to connect", cause);

        // Then
        assertEquals(cause, exception.getCause());
        assertEquals(SmbOperationException.ErrorCategory.NETWORK, exception.getErrorCategory());
        assertTrue(exception.isRetryable());

**NOTE:**

  public val port: Int
    get() = socketAddress.port

  public val hostName: String
    get() = socketAddress.address.hostName

  /** Returns the address of this server, to connect to it as an HTTP proxy. */
  public val proxyAddress: Proxy
    get() = Proxy(Proxy.Type.HTTP, socketAddress)

  /**
   * True if ALPN is used on incoming HTTPS connections to negotiate a protocol like HTTP/1.1 or

errors.failed_to_read_request_file=Échec de la lecture d'un fichier de requête : {0}
errors.invalid_header_for_request_file=Ligne d'en-tête non valide : {0}
errors.could_not_delete_logged_in_user=Vous ne pouvez pas supprimer un utilisateur connecté.
errors.unauthorized_request=Requête non autorisée.
errors.failed_to_print_thread_dump=Échec de l'impression d'un vidage de thread.
errors.file_is_not_supported={0} n'est pas pris en charge.

		return
	}
	cred, err := auth.GetNewCredentialsWithMetadata(claims, secret)
	if err != nil {
		writeSTSErrorResponse(ctx, w, ErrSTSInternalError, err)
		return
	}

	// https://openid.net/specs/openid-connect-core-1_0.html#ClaimStability
	// claim is only considered stable when subject and iss are used together
	// this is to ensure that ParentUser doesn't change and we get to use

        fromSink.writeByte(ADDRESS_TYPE_IPV4)
        fromSink.write(localAddress)
        fromSink.writeShort(toSocket.localPort)
        fromSink.emit()
        logger.log(Level.INFO, "SocksProxy connected $fromAddress to $toAddress")

        // Copy sources to sinks in both directions.
        val toSource = toSocket.source().buffer()
        val toSink = toSocket.sink().buffer()
        openSockets.add(toSocket)

 *     sha256/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=
 *   at okhttp3.CertificatePinner.check(CertificatePinner.java)
 *   at okhttp3.Connection.upgradeToTls(Connection.java)
 *   at okhttp3.Connection.connect(Connection.java)
 *   at okhttp3.Connection.connectAndSetOwner(Connection.java)
 * ```
 *
 * Follow up by pasting the public key hashes from the exception into the
 * certificate pinner's configuration:
 *
 * ```java

        setHeader("Connection", "Upgrade")
        setHeader("Upgrade", "websocket")
        webSocketListener = listener
      }

    /**
     * Configures this response to be served as a response to an HTTP CONNECT request, either for
     * doing HTTPS through an HTTP proxy, or HTTP/2 prior knowledge through an HTTP proxy.
     *
     * When a new connection is received, all in-tunnel responses are served before the connection is