StabilityLevel: metrics.STABLE,
		},
		[]string{"zone"},
	)

	updateNodeHealthDuration = metrics.NewHistogram(
		&metrics.HistogramOpts{
			Subsystem:      nodeControllerSubsystem,
			Name:           updateNodeHealthKey,
			Help:           "Duration in seconds for NodeController to update the health of a single node.",

func AddOrUpdateDaemonPodTolerations(spec *v1.PodSpec) {
	// DaemonSet pods shouldn't be deleted by NodeController in case of node problems.
	// Add infinite toleration for taint notReady:NoExecute here
	// to survive taint-based eviction enforced by NodeController
	// when node turns not ready.
	v1helper.AddOrUpdateTolerationInPodSpec(spec, &v1.Toleration{
		Key:      v1.TaintNodeNotReady,

	"k8s.io/klog/v2"
)

const (
	// NodeHealthUpdateRetry controls the number of retries of writing
	// node health update.
	NodeHealthUpdateRetry = 5
	// NodeEvictionPeriod controls how often NodeController will try to
	// evict Pods from non-responsive Nodes.
	NodeEvictionPeriod = 100 * time.Millisecond
	// EvictionRateLimiterBurst is the burst value for all eviction rate
	// limiters
	EvictionRateLimiterBurst = 1
)

	// CIDR range allocations from the cloud to the cluster.
	IPAMFromCloudAllocatorType = "IPAMFromCloud"
)

// TODO: figure out the good setting for those constants.
const (
	// The amount of time the nodecontroller polls on the list nodes endpoint.
	apiserverStartupGracePeriod = 10 * time.Minute

	// The no. of NodeSpec updates NC can process concurrently.
	cidrUpdateWorkers = 30

			})
		},
	})

	return &podController{
		q:        q,
		informer: informer,
	}
}

func (c *podController) Run(stop <-chan struct{}) {
	go c.informer.Run(stop)
	kube.WaitForCacheSync("pod controller", stop, c.informer.HasSynced)
	c.q.Run(stop)
}

func (c *podController) HasSynced() bool {
	return c.q.HasSynced()
}

func (c *podController) WaitForSync(stopCh <-chan struct{}) bool {

        result.clientFailure == null

        and:
        1 * buildController.fromBuildModel(_, _) >> { Boolean b, BuildTreeModelAction modelAction ->
            modelAction.beforeTasks(modelController)
            modelAction.fromBuildModel(modelController)
        }
        1 * projectsLoadedAction.execute(_) >> result1
        1 * buildFinishedAction.execute(_) >> result2
        1 * buildEventConsumer.dispatch({

    def modelId = Stub(ModelIdentifier) {
        getName() >> 'some.model'
    }
    def modelScope = Mock(ToolingModelScope)
    def buildStateRegistry = Mock(BuildStateRegistry)
    def modelController = Mock(BuildTreeModelController)
    def workerThreadRegistry = Mock(WorkerThreadRegistry)
    def parameterCarrierFactory = Mock(ToolingModelParameterCarrier.Factory)
    def buildEventConsumer = Mock(BuildEventConsumer)

    def payloadSerializer = Mock(PayloadSerializer)
    def gradle = Stub(GradleInternal)
    def buildController = Mock(BuildTreeLifecycleController) {
        getGradle() >> this.gradle
    }
    def modelController = Stub(BuildTreeModelController)
    def clientProvidedBuildAction = new ClientProvidedBuildAction(startParameter, action, false /* isRunTasks */, clientSubscriptions)

)

type workloadHandler interface {
	WorkloadReady(w *workload)
	WorkloadNotReady(w *workload)
}

type workloadManager struct {
	workloads     []*workload
	mutex         sync.Mutex
	podController *podController
	cfg           echo.Config
	ctx           resource.Context
	grpcPort      uint16
	tls           *echoCommon.TLSSettings
	closing       bool
	stopCh        chan struct{}
	handler       workloadHandler
}