recv, send time.Duration
}

func (w *slowClientStream) RecvMsg(m any) error {
	if w.recv > 0 {
		sleep.UntilContext(w.Context(), w.recv)
		log.Infof("delayed recv for %v", w.recv)
	}
	return w.ClientStream.RecvMsg(m)
}

func (w *slowClientStream) SendMsg(m any) error {
	if w.send > 0 {
		sleep.UntilContext(w.Context(), w.send)
		log.Infof("delayed send for %v", w.send)
	}
	return w.ClientStream.SendMsg(m)
}

// limitations under the License.

package sleep

import (
	"context"
	"time"
)

// UntilContext sleeps for the given duration, or until the context is complete.
// Returns true if the sleep completes the full duration
func UntilContext(ctx context.Context, d time.Duration) bool {
	return Until(ctx.Done(), d)
}

// Until sleeps for the given duration, or until the channel is closed.

	}

	for {
		select {
		case <-ctx.Done():
			return GetPrivateIPsIfAvailable()
		default:
			addr, ok := GetPrivateIPsIfAvailable()
			if ok {
				return addr, true
			}
			sleep.UntilContext(ctx, waitInterval)
		}
	}
}

// GetPrivateIPsIfAvailable returns all the private IP addresses
func GetPrivateIPsIfAvailable() ([]string, bool) {
	ok := true
	ipAddresses := make([]string, 0)

		log.Warnf("got an event for pod %s in namespace %s not found in current pod cache, retry %d of %d",
			name, namespace, retries, maxStaleRetries)
		if !sleep.UntilContext(s.ctx, time.Duration(msInterval)*time.Millisecond) {
			return nil, fmt.Errorf("aborted")
		}
	}
	if err != nil {
		return nil, fmt.Errorf("failed to get pod %s/%s: %v", namespace, name, err)
	}