*/
    public static void writeThreadDump(final String file) {
        try (final Writer writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), Constants.CHARSET_UTF_8))) {
            processThreadDump(s -> {
                try {
                    writer.write(s);
                    writer.write('\n');
                } catch (final IOException e) {
                    throw new IORuntimeException(e);

      failed = true

      socketToCancel = this.socket

      writerToClose = this.writer
      this.writer = null

      if (!isWriter && writerToClose != null) {
        // If the caller isn't the writer thread, get that thread to close the writer.
        taskQueue.execute("$name writer close", cancelable = false) {
          writerToClose.closeQuietly()
        }
      }

        protected boolean isCommit = false;

        /** The temporary file to write changes to. */
        protected File newFile;

        /** The writer for the temporary file. */
        protected Writer writer;

        /** The stopword item being added or updated. */
        protected StopwordsItem item;

        /**
         * Constructs a new updater for a stopword item.
         *

    }

    /**
     * Method write.
     *
     * @param writer   a writer object
     * @param metadata a Metadata object
     * @throws java.io.IOException java.io.IOException if any
     */
    public void write(Writer writer, Metadata metadata) throws java.io.IOException {
        try {
            delegate.write(writer, metadata.getDelegate());
        } catch (XMLStreamException e) {

        protected boolean isCommit = false;

        /** The temporary file to write changes to. */
        protected File newFile;

        /** The writer for the temporary file. */
        protected Writer writer;

        /** The stemmer override item being added or updated. */
        protected StemmerOverrideItem item;

        /**

	ch := make(chan madmin.SpeedTestResult, 1)
	go func() {
		defer xioutil.SafeClose(ch)

		concurrency := opts.concurrencyStart

		if opts.autotune {
			// if we have less drives than concurrency then choose
			// only the concurrency to be number of drives to start
			// with - since default '32' might be big and may not
			// complete in total time of 10s.
			if globalEndpoints.NEndpoints() < concurrency {

        /** True if the changes have been committed. */
        protected boolean isCommit = false;

        /** The new file. */
        protected File newFile;

        /** The writer for the new file. */
        protected Writer writer;

        /** The item to be added or updated. */
        protected KuromojiItem item;

        /**
         * Constructs a new Kuromoji updater.
         *

    }

    /**
     * Method write.
     *
     * @param writer a writer object.
     * @param persistedToolchains a persistedToolchains object.
     * @throws IOException java.io.IOException if any.
     */
    public void write(Writer writer, PersistedToolchains persistedToolchains) throws IOException {
        try {
            delegate.write(writer, persistedToolchains.getDelegate());
        } catch (XMLStreamException e) {

Un middleware no tiene que estar hecho para FastAPI o Starlette para funcionar, siempre que siga la especificación ASGI.

En general, los middlewares ASGI son clases que esperan recibir una aplicación ASGI como primer argumento.

Entonces, en la documentación de middlewares ASGI de terceros probablemente te indicarán que hagas algo como:

```Python
from unicorn import UnicornMiddleware

app = SomeASGIApp()

   *
   * If this does write a value, it will write a tag and a length and a full value.
   */
  fun toDer(
    writer: DerWriter,
    value: T,
  )

  fun toDer(value: T): ByteString {
    val buffer = Buffer()
    val writer = DerWriter(buffer)
    toDer(writer, value)
    return buffer.readByteString()
  }

  /**