}

    @Override
    public SmbTransportPool getTransportPool() {
        return this.delegate.getTransportPool();
    }

    @Override
    public boolean close() throws CIFSException {
        return this.delegate.close();
    }

    }

    /**
     * Closes this output stream and releases any system resources associated
     * with it.
     *
     * @throws IOException
     *             if a network error occurs
     */

    @Override
    public void close() throws IOException {
        try {
            if (this.handle.isValid()) {
                this.handle.close();
            }
        } finally {

		fillReq:   make(chan struct{}),
		fillReady: make(chan int64),
	}

	go func() {
		var rpos int64 // total bytes read into buffer

		defer func() {
			atomic.StoreInt64(&sr.end, rpos)
			close(sr.fillReady)
		}()

		for range sr.fillReq {
		scan:
			n, err := r.Read(sr.nbuf[:])

			if n == 0 {
				switch err {
				case io.EOF: // reader is exhausted
					return

        getOnly = true,
      )
    runBatch(dnsProviders, names)
  } finally {
    bootstrapClient.connectionPool.evictAll()
    bootstrapClient.dispatcher.executorService.shutdownNow()
    bootstrapClient.cache?.close()
  }

		err := localDrive.CreateFile(context.Background(), "", minioMetaBucket, pathJoin(healMRFDir, "list.bin"), -1, r)
		r.Close()
		if err == nil {
			break
		}
	}
}

func (m *mrfState) startMRFPersistence() {
	loadMRF := func(rc io.ReadCloser, opCh chan PartialOperation) error {
		defer rc.Close()
		var data [4]byte
		n, err := rc.Read(data[:])
		if err != nil {
			return err
		}
		if n != len(data) {

            }
            return resp.getAvailable();
        } catch (final SmbException se) {
            throw seToIoe(se);
        }
    }

    @Override
    public void close() {
        // ignore, the shared file descriptor is closed by the pipe handle
    }

### Ask to close { #ask-to-close }

If they reply, there's a high chance you would have solved their problem, congrats, **you're a hero**! 🦸

* Now, if that solved their problem, you can ask them to:

    * In GitHub Discussions: mark the comment as the **answer**.
    * In GitHub Issues: **close** the issue.

## Watch the GitHub repository { #watch-the-github-repository }

                        indexUpdater.addFinishedSessionId(sid);
                        try {
                            crawler.close();
                        } catch (final Exception e) {
                            logger.warn("Failed to close the crawler.", e);
                        }
                    }
                    if (!Constants.DONE.equals(crawlerStatusList.get(i))) {

    checkNotNull(bytes);

    try (OutputStream out = openStream()) {
      out.write(bytes);
    }
  }

  /**
   * Writes all the bytes from the given {@code InputStream} to this sink. Does not close {@code
   * input}.
   *
   * @return the number of bytes written
   * @throws IOException if an I/O occurs while reading from {@code input} or writing to this sink
   */
  @CanIgnoreReturnValue

    stream = http2Connection.newStream(requestHeaders, hasRequestBody)
    // We may have been asked to cancel while creating the new stream and sending the request
    // headers, but there was still no stream to close.
    if (canceled) {
      stream!!.closeLater(ErrorCode.CANCEL)
      throw IOException("Canceled")
    }
    stream!!.readTimeout().timeout(chain.readTimeoutMillis.toLong(), TimeUnit.MILLISECONDS)