log.Printf("[HTTP][allowed]: %s", l)
		response.Header().Set(resultHeader, resultAllowed)
		response.Header().Set(overrideHeader, request.Header.Get(overrideHeader))
		response.Header().Set(receivedHeader, l)
		response.WriteHeader(http.StatusOK)
	} else {
		log.Printf("[HTTP][denied]: %s", l)
		response.Header().Set(resultHeader, resultDenied)
		response.Header().Set(overrideHeader, request.Header.Get(overrideHeader))

		ResponseNonce: eres.Nonce,
	})
	// We should get a response
	eres3 := ads.ExpectResponse(t)
	// Now send our CDS request
	ads.RequestResponseAck(t, &discovery.DiscoveryRequest{
		TypeUrl:       v3.ClusterType,
		ResponseNonce: eres.Nonce,
	})
	// Send another request. This is essentially an ACK of eres3. However, envoy expects a response
	ads.RequestResponseAck(t, &discovery.DiscoveryRequest{

func (s *JWTServer) ServeHTTP(response http.ResponseWriter, request *http.Request) {
	// Add artificious delay based on delay query
	delayParam := request.URL.Query().Get("delay")
	if delayParam != "" {
		delayDuration, err := time.ParseDuration(delayParam)
		if err != nil {
			// Handle invalid delay parameter
			response.WriteHeader(http.StatusBadRequest)
			response.Write([]byte("Invalid delay parameter"))
			return
		}

		fwLog.Warnf("UDP read failed (already read %d bytes): %v", len(resBuffer.String()), err)
		return msgBuilder.String(), err
	}
	resBuffer.Write(buf[:n])

	// format the output for forwarder response
	for _, line := range strings.Split(string(buf[:n]), "\n") {
		if line != "" {
			echo.WriteBodyLine(&msgBuilder, requestID, line)
		}
	}

	msg := msgBuilder.String()

		_, _, codec := cmdtesting.NewExternalScheme()
		tf.UnstructuredClient = &fake.RESTClient{
			NegotiatedSerializer: resource.UnstructuredPlusDefaultContentConfig().NegotiatedSerializer,
			Resp: &http.Response{
				StatusCode: http.StatusOK,
				Header:     cmdtesting.DefaultHeader(),
				Body: cmdtesting.ObjBody(codec,
					cmdtesting.NewInternalType("", "", "foo")),
			},
		}
		return tf
	}

			responseFields := s.getResponseFields(remote)
			if _, err := listener.WriteTo([]byte(responseFields), remote); err != nil {
				epLog.WithLabels("id", id).Warnf("UDP failed writing echo response: %v", err)
			}
		}
	}()

	// Notify the WaitGroup once the port has transitioned to ready.
	go s.awaitReady(onReady, listener.LocalAddr().String())
	return nil
}

		p.atleastOnceReady = true
	}
	return err
}

type ServerInfoState int32

const (
	// Server is live and serving traffic.
	Live ServerInfoState = 0
	// Server is draining listeners in response to external health checks failing.
	Draining ServerInfoState = 1
	// Server has not yet completed cluster manager initialization.
	PreInitializing ServerInfoState = 2

	err = adscConn.Run()
	if err != nil {
		return nil, fmt.Errorf("ADSC: failed running %v", err)
	}

	err = adscConn.Send(dr)
	if err != nil {
		return nil, err
	}
	response, err := adscConn.WaitVersion(opts.Timeout, dr.TypeUrl, "")
	return response, err
}

// DialOptions constructs gRPC dial options from command line configuration
func DialOptions(opts clioptions.CentralControlPlaneOptions,

	if isRedirect(response.StatusCode) { // Redirect
		// In other cases, we return the original status code. For redirects, it is illegal to
		// not have Location header, so we need to switch to just 200.
		w.WriteHeader(http.StatusOK)
		return
	}
	// We only write the status code to the response.
	w.WriteHeader(response.StatusCode)
	// Return the body from probe as well
	b, _ := k8sUtilIo.ReadAtMost(response.Body, maxRespBodyLength)

							"",
						},
					},
				},
			}},
		}, valid: false},
		{name: "empty header name - response add", route: &networking.HTTPRoute{
			Route: []*networking.HTTPRouteDestination{{
				Destination: &networking.Destination{Host: "foo.baz"},
				Headers: &networking.Headers{
					Response: &networking.Headers_HeaderOperations{
						Add: map[string]string{
							"": "value",
						},
					},
				},