public static final String LONG_OPTION = "write-locks";

        public DependencyLockingWriteOption() {
            super(null, CommandLineOptionConfiguration.create(LONG_OPTION, "Persists dependency resolution for locked configurations, ignoring existing locking information if it exists"));
        }

        @Override
        public void applyTo(StartParameterInternal settings, Origin origin) {

	response, err = s.client.Do(request)
	c.Assert(err, nil)
	// Assert if the content-type header set during the object upload persists.
	c.Assert(response.Header.Get("Content-Type"), "application/json")

	// Fetch the object and assert whether the Content-Type header persists.
	request, err = newTestSignedRequest(http.MethodGet, getGetObjectURL(s.endPoint, bucketName, objectName),
		0, nil, s.accessKey, s.secretKey, s.signer)

	if err != nil {
		return "", warn, err
	}

	// convert any binary data to the string equivalent for easier review. The
	// kube-apiserver will convert this to binary before it persists it to storage.
	remoteSecret.StringData = make(map[string]string, len(remoteSecret.Data))
	for k, v := range remoteSecret.Data {
		remoteSecret.StringData[k] = string(v)
	}
	remoteSecret.Data = nil

Requests will be retried up to 3 times.
If the problem persists, the cache operation will fail and the remote cache will be disabled for the remainder of the build.

==== Using SSL

Gradle then executes the task.
If the task completes successfully, Gradle takes a fingerprint of the outputs.
This fingerprint contains the set of output files and a hash of the contents of each file.
Gradle persists both fingerprints for the next time the task is executed.

Each time after that, before the task is executed, Gradle takes a new fingerprint of the inputs and outputs.

	args    []string // arguments for test executable
	env     []string // environment for test executable

	coordinator *coordinator

	memMu chan *sharedMem // mutex guarding shared memory with worker; persists across processes.

	cmd         *exec.Cmd     // current worker process
	client      *workerClient // used to communicate with worker process
	waitErr     error         // last error returned by wait, set before termC is closed.

import java.util.Collections;
import java.util.Set;

public class Permits {
    private static final Permits NONE = new Permits(Collections.emptySet());

    private final Set<String> allowedExtensions;

    public Permits(Set<String> allowedExtensions) {
        this.allowedExtensions = allowedExtensions;
    }

    public static Permits none() {
        return NONE;
    }

    /**

	}
	if sc.c == nil { // connection closed by user in the meantime
		defer sc.mu.Unlock()
		return ErrClosed
	}
	c := sc.c
	if sc.nread <= sc.nwritten {
		defer sc.mu.Unlock()
		return errors.New("persist server pipe count")
	}
	if resp.Close {
		// After signaling a keep-alive close, any pipelined unread
		// requests will be lost. It is up to the user to drain them
		// before signaling.
		sc.re = ErrPersistEOF

                     persistor.device_type(), persistor.persistence_prefix());
  // File for key2 contains the same content as key1.
  TF_ASSERT_OK(Env::Default()->CopyFile(
      GetFilePath(key1, persistor.persistent_cache_directory()),
      GetFilePath(key2, persistor.persistent_cache_directory())));

  MockXlaCompilerClient mock_client;
  // Try to load an executable from file corresponding to key2 (whose file
  // content corresponds to key1).

wrapper script`).

`migrate` writes a `version.txt` file to track the "current" version
of etcd that was used to persist data to disk. A "target" version may also be provided
by the `TARGET_STORAGE` (e.g. "etcd3") and `TARGET_VERSION` (e.g. "3.4.13" )
environment variables. If the persisted version differs from the target version,
`migrate-if-needed.sh` will migrate the data from the current to the target
version.