"istio.io/istio/pkg/kube/kclient"
	"istio.io/istio/pkg/kube/krt"
	"istio.io/istio/pkg/kube/kubetypes"
	istiolog "istio.io/istio/pkg/log"
)

var log = istiolog.RegisterScope("untaint", "CNI node-untaint controller")

const (
	TaintName = "cni.istio.io/not-ready"
)

var istioCniLabels = map[string]string{
	"k8s-app": "istio-cni-node",
}

type NodeUntainter struct {

 */

package org.gradle.plugins.ide.eclipse.model;

import groovy.util.Node;

/**
 * A container classpath entry.
 */
public class Container extends AbstractClasspathEntry {

    public Container(Node node) {
        super(node);
    }

    public Container(String path) {
        super(path);
    }

    @Override
    public String getKind() {
        return "con";
    }

  selector:
    matchLabels:
      app: app
  strategy: {}
  template:
    metadata:
      annotations:
        istio.io/rev: default
        kubectl.kubernetes.io/default-container: name1
        kubectl.kubernetes.io/default-logs-container: name1
        prometheus.io/path: /stats/prometheus
        prometheus.io/port: "15020"
        prometheus.io/scrape: "true"

	s := newNodeUntainterTestServer(t)
	s.addTaintedNodes(t, "node1", "node2")
	s.addPod(t, "node2", true, cniPodLabels, "default")
	s.addCniPod(t, "node1", true)

	// wait for the untainter to run
	s.assertNodeUntainted(t, "node1")
	s.assertNodeTainted(t, "node2")
}

func (s *nodeTainterTestServer) assertNodeTainted(t *testing.T, node string) {
	t.Helper()

John Howard <******@****.***> 1709052916 -0800

	framework.
		NewTest(t).
		Run(func(ctx framework.TestContext) {
			// make cni not deploy to one of the nodes
			taintNodes(ctx)

			// make sure all nodes were untainted
			retry.UntilSuccessOrFail(t, func() error {
				nodeC := ctx.Clusters().Default().Kube().CoreV1().Nodes()
				nodes, err := nodeC.List(ctx.Context(), metav1.ListOptions{})
				if err != nil {
					return err
				}

				for _, node := range nodes.Items {

        container.newElement("b", [3, 4], null)
        expect:
        container.size == 2
        container.popConflict().toString() == "a:1,2"
        container.popConflict().toString() == "b:3,4"
    }

    def "pops conflicts orderly"() {
        container.newElement("c", [5, 6], null)
        container.newElement("b", [3, 4], null)
        container.newElement("a", [1, 2], null)
        expect:
        container.size == 3

			containers:        []v1.Container{{Name: "container-1"}, {Name: "container-2"}},
			statuses:          []v1.ContainerStatus{{Name: "container-1"}, {Name: "container-2"}},
			idx:               1,
			expectedContainer: v1.Container{Name: "container-2"},
			expectedOK:        true,
		},
	}

	for _, tc := range testCases {
		container, ok := GetContainerByIndex(tc.containers, tc.statuses, tc.idx)

        container.getByName("foo") == extension
        container.findByName("bar") == barExtension

        container.getByType(BarExtension) == barExtension
        container.findByType(FooExtension) == extension

        container.findByType(SomeExtension) == null
        container.findByName("i don't exist") == null
    }

    def "throws when unknown exception wanted by name"() {
        container.add("foo", extension)

        when:
        container.addRule(rule1)
        container.addClassRule(rule2)

        then:
        !container.isEmpty()
        !container.isClassBasedRulesOnly()
        def iterator = container.iterator()
        def ruleWrapper = iterator.next()
        !ruleWrapper.isClassBased()
        ruleWrapper.rule == rule1
        def ruleWrapper2 = iterator.next()
        ruleWrapper2.isClassBased()