func namespacesReady(namespaces []corev1.Namespace) (bool, []string) {
	var notReady []string
	for _, namespace := range namespaces {
		if namespace.Status.Phase != corev1.NamespaceActive {
			notReady = append(notReady, "Namespace/"+namespace.Name)
		}
	}
	return len(notReady) == 0, notReady
}

func podsReady(pods []corev1.Pod) (bool, []string) {
	var notReady []string
	for _, pod := range pods {
		if !isPodReady(&pod) {

	}

	node, ok := a.GetObject().(*api.Node)
	if !ok {
		return admission.NewForbidden(a, fmt.Errorf("unexpected type %T", a.GetObject()))
	}

	// Taint node with NotReady taint at creation. This is needed to make sure
	// that nodes are added to the cluster with the NotReady taint. Otherwise,
	// a new node may receive the taint with some delay causing pods to be
	// scheduled on a not-ready node. Node controller will remove the taint

		name           string
		node           api.Node
		oldNode        api.Node
		operation      admission.Operation
		options        runtime.Object
		expectedTaints []api.Taint
	}{
		{
			name:           "notReady taint is added on creation",
			node:           myNodeObj,
			operation:      admission.Create,
			options:        &metav1.CreateOptions{},
			expectedTaints: []api.Taint{notReadyTaint},
		},
		{

		bootstrapGracePeriod: defaultBootstrapGraceperiod,
	}
	return &p
}

func (a *poller) lastError(err error) {
	a.lock.Lock()
	defer a.lock.Unlock()
	a.lastErr = err
}

func (a *poller) notReady() {
	a.lock.Lock()
	defer a.lock.Unlock()
	a.ready = false
}

func (a *poller) bootstrapping() {
	// bootstrapGracePeriod is read-only, so no lock is required
	timer := time.NewTimer(a.bootstrapGracePeriod)

			}},
			expect: []v1.EndpointSubset{{
				Addresses: []v1.EndpointAddress{{IP: "beef::1:2:3:4"}},
				Ports:     []v1.EndpointPort{{Port: 111}},
			}},
		}, {
			name: "one set, one notReady ip, one port",
			given: []v1.EndpointSubset{{
				NotReadyAddresses: []v1.EndpointAddress{{IP: "1.2.3.4"}},
				Ports:             []v1.EndpointPort{{Port: 111}},
			}},
			expect: []v1.EndpointSubset{{

	LargeClusterSizeThreshold int32
	// Zone is treated as unhealthy in nodeEvictionRate and secondaryNodeEvictionRate when at least
	// unhealthyZoneThreshold (no less than 3) of Nodes in the zone are NotReady
	UnhealthyZoneThreshold float32

        new File(temporaryFolder, "jdks/jdk-mac-2/" + DefaultJdkCacheDirectory.MARKER_FILE).createNewFile()

        new File(temporaryFolder, "jdks/notReady").tap { mkdirs() }

        when:
        def homes = jdkCacheDirectory.listJavaHomes()

        then:
        homes == ([install1, install2] as Set)
    }

	// Set some defaults
	s := &Server{
		ctx:        ctx,
		kubeClient: client,
		isReady:    ready,
		dataplane: &meshDataplane{
			kubeClient: client.Kube(),
			netServer:  netServer,
		},
	}
	s.NotReady()
	s.handlers = setupHandlers(s.ctx, s.kubeClient, s.dataplane, args.SystemNamespace)

	cniServer := startCniPluginServer(ctx, pluginSocket, s.handlers, s.dataplane)
	err = cniServer.Start()
	if err != nil {

	}

	notReadyControlPlanes := getNotReadyNodes(nodes.Items)
	if len(notReadyControlPlanes) != 0 {
		return errors.Errorf("there are NotReady control-planes in the cluster: %v", notReadyControlPlanes)
	}
	return nil
}

// staticPodManifestHealth makes sure the required static pods are presents

	// we need second healthy node in tests. Because of how the tests are written we need to update
	// the status of this Node.
	healthyNodeNewStatus := v1.NodeStatus{
		Conditions: []v1.NodeCondition{
			{
				Type:   v1.NodeReady,
				Status: v1.ConditionTrue,
				// Node status has just been updated, and is NotReady for 10min.