// If the object ETag matches with the specified ETag.
			writeHeaders()
			writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrPreconditionFailed), r.URL)
			return true
		}
	}

	etagMatch := opts.PreserveETag != "" && isETagEqual(objInfo.ETag, opts.PreserveETag)
	vidMatch := opts.VersionID != "" && opts.VersionID == objInfo.VersionID
	if etagMatch && vidMatch {
		writeHeaders()

            try (ServletOutputStream out = response.getOutputStream(); InputStream in = curlResponse.getContentAsStream()) {
                response.setStatus(curlResponse.getHttpStatusCode());
                writeHeaders(response);
                final String responseContentType = curlResponse.getHeaderValue("Content-Type");
                if (StringUtil.isBlank(responseContentType)) {

    path: String,
  ) {
    val responseHeaders =
      listOf(
        Header(":status", "404"),
        Header(":version", "HTTP/1.1"),
        Header("content-type", "text/plain"),
      )
    stream.writeHeaders(
      responseHeaders = responseHeaders,
      outFinished = false,
      flushHeaders = false,
    )
    val out = stream.sink.buffer()
    out.writeUtf8("Not found: $path")
    out.close()
  }

        } else {
            enc = encoding;
        }
        buf.append(enc);
        final HttpServletResponse response = LaResponseUtil.getResponse();
        response.setContentType(buf.toString());
        writeHeaders(response);
        try (PrintWriter out = new PrintWriter(new OutputStreamWriter(response.getOutputStream(), enc))) {
            out.print(text);
        } catch (final IOException e) {

    socket.sleepWhileOpen(response.trailersDelayNanos)
    if ("chunked".equals(response.headers["Transfer-Encoding"], ignoreCase = true)) {
      writeHeaders(socket.sink, response.trailers)
    }
  }

  @Throws(IOException::class)
  private fun writeHeaders(
    sink: BufferedSink,
    headers: Headers,
  ) {
    for ((name, value) in headers) {
      sink.writeUtf8(name)
      sink.writeUtf8(": ")

      }
    }

    if (flushHeaders) {
      writer.flush()
    }

    return stream
  }

  @Throws(IOException::class)
  internal fun writeHeaders(
    streamId: Int,
    outFinished: Boolean,
    alternating: List<Header>,
  ) {
    writer.headers(outFinished, streamId, alternating)
  }

  /**

        }

        @Override
        public HighlightInfo getHighlightInfo() {
            return new HighlightInfo();
        }
    }

    @Override
    protected void writeHeaders(final HttpServletResponse response) {
        ComponentUtil.getFessConfig().getApiJsonResponseHeaderList().forEach(e -> response.setHeader(e.getFirst(), e.getSecond()));
    }

    /**

    // Play it back.
    val connection = connect(peer)
    connection.writePingAndAwaitPong()
    val stream = connection.newStream(headerEntries("a", "android"), true)
    // finish the stream
    stream.writeHeaders(headerEntries("b", "berserk"), true, false)
    assertFailsWith<IllegalStateException> {
      stream.enqueueTrailers(headersOf("trailers", "boom"))
    }
  }

  @Test fun noTrailersFrameYieldsEmptyTrailers() {

		writeErrorResponse(ctx, w, *apiErr, r.URL)
		return
	}

	if !globalAPIConfig.shouldGzipObjects() {
		w.Header().Set(gzhttp.HeaderNoCompression, "true")
	}

	w.WriteHeader(statusCode)
	io.Copy(w, resp.Body)

				w.Header().Set(xhttp.AmzRequestToken, functionToken)
				w.Header().Set(xhttp.AmzFwdHeaderContentType, contentType)
				w.Header().Set(xhttp.AmzFwdStatus, strconv.Itoa(lambdaStatus))
				w.WriteHeader(lambdaStatus)
				w.Write([]byte(lambdaBody))
			}))
			defer lambdaServer.Close()

			lambdaARN := "arn:minio:s3-object-lambda::lambda1:webhook"

			cfg := config.New()