serverOk = false
				}
			}
			if serverOk && setUpUdsOK {
				started = true
				break
			}
			time.Sleep(waitTime)
			waitTime *= 2
		}
		if !started {
			sdsServiceLog.Warn("SDS grpc server could not be started")
		}
	}()
}

func (s *Server) grpcServerOptions() []grpc.ServerOption {
	grpcOptions := []grpc.ServerOption{

        @Override
        public void started(BuildOperationDescriptor buildOperation, OperationStartEvent startEvent) {
            List<? extends BuildOperationListener> listeners = DefaultBuildOperationListenerManager.this.listeners;
            //noinspection ForLoopReplaceableByForEach
            for (int i = 0; i < listeners.size(); ++i) {
                listeners.get(i).started(buildOperation, startEvent);
            }
        }

	// WaitForCacheSync blocks until all started informers' caches were synced
	// or the stop channel gets closed.
	WaitForCacheSync(stopCh <-chan struct{}) bool

	// Shutdown marks a factory as shutting down. At that point no new
	// informers can be started anymore and Start will return without
	// doing anything.
	//

public interface WorkerProcessFactory {
    /**
     * Creates a builder for workers that will run the given action. The worker action is serialized to the worker process and executed.
     *
     * <p>The worker process is not started until {@link WorkerProcess#start()} is called.</p>
     *
     * @param workerAction The action to serialize and run in the worker process.
     */

     *
     * <p>This must be called before {@link #started()}.
     *
     * @param description The description.
     */
    ProgressLogger setDescription(String description);

    /**
     * Convenience method that sets descriptions and logs started() event.
     *
     * @param status The initial status message. Can be null or empty.
     * @return this logger instance

[19515] [INFO] Booting worker with pid: 19515
[19511] [INFO] Started server process [19511]
[19511] [INFO] Waiting for application startup.
[19511] [INFO] Application startup complete.
[19513] [INFO] Started server process [19513]
[19513] [INFO] Waiting for application startup.
[19513] [INFO] Application startup complete.
[19514] [INFO] Started server process [19514]
[19514] [INFO] Waiting for application startup.

    name: nameValue
    ready: true
    resources:
      claims:
      - name: nameValue
      limits:
        limitsKey: "0"
      requests:
        requestsKey: "0"
    restartCount: 5
    started: true
    state:
      running:
        startedAt: "2001-01-01T01:01:01Z"
      terminated:
        containerID: containerIDValue
        exitCode: 1
        finishedAt: "2006-01-01T01:01:01Z"

	}
	s.hm.Lock()
	defer s.hm.Unlock()
	s.started = stop
}

var _ Informer[controllers.Object] = &delayedClient[controllers.Object]{}

func (s *delayedClient[T]) set(inf Informer[T]) {
	if inf != nil {
		s.inf.Swap(&inf)
		s.hm.Lock()
		defer s.hm.Unlock()
		for _, h := range s.handlers {
			inf.AddEventHandler(h)
		}
		s.handlers = nil
		if s.started != nil {
			inf.Start(s.started)
		}
	}

 */

package org.gradle.launcher.daemon.logging;

public abstract class DaemonMessages {
    public final static String PROCESS_STARTED = "Daemon server started.";
    public final static String ABOUT_TO_CLOSE_STREAMS = "Daemon started. About to close the streams. Daemon details: ";
    public final static String STARTED_RELAYING_LOGS = "The client will now receive all logging from the daemon (pid: ";

		wantErr               error
	}{
		{
			desc:                  "not-started",
			inValues:              "",
			startRender:           false,
			inChart:               chart.Chart{},
			objFileTemplateReader: Renderer{},
			wantResult:            "",
			wantErr:               errors.New("fileTemplateRenderer for not started in renderChart"),
		},
		{
			desc: "started-random-template",
			inValues: `
description: test
`,