)

// Result of a traffic generation operation.
type Result struct {
	TotalRequests      int
	SuccessfulRequests int
	Error              error
}

func (r Result) String() string {
	buf := &bytes.Buffer{}

	_, _ = fmt.Fprintf(buf, "TotalRequests:       %d\n", r.TotalRequests)
	_, _ = fmt.Fprintf(buf, "SuccessfulRequests:  %d\n", r.SuccessfulRequests)

}

func (tm testMetrics) totalRequests() uint64 {
	return tm.requestsSameZone + tm.requestsSameRegion + tm.requestsOtherRegion
}

func (tm testMetrics) sameZonePercent() float64 {
	return (float64(tm.requestsSameZone) / float64(tm.totalRequests())) * 100
}

func (tm testMetrics) sameRegionPercent() float64 {
	return (float64(tm.requestsSameRegion) / float64(tm.totalRequests())) * 100
}

}

type connection struct {
	request func(onDone func())
	helper  *ConnectionHelper
}

func (c *connection) Name() string {
	return c.helper.Name()
}

func (c *connection) TotalRequests() uint64 {
	return c.helper.TotalRequests()
}

func (c *connection) ActiveRequests() uint64 {
	return c.helper.ActiveRequests()
}

func (c *connection) Latency() *timeseries.Instance {
	return c.helper.Latency()
}

	"golang.org/x/sync/semaphore"
)

const (
	maxConcurrencyPerForward = 20
)

type executor struct {
	totalRequests  *atomic.Uint64
	activeRequests *atomic.Uint64
	stopCh         chan struct{}
}

func newExecutor() *executor {
	e := &executor{
		totalRequests:  atomic.NewUint64(0),
		activeRequests: atomic.NewUint64(0),
		stopCh:         make(chan struct{}),
	}

	return e
}

	clippedLatency := math.Min(latency, float64(maxQLatency.Milliseconds()))

	// Return the latency as milliseconds.
	return time.Duration(clippedLatency) * time.Millisecond
}

func (n *Node) TotalRequests() uint64 {
	return n.helper.TotalRequests()
}

func (n *Node) ActiveRequests() uint64 {
	return n.helper.ActiveRequests()
}

func (n *Node) Latency() *timeseries.Instance {
	return n.helper.Latency()
}

	lb.helper.Request(c.Request, onDone)
}

func (lb *weightedConnections) Name() string {
	return lb.helper.Name()
}

func (lb *weightedConnections) TotalRequests() uint64 {
	return lb.helper.TotalRequests()
}

func (lb *weightedConnections) ActiveRequests() uint64 {
	return lb.helper.ActiveRequests()
}

func (lb *weightedConnections) Latency() *timeseries.Instance {

// failed functions.
func (target *WebhookTarget) Stat() event.TargetStat {
	return event.TargetStat{
		ID:             target.id,
		ActiveRequests: atomic.LoadInt64(&target.activeRequests),
		TotalRequests:  atomic.LoadInt64(&target.totalRequests),
		FailedRequests: atomic.LoadInt64(&target.failedRequests),
	}
}

// Send - sends an event to the webhook.

	return &ConnectionHelper{
		active: atomic.NewUint64(0),
		total:  atomic.NewUint64(0),
		name:   name,
	}
}

func (c *ConnectionHelper) Name() string {
	return c.name
}

func (c *ConnectionHelper) TotalRequests() uint64 {
	return c.total.Load()
}

func (c *ConnectionHelper) ActiveRequests() uint64 {
	return c.active.Load()
}

func (c *ConnectionHelper) Latency() *timeseries.Instance {
	return &c.hist
}

	m.Set(pluginAuthnServiceSuccAvgRttMsMinute, pluginAuthNMetrics.AvgSuccRTTMs)
	m.Set(pluginAuthnServiceSuccMaxRttMsMinute, pluginAuthNMetrics.MaxSuccRTTMs)
	m.Set(pluginAuthnServiceTotalRequestsMinute, float64(pluginAuthNMetrics.TotalRequests))
	lastSyncTime := atomic.LoadUint64(&globalIAMSys.LastRefreshTimeUnixNano)
	if lastSyncTime != 0 {
		m.Set(sinceLastSyncMillis, float64((uint64(time.Now().UnixNano())-lastSyncTime)/uint64(time.Millisecond)))
	}

	// Trigger the generator to stop.
	close(g.stop)

	// Wait for the generator to exit.
	t := time.NewTimer(g.StopTimeout)
	select {
	case <-g.stopped:
		t.Stop()
		if g.result.TotalRequests == 0 {
			g.t.Fatal("no requests completed before stopping the traffic generator")
		}
		return g.result
	case <-t.C:
		g.t.Fatal("timed out waiting for result")
	}