}

  /** Finds a new or pooled connection to carry a forthcoming request and response. */
  internal fun initExchange(chain: RealInterceptorChain): Exchange {
    withLock {
      check(expectMoreExchanges) { "released" }
      check(!responseBodyOpen && !requestBodyOpen && !socketSourceOpen && !socketSinkOpen)
    }

    val exchangeFinder = this.exchangeFinder!!
    val connection = exchangeFinder.find()

    public synchronized void close() {
        release();
    }

    /**
     * @return tree handle with increased usage count
     */
    public SmbTreeHandleImpl acquire() {
        if (this.usageCount.incrementAndGet() == 1) {
            this.treeConnection.acquire();
        }
        return this;
    }

    @Override
    public void release() {

                guidToHandle.remove(info.getCreateGuid());
                removePersistedHandle(info);
                log.debug("Released handle for: {}", path);
            }
        } finally {
            lock.writeLock().unlock();
        }
    }

    /**
     * Get handle information by GUID
     * @param guid the handle GUID
     * @return the handle info or null if not found
     */

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 */

/*
 * Source:
 * http://gee.cs.oswego.edu/cgi-bin/viewcvs.cgi/jsr166/src/jsr166e/LongAdder.java?revision=1.17
 */

package com.google.common.hash;

import com.google.common.annotations.GwtIncompatible;

                      Sometimes, the change was made on the `release` branch but hasn't yet been published to the baseline version.
                      In that case, you can publish a new snapshot from the release branch. This will update `released-versions.json` on `master`.

      finalizeReferentCalled = true;
    }
  }

  /**
   * Keeps a weak reference to the underlying reference queue. When this reference is cleared, we
   * know that the background thread has stopped and released its strong reference.
   */
  private WeakReference<ReferenceQueue<Object>> queueReference;

  @Test
  public void testThatFinalizerStops() {
    weaklyReferenceQueue();
    GcFinalization.awaitClear(queueReference);

            if (wasOpen) {
                this.handle.close();
            } else if (this.handle != null) {
                this.handle.release();
            }
            this.handle = null;
        } finally {
            if (this.treeHandle != null) {
                this.treeHandle.release();
            }
        }
    }

# Separate OpenAPI Schemas for Input and Output or Not { #separate-openapi-schemas-for-input-and-output-or-not }

Since **Pydantic v2** was released, the generated OpenAPI is a bit more exact and **correct** than before. 😎

In fact, in some cases, it will even have **two JSON Schemas** in OpenAPI for the same Pydantic model, for input and output, depending on if they have **default values**.

Let's see how that works and how to change it if you need to do that.

        h.acquire();

        // First release: should not close yet
        h.release();
        verify(tree, never()).send(isA(Smb2CloseRequest.class), any());
        verify(tree, never()).send(any(CommonServerMessageBlockRequest.class), any(SmbComBlankResponse.class), any(RequestParam[].class));

        // Second release: should close now via SMB2 path
        h.release();

See the sections below for detailed instructions on each method.

### Legacy Binary Releases

Historical pre-compiled binary releases remain available for reference but are no longer maintained:
- GitHub Releases: https://github.com/minio/minio/releases
- Direct downloads: https://dl.min.io/server/minio/release/