continue
		}

	keepLock:
		for {
			select {
			case <-ctx.Done():
				return
			case <-lkctx.Context().Done():
				// The context of the lock is canceled, this can happen
				// if one lock lost quorum due to cluster instability
				// in that case, try to lock again.
				break keepLock
			case ld.lockContext <- lkctx:
				// Send the lock context to anyone asking for it
			}
		}
	}
}

//	    "accessPointArn": "...",
//	    "supportingAccessPointArn": "...",
//	    "payload": ""
//	  },
//	  "userRequest": {
//	    "url": "...",
//	    "headers": {
//	      "Host": "...",
//	      "X-Amz-Content-SHA256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
//	    }
//	  },
//	  "userIdentity": {
//	    "type": "IAMUser",
//	    "principalId": "AIDAJF5MO57RFXQCE5ZNC",

//
// In most cases, new([Buffer]) (or just declaring a [Buffer] variable) is
// sufficient to initialize a [Buffer].
func NewBuffer(buf []byte) *Buffer { return &Buffer{buf: buf} }

// NewBufferString creates and initializes a new [Buffer] using string s as its
// initial contents. It is intended to prepare a buffer to read an existing
// string.
//

You could also use `from starlette.responses import Response` or `from starlette.responses import JSONResponse`.

**FastAPI** provides the same `starlette.responses` as `fastapi.responses` just as a convenience for you, the developer. But most of the available responses come directly from Starlette.

And as the `Response` can be used frequently to set headers and cookies, **FastAPI** also provides it at `fastapi.Response`.

///

I will show you some of the main concepts you should probably keep in mind when deploying a **FastAPI** application (although most of it applies to any other type of web application).

	entry := NewEntry(deploymentID)

	entry.RemoteHost = handlers.GetSourceIP(r)
	entry.UserAgent = r.UserAgent()
	entry.ReqClaims = reqClaims
	entry.ReqHost = r.Host
	entry.ReqPath = r.URL.Path

	q := r.URL.Query()
	reqQuery := make(map[string]string, len(q))
	for k, v := range q {
		reqQuery[k] = strings.Join(v, ",")
	}
	entry.ReqQuery = reqQuery

    id: context
    attributes:
      label: Context (optional)
      description: |
        How has this issue affected you? What are you trying to accomplish?
        Providing context helps us come up with a solution that is most useful in the real world
    validations:
      required: false
  - type: textarea
    id: steps-to-reproduce
    attributes:
      label: Self-contained Reproducer Project
      description: |

        daemon --> worker3
    
```

These are all Java processes. Each process has a corresponding "runtime".
All source code in Gradle is written to target one or more of these runtimes.
Most source code targets the daemon and the remaining code either targets a single runtime, for example the Gradle client, or is shared across multiple runtimes.

## Composition by architecture modules

            } else if (state == DfsState.VISITING) {
                // we are already visiting this vertex, this mean we have a cycle
                int pos = cycle.lastIndexOf(v.label);
                List<String> ret = cycle.subList(pos, cycle.size());
                ret.add(v.label);
                return ret;
            }
        }
        return null;
    }

    static class Vertex {

  env_file:
    - ./minio.env
  expose:
    - "9000"
    - "9001"

# starts 4 docker containers running minio server instances.
# using nginx reverse proxy, load balancing, you can access
# it through port 9000.
services:
  minio1:
    <<: *minio-common
    hostname: minio1
    volumes:
      - data1-1:/data1
      - data1-2:/data2
      - data1-3:/data3

  minio2:
    <<: *minio-common