}

        if (domain == null) {
            return null;
        }

        domain = domain.toLowerCase();

        if (log.isTraceEnabled()) {
            log.trace(String.format("Resolving \\%s\\%s%s", domain, root, path != null ? path : ""));
        }

        DfsReferralDataInternal dr = null;
        final long now = System.currentTimeMillis();
        synchronized (this.domainsLock) {

// An optional error can be sent which will be picked as text only error,
// without its original type by the receiver.
// waitForHTTPResponse should be used to the receiving side.
func keepHTTPReqResponseAlive(w http.ResponseWriter, r *http.Request) (resp func(error), body io.ReadCloser) {
	bodyDoneCh := make(chan struct{})
	doneCh := make(chan error)
	ctx := r.Context()
	go func() {

                                concurrentLimiter.recordFailure("user" + threadId, "192.168.2." + threadId);
                                localFailures++;
                                // Prevent lockout by resetting after 3 failures
                                if (localFailures >= 3) {
                                    concurrentLimiter.recordSuccess("user" + threadId, "192.168.2." + threadId);

# Using TensorFlow Securely

This document discusses the TensorFlow security model. It describes the security
risks to consider when using models, checkpoints or input data for training or
serving. We also provide guidelines on what constitutes a vulnerability in
TensorFlow and how to report them.

This document applies to other repositories in the TensorFlow organization,
covering security practices for the entirety of the TensorFlow ecosystem.

     *
     * @param authorityServerName
     *            The FQDN of the server that is an authority for the SID.
     * @param tc
     *            Context to use
     * @throws IOException if there is an error resolving the SID
     */
    public void resolve(final String authorityServerName, final CIFSContext tc) throws IOException {
        final SID[] sids = new SID[1];
        sids[0] = this;

Run the server with:

<div class="termy">

```console
$ fastapi dev main.py

 ╭────────── FastAPI CLI - Development mode ───────────╮
 │                                                     │
 │  Serving at: http://127.0.0.1:8000                  │
 │                                                     │
 │  API docs: http://127.0.0.1:8000/docs               │
 │                                                     │

-   x86 and arm64
-   CPU-only, or with NVIDIA CUDA support (Linux only), or with TPUs

## How to Test Your Changes to TensorFlow

You may check how your changes will affect TensorFlow by:

1. Creating a PR and observing the presubmit test results
2. Running the CI scripts locally, as explained below
3. **Google employees only**: Google employees can use an internal-only tool

    /**
     * Configures this request's body to be compressed when it is transmitted. This also adds the
     * 'Content-Encoding: gzip' header.
     *
     * Only use this method if you have prior knowledge that the receiving server supports
     * gzip-compressed requests.
     *
     * It is an error to call this multiple times on the same instance.
     *

 <span style="background-color:#C4A000"><font color="#2E3436">│                                                     │</font></span>
 <span style="background-color:#C4A000"><font color="#2E3436">│  Serving at: http://127.0.0.1:8000                  │</font></span>
 <span style="background-color:#C4A000"><font color="#2E3436">│                                                     │</font></span>

    /**
     * Resolve an array of SIDs using a cache and at most one MSRPC request.
     * <p>
     * This method will attempt
     * to resolve SIDs using a cache and cache the results of any SIDs that
     * required resolving with the authority. SID cache entries are currently not
     * expired because under normal circumstances SID information never changes.
     *
     * @param authorityServerName