ready := make(chan struct{}, 1)
	listeningTestProbe = func() {
		ready <- struct{}{}
	}
	defer func() { listeningTestProbe = nil }()

	// Start and wait for server
	o := DefaultOptions()
	o.Port = 0
	s, err := Run(o, nil)
	if err != nil {
		t.Fatalf("Failed to start server: %v", err)
	}
	select {
	case <-ready:
	case <-time.After(5 * time.Second):

type Options struct {
	PurgeInterval         time.Duration
	ModuleExpiry          time.Duration
	InsecureRegistries    sets.String
	HTTPRequestTimeout    time.Duration
	HTTPRequestMaxRetries int
}

func defaultOptions() Options {
	return Options{
		PurgeInterval:         DefaultPurgeInterval,
		ModuleExpiry:          DefaultModuleExpiry,
		InsecureRegistries:    sets.New[string](),
		HTTPRequestTimeout:    DefaultHTTPRequestTimeout,

	// scope is for dev logging.  Warning: log levels are not set by --log_output_level until command is Run().
	Scope = log.RegisterScope("cli", "istioctl")
)

func defaultLogOptions() *log.Options {
	o := log.DefaultOptions()
	// Default to warning for everything; we usually don't want logs in istioctl
	o.SetDefaultOutputLevel("all", log.WarnLevel)
	// These scopes are too noisy even at warning level

}

func serverCmd() *cobra.Command {
	loggingOptions := log.DefaultOptions()
	introspectionOptions := ctrlz.DefaultOptions()
	sArgs := &serverArgs{}
	serverCmd := &cobra.Command{
		Use:   "server",
		Short: "Starts the Istio operator server",
		Args:  cobra.ExactArgs(0),

	cltInstance := GetClientInstances()[0]

	defaultOptions := []retry.Option{retry.Delay(100 * time.Millisecond), retry.Timeout(200 * time.Second)}
	httpOpts := echo.CallOptions{
		To: GetTarget(),
		Port: echo.Port{
			Name: "http",
		},
		HTTP: echo.HTTP{
			Path:   "/path",
			Method: "GET",
		},
		Count: 1,
		Retry: echo.Retry{
			Options: append(defaultOptions, options...),
		},
		Check: checker,
	}

			RotationMaxBackups:  1234,
		}},
	}

	for j := 0; j < 2; j++ {
		for i, c := range cases {
			t.Run(strconv.Itoa(j*100+i), func(t *testing.T) {
				o := DefaultOptions()
				cmd := &cobra.Command{}
				o.AttachCobraFlags(cmd)
				cmd.SetArgs(strings.Split(c.cmdLine, " "))

				if err := cmd.Execute(); err != nil {
					t.Errorf("Got %v, expecting success", err)
				}

	udsDir := t.TempDir()
	socketPath := filepath.Join(udsDir, "test.sock")
	unixListener, err := net.Listen("unix", socketPath)
	if err != nil {
		t.Fatalf("failed to create uds listener: %v", err)
	}
	loggingOptions := DefaultOptions()
	loggingOptions.JSONEncoding = true
	if err := Configure(loggingOptions.WithTeeToUDS(socketPath, "/")); err != nil {
		t.Fatal(err)
	}
	mux := http.NewServeMux()
	mux.HandleFunc("/", srv.handleLog)

	defaultOutputLevels string
	logCallers          string
	stackTraceLevels    string

	useStackdriverFormat bool
	extensions           []Extension
}

// DefaultOptions returns a new set of options, initialized to the defaults
func DefaultOptions() *Options {
	return &Options{
		OutputPaths:          []string{defaultOutputPath},
		ErrorOutputPaths:     []string{defaultErrorOutputPath},

	defer close(stop)
	assert.NoError(t, logger.StartUDSLogServer(udsSock, stop))

	// Configure log to tee to UDS server
	stdout := os.Stdout
	r, w, _ := os.Pipe()
	os.Stdout = w
	loggingOptions := istiolog.DefaultOptions()
	loggingOptions.JSONEncoding = true
	loggingOptions.WithTeeToUDS(udsSock, constants.UDSLogPath)
	assert.NoError(t, istiolog.Configure(loggingOptions))
	istiolog.FindScope("default").SetOutputLevel(istiolog.DebugLevel)

		err := retry.UntilSuccess(func() error {
			if hasTargetRef {
				hostname := fmt.Sprintf("%s-gateway-istio.%s.svc.cluster.local", GetTarget().ServiceName(), apps.Namespace.Name())
				defaultOptions := []retry.Option{retry.Delay(100 * time.Millisecond), retry.Timeout(200 * time.Second)}
				httpOpts := echo.CallOptions{
					Address: hostname,
					Port: echo.Port{
						Name:        "http",