if err != nil {
			return err
		}
		if etcdCfg.Enabled {
			etcdClnt, err := etcd.New(etcdCfg)
			if err != nil {
				return err
			}
			etcdClnt.Close()
		}
	case config.IdentityOpenIDSubSys:
		if _, err := openid.LookupConfig(s,
			NewHTTPTransport(), xhttp.DrainBody, globalSite.Region()); err != nil {
			return err
		}
	case config.IdentityLDAPSubSys:

		defer timeout(5 * time.Second)()
		rb.Reset()
		done := make(chan struct{})
		go func() {
			defer close(done)
			time.Sleep(10 * time.Millisecond)
			fn()
		}()
		rb.CloseWithError(errors.New("test error"))
		<-done

		rb.Reset()
		done = make(chan struct{})
		go func() {
			defer close(done)
			fn()
		}()
		time.Sleep(10 * time.Millisecond)
		rb.CloseWithError(errors.New("test error"))

            connectionMonitorTask.cancel();
        }
        if (httpClient != null) {
            try {
                httpClient.close();
            } catch (final IOException e) {
                logger.error("Failed to close httpClient.", e);
            }
            httpClient = null;
            if (clientConnectionManager != null) {
                clientConnectionManager.shutdown();
            }
        }

// connect to list of endpoints and load all Erasure disk formats, validate the formats are correct
// and are in quorum, if no formats are found attempt to initialize all of them for the first
// time. additionally make sure to close all the disks used in this attempt.

// Reset the record.
func (r *Record) Reset() {
	r.object = simdjson.Object{}
}

// Clone the record and if possible use the destination provided.
func (r *Record) Clone(dst sql.Record) sql.Record {
	other, ok := dst.(*Record)
	if !ok {
		other = &Record{}
	}
	other.object = r.object
	return other
}

// CloneTo clones the record to a json Record.
// Values are only unmashaled on object level.

The application-layer can also do blocking reads. If the application asks to read and there's nothing available, we need to hold that thread until either the bytes arrive, the stream is closed, or a timeout elapses. If we get bytes but there's nobody asking for them, we buffer them. We don't consider bytes as delivered for flow control until they're consumed by the application.

   * merge does not affect its value. For example, if {@code rangeMap} had one entry {@code [1, 5]
   * => 3} then {@code rangeMap.merge(Range.closed(0,2), 3, Math::max)} could yield a map with the
   * entries {@code [0, 1) => 3, [1, 2] => 3, (2, 5] => 3}.
   *
   * @since 28.1
   */
  void merge(
      Range<K> range,
      @CheckForNull V value,

		if err != nil {
			return nil, err
		}
		err = pprof.StartCPUProfile(f)
		if err != nil {
			return nil, err
		}
		prof.stopFn = func() ([]byte, error) {
			pprof.StopCPUProfile()
			err := f.Close()
			if err != nil {
				return nil, err
			}
			defer RemoveAll(dirPath)
			return ioutilx.ReadFile(fn)
		}
	case madmin.ProfilerCPUIO:
		// at 10k or more goroutines fgprof is likely to become

        @Override
        public void close() throws InvokerException {
            List<Exception> causes = null;
            List<AutoCloseable> cs = new ArrayList<>(closeables);
            Collections.reverse(cs);
            for (AutoCloseable c : cs) {
                if (c != null) {
                    try {
                        c.close();
                    } catch (Exception e) {

	// Object operations.

	// GetObjectNInfo returns a GetObjectReader that satisfies the
	// ReadCloser interface. The Close method runs any cleanup
	// functions, so it must always be called after reading till EOF
	//
	// IMPORTANTLY, when implementations return err != nil, this
	// function MUST NOT return a non-nil ReadCloser.