*
 * <p>Implementations are thread-safe: A listener is notified by at most 1 thread at a time, and so do not need to be thread-safe. All listeners
 * of a given type receive events in the same order. Listeners can be added and removed at any time.
 */
@ServiceScope(Scope.Global.class)
public interface ListenerManager {
    /**

```

!!! note "📡 ℹ"
     `Request` ✔️ `request.scope` 🔢, 👈 🐍 `dict` ⚗ 🗃 🔗 📨.

     `Request` ✔️ `request.receive`, 👈 🔢 "📨" 💪 📨.

     `scope` `dict` & `receive` 🔢 👯‍♂️ 🍕 🔫 🔧.

     & 👈 2️⃣ 👜, `scope` & `receive`, ⚫️❔ 💪 ✍ 🆕 `Request` 👐.

    💡 🌅 🔃 `Request` ✅ <a href="https://www.starlette.io/requests/" class="external-link" target="_blank">💃 🩺 🔃 📨</a>.

    {!> ../../../docs_src/body_updates/tutorial001_py39.py!}
    ```

=== "Python 3.8+"

    ```Python hl_lines="30-35"
    {!> ../../../docs_src/body_updates/tutorial001.py!}
    ```

`PUT` is used to receive data that should replace the existing data.

### Warning about replacing

That means that if you want to update the item `bar` using `PUT` with a body containing:

```Python
{
    "name": "Barz",

    /**
     * Serialize the <code>message</code> onto the provided <code>outputStream</code>, replacing all {@link Throwable}s in the object graph with a placeholder object that can be read back by {@link
     * #receive(java.io.InputStream, ClassLoader)}.
     *
     * @param message object to serialize
     * @param outputSteam stream to serialize onto
     */

    Ein `Request` hat auch ein `request.receive`, welches eine Funktion ist, die den Hauptteil des Requests empfängt.

    Das `scope`-`dict` und die `receive`-Funktion sind beide Teil der ASGI-Spezifikation.

    Und diese beiden Dinge, `scope` und `receive`, werden benötigt, um eine neue `Request`-Instanz zu erstellen.

  logLevel: info
  provider: "multus"
pilot:
  cni:
    enabled: true
    provider: "multus"
  variant: distroless
  env:
    PILOT_ENABLE_AMBIENT: "true"
    # Allow sidecars/ingress to send/receive HBONE. This is required for interop.
    PILOT_ENABLE_SENDING_HBONE: "true"
    PILOT_ENABLE_SIDECAR_LISTENING_HBONE: "true"
platform: openshift
variant: distroless
seLinuxOptions:

				`with binding 'stable-channel-default-policy-binding.istio.io' denied request`
			err := t.ConfigIstio().Eval("default", nil, sampleEnvoyFilter).Apply()
			if err == nil {
				t.Errorf("Did not receive an error while applying sample EnvoyFilter with stable admission policy")
			} else {
				msg := fmt.Sprintf(expectedErrorPrefix, "envoyfilters.networking.istio.io")
				if !strings.Contains(err.Error(), msg) {

	supportsStreamClose := protocolSupportsStreamClose(conn.selectedProtocol)

	for {
		conn.resetTimeout()
		var data []byte
		if err := websocket.Message.Receive(ws, &data); err != nil {
			if err != io.EOF {
				klog.Errorf("Error on socket receive: %v", err)
			}
			break
		}
		if len(data) == 0 {
			continue
		}
		if supportsStreamClose && data[0] == remotecommand.StreamClose {
			if len(data) != 2 {

            'Did not receive all expected requests. Waiting for 1 further requests, received [], released [], not yet received [GET /a]',
            'Did not receive all expected requests. Waiting for 1 further requests, received [], released [], not yet received [GET /b]',
            'Did not receive all expected requests. Waiting for 1 further requests, received [], released [], not yet received [GET /c, GET /d]',

// to represent the names. The protocol is based on GRPC resolution of XDS resources.
func TestAPIGen(t *testing.T) {
	ds := initDS(t)

	// Verify we can receive the DNS cluster IPs using XDS
	t.Run("adsc", func(t *testing.T) {
		proxy := &model.Proxy{Metadata: &model.NodeMetadata{
			Generator: "api",
		}}
		adscConn := ds.ConnectUnstarted(ds.SetupProxy(proxy), xds.APIWatches())