globalServiceFreezeMu.Lock()
	// Close when we reach 0
	globalServiceFreezeCnt--
	if globalServiceFreezeCnt <= 0 {
		// Set to a nil channel.
		var _ch chan struct{}
		if val := globalServiceFreeze.Swap(_ch); val != nil {
			if ch, ok := val.(chan struct{}); ok && ch != nil {
				// Close previous non-nil channel.
				xioutil.SafeClose(ch)
			}
		}

	d, err := Open(dirPath)
	if err != nil {
		if osErrToFileErr(err) == errFileNotFound {
			return nil
		}
		return osErrToFileErr(err)
	}
	defer d.Close()

	maxEntries := 1000
	for {
		// Read up to max number of entries.
		fis, err := d.Readdir(maxEntries)
		if err != nil {
			if err == io.EOF {
				break
			}
			err = osErrToFileErr(err)

    val source = response.body.source()
    while (!source.exhausted()) {
      out.write(source.buffer, source.buffer.size)
      out.flush()
    }

    response.body.close()
  } catch (e: IOException) {
    e.printStackTrace()
  } finally {
    close()
  }

        SocketException exception = new SocketException();
        exception.initCause(e);
        throw exception;
      }
    }

    @Override public void close() throws IOException {
      serverSocketChannel.close();
    }
  }

        }

        while (off < length) {
            off += in.readDirect(buf, off, length - off);
        }
    }

    @Override
    public void close() throws IOException {
        state = 0;
        if (out != null) {
            out.close();
        }
    }

	if err != nil {
		log.Fatalln(err)
	}

	zipFile, err := os.Create("format.json.zip")
	if err != nil {
		log.Fatalf("failed to create format.json.zip: %v", err)
	}
	defer zipFile.Close()
	fmtZipW := zip.NewWriter(zipFile)
	defer fmtZipW.Close()
	for _, pool := range pools { // for each pool
		setCount, setDriveCount := pool.SetCount, pool.DrivesPerSet
		format := newFormatErasureV3(setCount, setDriveCount)
		format.ID = deploymentID

     * @param content the message to log
     * @param error the error that caused this log
     */
    void debug(CharSequence content, Throwable error);

    /**
     * Sends an exception to the user in the <b>debug</b> error level.
     * The stack trace for this exception will be output when this error level is enabled.
     *
     * @param error the error that caused this log
     */
    void debug(Throwable error);

        internalBuild()
        buildFile << """
            apply plugin: 'elasticsearch.internal-distribution-bwc-setup'
        """
        execute("git branch origin/7.x", file("cloned"))
        execute("git branch origin/7.10", file("cloned"))
    }

    def "builds distribution from branches via archives assemble"() {
        given:
        buildFile.text = ""
        internalBuild(buildFile, "7.10.1", "7.11.0", "7.12.0")

        fileIdField.setAccessible(true);
        byte[] storedFileId = (byte[]) fileIdField.get(request);
        assertEquals(null, storedFileId);
    }

    @Test
    @DisplayName("setCloseFlags should update close flags")
    void testSetCloseFlags() throws Exception {
        int testFlags = 0x00000001; // SMB2_CLOSE_FLAG_POSTQUERY_ATTRIB
        request.setCloseFlags(testFlags);

    response.body.string()
    val cached = cacheGet(cache, request)
    if (shouldWriteToCache) {
      assertThat(cached).isNotNull()
      cached!!.body.close()
    } else {
      assertThat(cached).isNull()
    }
    server.close() // tearDown() isn't sufficient; this test starts multiple servers
  }

  private fun assertSubsequentResponseCached(
    initialResponseCode: Int,