*/
internal class ThrottledSink(
  private val delegate: Sink,
  private val bytesPerPeriod: Long,
  private val periodDelayNanos: Long,
) : Sink by delegate {
  private var bytesWrittenSinceLastDelay = 0L

  override fun write(
    source: Buffer,
    byteCount: Long,
  ) {
    var bytesLeft = byteCount

    while (bytesLeft > 0) {
      if (bytesWrittenSinceLastDelay == bytesPerPeriod) {

      override fun close() {
        if (currentPart == this) {
          currentPart = null
        }
      }

      override fun read(
        sink: Buffer,
        byteCount: Long,
      ): Long {
        require(byteCount >= 0L) { "byteCount < 0: $byteCount" }
        check(currentPart == this) { "closed" }

        source.timeout().intersectWith(timeout) {

  internal const val OPCODE_CONTROL_CLOSE = 0x8
  internal const val OPCODE_CONTROL_PING = 0x9
  internal const val OPCODE_CONTROL_PONG = 0xa

  /**
   * Maximum length of frame payload. Larger payloads, if supported by the frame type, can use the
   * special values [PAYLOAD_SHORT] or [PAYLOAD_LONG].
   */
  internal const val PAYLOAD_BYTE_MAX = 125L

  /** Maximum length of close message in bytes. */

  val start = System.currentTimeMillis()

  override fun receivingStreamWindowChanged(
    streamId: Int,
    windowCounter: WindowCounter,
    bufferSize: Long,
  ) {
    println("${System.currentTimeMillis() - start},$streamId,${windowCounter.unacknowledged},$bufferSize")
  }

  override fun receivingConnectionWindowChanged(windowCounter: WindowCounter) {

      .build()
  }

  private fun uppercaseSink(sink: Sink): Sink {
    return object : ForwardingSink(sink) {
      @Throws(IOException::class)
      override fun write(
        source: Buffer,
        byteCount: Long,
      ) {
        val bytes = source.readByteString(byteCount)
        delegate.write(
          Buffer()
            .write(bytes.toAsciiUppercase()),
          byteCount,
        )
      }
    }
  }

  }

  override fun isShutdown(): Boolean {
    return shutdown
  }

  override fun isTerminated(): Boolean {
    throw UnsupportedOperationException()
  }

  override fun awaitTermination(
    timeout: Long,
    unit: TimeUnit,
  ): Boolean {
    throw UnsupportedOperationException()
  }

    private val builder: KtSymbolByFirBuilder,
    override val token: KtLifetimeToken
) : KtBuiltinTypes() {

    override val INT: KtType by cachedBuiltin(builtinTypes.intType)
    override val LONG: KtType by cachedBuiltin(builtinTypes.longType)
    override val SHORT: KtType by cachedBuiltin(builtinTypes.shortType)
    override val BYTE: KtType by cachedBuiltin(builtinTypes.byteType)

  ): Sink = FaultySink(super.sink(file, mustCreate), file)

  inner class FaultySink(sink: Sink, private val file: Path) : ForwardingSink(sink) {
    override fun write(
      source: Buffer,
      byteCount: Long,
    ) {
      if (writeFaults.contains(file)) {
        throw IOException("boom!")
      } else {
        super.write(source, byteCount)
      }
    }
  }

  }

  /**
   * @param delta the offset from the current date to use. Negative values yield dates in the past;
   *     positive values yield dates in the future.
   */
  private fun formatDate(
    delta: Long,
    timeUnit: TimeUnit,
  ): String? {
    return formatDate(Date(System.currentTimeMillis() + timeUnit.toMillis(delta)))
  }

  private fun formatDate(date: Date): String? {

### High availability

A stand-alone MinIO server would go down if the server hosting the drives goes offline. In contrast, a distributed MinIO setup with _m_ servers and _n_ drives will have your data safe as long as _m/2_ servers or _m*n_/2 or more drives are online.