and apparatus claims, in any patent Licensable by such Contributor that
      would be infringed, but for the grant of the License, by the making,
      using, selling, offering for sale, having made, import, or transfer of
      either its Contributions or its Contributor Version.

1.12. “Secondary License”

      means either the GNU General Public License, Version 2.0, the GNU Lesser

   * implementation; otherwise refreshes will be performed during unrelated cache read and write
   * operations.
   *
   * <p>Currently automatic refreshes are performed when the first stale request for an entry
   * occurs. The request triggering refresh will make a synchronous call to {@link
   * CacheLoader#reload}
   * to obtain a future of the new value. If the returned future is already complete, it is returned

    "name": "samples",
    "path": "platforms/documentation/samples",
    "unitTests": false,
    "functionalTests": true,
    "crossVersionTests": false
  },
  {
    "name": "scala",
    "path": "platforms/jvm/scala",
    "unitTests": true,
    "functionalTests": true,
    "crossVersionTests": false
  },
  {
    "name": "security",
    "path": "platforms/software/security",

    # /- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # o targetLanguage: (Required)
    #  The target language.
    #  Your possible choices are:
    #
    #       java, csharp, scala
    #
    ; targetLanguage = java
    # - - - - - - - - - -/

    # /- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # o targetContainer: (Required)
    #  The target DI container.

If there's a problem with the connection, OkHttp will select another route and try again. This allows OkHttp to recover when a subset of a server's addresses are unreachable. It's also useful when a pooled connection is stale or if the attempted TLS version is unsupported.

		if err != nil {
			writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
			return
		}
	}
	stale := r.Form.Get("stale") == "true" // list also stale locks

	peerLocks := globalNotificationSys.GetLocks(ctx, r)

	topLocks := topLockEntries(peerLocks, stale)

	// Marshal API response upto requested count.
	if len(topLocks) > count && count > 0 {
		topLocks = topLocks[:count]
	}

  private fun getCacheOnlyResponse(request: Request): Response? {
    if (client.cache != null) {
      try {
        // Use the cache without hitting the network first
        // 504 code indicates that the Cache is stale
        val onlyIfCached =
          CacheControl.Builder()
            .onlyIfCached()
            .build()

        var cacheUrl = request.url

        val cacheRequest =

	// the disksWithAllParts() returns the actual disks that can be
	// used here for reconstruction. This is done to ensure that
	// we do not skip drives that have inconsistent metadata to be
	// skipped from purging when they are stale.
	availableDisks, dataErrsByDisk, dataErrsByPart := disksWithAllParts(ctx, onlineDisks, partsMetadata,
		errs, latestMeta, filterDisksByETag, bucket, object, scanMode)

	var erasure Erasure

  // TODO GET preferred order - with tests to confirm this
  // 1. successful fresh cached GET response
  // 2. unsuccessful (404, 500) fresh cached GET response
  // 3. successful network response
  // 4. successful stale cached GET response
  // 5. unsuccessful response
  @Test
  fun usesCache() {
    val cache = Cache(cacheFs, "cache".toPath(), (100 * 1024).toLong())

		// value is cached we should attempt to invalidate it if such calls
		// were attempted. This can lead to false success under certain conditions
		// - this change attempts to avoid stale information if the underlying
		// transport is already down.
		return "", errDiskNotFound
	}

	// This call should never be over the network, this is always
	// a cached value - caller should make sure to use this