"If true, Pilot will cache XDS responses.").Get()

	// EnableCDSCaching determines if CDS caching is enabled. This is explicitly split out of ENABLE_XDS_CACHE,
	// so that in case there are issues with the CDS cache we can just disable the CDS cache.
	EnableCDSCaching = env.Register("PILOT_ENABLE_CDS_CACHE", true,
		"If true, Pilot will cache CDS responses. Note: this depends on PILOT_ENABLE_XDS_CACHE.").Get()

		}

		return &proto.ForwardEchoResponse{
			Output: responses,
		}, nil
	case <-ctx.Done():
		responsesMu.Lock()
		defer responsesMu.Unlock()

		var c int
		var tt time.Duration
		for id, res := range responses {
			if res != "" && responseTimes[id] != 0 {
				c++
				tt += responseTimes[id]
			}
		}
		var avgTime time.Duration

	"istio.io/istio/pilot/pkg/model"
	xdsresource "istio.io/istio/pilot/pkg/xds/v3"
	"istio.io/istio/pkg/log"
)

// XdsStatusWriter enables printing of sync status using multiple xdsapi.DiscoveryResponse Istiod responses
type XdsStatusWriter struct {
	Writer                 io.Writer
	Namespace              string
	InternalDebugAllIstiod bool
}

type xdsWriterStatus struct {
	proxyID               string

		Server: s,
	}
}

// Generate XDS responses about internal events:
// - connection status
// - NACKs
// We can also expose ACKS.
func (sg *StatusGen) Generate(proxy *model.Proxy, w *model.WatchedResource, req *model.PushRequest) (model.Resources, model.XdsLogDetails, error) {
	return sg.handleInternalRequest(proxy, w, req)
}

// Generate delta XDS responses about internal events:
// - connection status
// - NACKs

		"pilot_xds_rds_reject",
		"Pilot rejected RDS.",
	)

	totalXDSRejects = monitoring.NewSum(
		"pilot_total_xds_rejects",
		"Total number of XDS responses from pilot rejected by proxy.",
	)

	ResponseWriteTimeouts = monitoring.NewSum(
		"pilot_xds_write_timeout",
		"Pilot XDS response write timeouts.",
	)

	sendTime = monitoring.NewDistribution(
		"pilot_xds_send_time",

	hreq, _ := http.NewRequest(http.MethodGet, debugURL, nil)
	handler, _ := dg.DebugMux.Handler(hreq)
	response := NewResponseCapture()
	handler.ServeHTTP(response, hreq)
	if response.wroteHeader && len(response.header) >= 1 {
		header, _ := json.Marshal(response.header)
		buffer.Write(header)
	}
	buffer.Write(response.body.Bytes())
	return buffer

package echo

import (
	"istio.io/istio/pkg/test"
	"istio.io/istio/pkg/test/echo"
)

// CallResult the result of a call operation.
type CallResult struct {
	From      Caller
	Opts      CallOptions
	Responses echo.Responses
}

type Caller interface {
	// Call from this Instance to a target Instance.
	Call(options CallOptions) (CallResult, error)
	CallOrFail(t test.Failer, options CallOptions) CallResult
}

	protocolMap[scheme.UDP] = add(newUDPProtocol(e))

	return &Instance{
		e:           e,
		protocolMap: protocolMap,
		protocols:   protocols,
	}
}

// ForwardEcho sends the requests and collect the responses.
func (i *Instance) ForwardEcho(ctx context.Context, cfg *Config) (*proto.ForwardEchoResponse, error) {
	if err := cfg.fillDefaults(); err != nil {
		return nil, err
	}

	// Lookup the protocol.

//  See the License for the specific language governing permissions and
//  limitations under the License.

package echo

import (
	"fmt"
	"io"
)

// Field is a list of fields returned in responses from the Echo server.
type Field string

func (f Field) String() string {
	return string(f)
}

func (f Field) Write(out io.StringWriter, value string) {
	_, _ = out.WriteString(fmt.Sprintf("%s=%s\n", f, value))

	}
	return nil
}

func (c *Client) Echo(ctx context.Context, request *proto.EchoRequest) (Response, error) {
	resp, err := c.client.Echo(ctx, request)
	if err != nil {
		return Response{}, err
	}
	return parseResponse(resp.Message), nil
}

// ForwardEcho sends the given forward request and parses the response for easier processing. Only fails if the request fails.