if obj == nil {
		return false
	}
	switch t := obj.(type) {
	case *corev1.Pod:
		return t.GetAnnotations()[constants.AmbientRedirection] == constants.AmbientRedirectionEnabled
	case *corev1.Namespace:
		if t.GetLabels()["istio-injection"] == "enabled" {
			return false
		}
		if v, ok := t.GetLabels()[label.IoIstioRev.Name]; ok && v != "" {
			return false
		}

    @Override
    public CustomModel execute(BuildController controller) {
        CustomModel model1 = controller.getModel(CustomModel.class);
        CustomModel model2 = controller.getModel(CustomModel.class);
        assert model1.getThing() == model2.getThing();
        return model1;
    }

			if runningConditionIdx != -1 {
				toBeUpdatedSVM.Status.Conditions[runningConditionIdx].Status = corev1.ConditionFalse
			}
		}

		toBeUpdatedSVM.Status.Conditions = append(toBeUpdatedSVM.Status.Conditions, svmv1alpha1.MigrationCondition{
			Type:           conditionType,
			Status:         corev1.ConditionTrue,
			LastUpdateTime: metav1.Now(),
			Reason:         reason,
		})
	}

	return toBeUpdatedSVM

func taintNodes(t resource.Context) error {
	nodeC := t.Clusters().Default().Kube().CoreV1().Nodes()
	nodes, err := nodeC.List(context.TODO(), metav1.ListOptions{})
	if err != nil {
		return err
	}

Outer:
	for _, node := range nodes.Items {
		for _, taint := range node.Spec.Taints {
			if taint.Key == "cni.istio.io/not-ready" {
				continue Outer
			}
		}
		node.Spec.Taints = append(node.Spec.Taints, corev1.Taint{

	var firstService *corev1.ServiceSpec
	var firstCluster cluster.ID
	for id, instance := range services {
		firstCluster = id
		firstService = instance.Message.(*corev1.ServiceSpec)
		if firstService != nil {
			break
		}
	}

	var addedHeadless bool
	for id, instance := range services {
		service := instance.Message.(*corev1.ServiceSpec)

		}
	}

	return nsNameList, nil
}

func getNamespaces(ctx context.Context, client kube.CLIClient) ([]corev1.Namespace, error) {
	nslist, err := client.Kube().CoreV1().Namespaces().List(ctx, metav1.ListOptions{})
	if err != nil {
		return []corev1.Namespace{}, err
	}
	return nslist.Items, nil
}

	for _, pod := range igPods {
		// only Running pods are valid
		if pod.Status.Phase != corev1.PodRunning {
			continue
		}

		// Find node external IP
		node := s.nodes.Get(pod.Spec.NodeName, "")
		if node == nil {
			continue
		}

		for _, address := range node.Status.Addresses {
			if address.Type == corev1.NodeExternalIP {
				if address.Address != "" && !addressInSlice(address.Address, addrs) {

        given:
        def spec = Mock(Spec)
        def node1 = new TestResolvedDependency()
        def node2 = new TestResolvedDependency()
        def node3 = new TestResolvedDependency()
        def firstLevelDependencies = [(Mock(ModuleDependency)): node1, (Mock(ModuleDependency)): node2, (Mock(ModuleDependency)): node3]
        def firstLevelDependenciesEntries = firstLevelDependencies.entrySet() as List

	g.updatePod(nil, obj)
}

func (g *graphPopulator) updatePod(oldObj, obj interface{}) {
	pod := obj.(*corev1.Pod)
	if len(pod.Spec.NodeName) == 0 {
		// No node assigned
		klog.V(5).Infof("updatePod %s/%s, no node", pod.Namespace, pod.Name)
		return
	}
	if oldPod, ok := oldObj.(*corev1.Pod); ok && oldPod != nil {
		if (pod.Spec.NodeName == oldPod.Spec.NodeName) && (pod.UID == oldPod.UID) &&

            @Override
            public void execute(CustomParameter customParameter) {
                customParameter.setValue(model1.getParameterValue() + ":parameter2");
            }
        });
        result.add(model0);
        result.add(model1);
        result.add(model2);
        return result;
    }