) {
  /** True if the request body need not complete before the response body starts. */
  internal var isDuplex: Boolean = false
    private set

  /** True if there was an exception on the connection to the peer. */
  internal var hasFailure: Boolean = false
    private set

  internal val connection: RealConnection
    get() = codec.carrier as? RealConnection ?: error("no connection for CONNECT tunnels")

		Help:      "Total number of bytes sent to the other peer nodes",
		Type:      counterMetric,
	}
}

func getInterNodeReceivedBytesMD() MetricDescription {
	return MetricDescription{
		Namespace: interNodeMetricNamespace,
		Subsystem: trafficSubsystem,
		Name:      receivedBytes,
		Help:      "Total number of bytes received from other peer nodes",
		Type:      counterMetric,
	}
}

	// Network Sent/Received Bytes (internode)
	ch <- prometheus.MustNewConstMetric(
		prometheus.NewDesc(
			prometheus.BuildFQName(interNodeNamespace, "tx", "bytes_total"),
			"Total number of bytes sent to the other peer nodes by current MinIO server instance",
			nil, nil),
		prometheus.CounterValue,
		float64(connStats.internodeOutputBytes),
	)

	ch <- prometheus.MustNewConstMetric(
		prometheus.NewDesc(

| `minio_inter_node_traffic_received_bytes` | Total number of bytes received from other peer nodes.   |
| `minio_inter_node_traffic_sent_bytes`     | Total number of bytes sent to the other peer nodes.     |

## Bucket Notification Metrics

   *    true.
   *
   * It won't retry if the exception is a bug or a configuration problem, such as:
   *
   *  * If the remote peer is untrusted: [exception] is an [SSLPeerUnverifiedException].
   *  * If received data is unexpected: [exception] is a [ProtocolException].
   *

// executes at least one write operation if it is closed.
//
// This can be useful within the context of HTTP. At least
// one write operation must happen to send the HTTP headers
// to the peer.
type WriteOnCloser struct {
	io.Writer
	hasWritten bool
}

func (w *WriteOnCloser) Write(p []byte) (int, error) {
	w.hasWritten = true
	return w.Writer.Write(p)
}

		}
		if errors.Is(nerr.Err, rest.ErrClientClosed) {
			return true
		}
	}
	if errors.Is(err, grid.ErrDisconnected) {
		return true
	}
	// More corner cases suitable for storage REST API
	switch {
	// A peer node can be in shut down phase and proactively
	// return 503 server closed error, consider it as an offline node
	case strings.Contains(err.Error(), http.ErrServerClosed.Error()):
		return true

     * followed by those lines.
     *
     * HTTPS responses also contain SSL session information. This begins with a blank line, and then
     * a line containing the cipher suite. Next is the length of the peer certificate chain. These
     * certificates are base64-encoded and appear each on their own line. The next line contains the
     * length of the local certificate chain. These certificates are also base64-encoded and appear

				return
			}
		}()
		h.ServeHTTP(w, r)
	})
}

// setUploadForwardingMiddleware middleware forwards multiparts requests
// in a site replication setup to peer that initiated the upload
func setUploadForwardingMiddleware(h http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if !globalSiteReplicationSys.isEnabled() ||

    server.useHttps(handshakeCertificates.sslSocketFactory(), false)
    ```

    Get these strings with `HeldCertificate.certificatePem()` and `privateKeyPkcs8Pem()`.

 *  Fix: Handshake now returns peer certificates in canonical order: each certificate is signed by
    the certificate that follows and the last certificate is signed by a trusted root.