When using CMake to build, the zlib submodule ends up with a generated
file that makes Git consider the submodule dirty. This state can be
ignored for day-to-day development on gRPC.
We cannot use the weaker "ignore = untracked" as the build process
deletes a tracked file as well as generating a new file.
The thread that watches connectivity on the channel might not
pick up that the server has gone away before the request is
dispatched, and return UNAVAILABLE instead of reconnecting
prior to sending the request. The fundamental solution would
basically be enabling retries in C-core. For now, we opt to
sleep a second to deflake this particular test case.
Currently when running python test on linux, we are mounting
/tmp/xdg-cache-home to the docker container that runs the tests
in the attempt to prevent unnecessary downloads of pip packages
(with the theory that more downloads leads to increased flakiness)
- the idea is that while there is a new docker container for each
test suite, the xdg cache remains per-VM.
This approach no longer seems to be useful:
* It turns out that XDG cache doesn't work reliably when multiple
docker containers are using it concurrently (the concurrent run can
see corrupt files). We are using concurrent docker containers in our
multilang test suite to speed up the execution and we are currently
getting flakes seeing flakes caused by this.
* support for caching makes our docker_run scripts more complicated
and we really don't want that.
* since we migrated to kokoro, the caching is limited anyway -
as each run gets a fresh VM, we need to download packages anyway
for every build (and that actually seems to causing way less
flakiness the problem with concurrent XDG caching).