"update",
                "watch"
              ]
            },
            {
              "categories": [
                "all"
              ],
              "resource": "daemonsets",
              "responseKind": {
                "group": "",
                "kind": "DaemonSet",
                "version": ""
              },
              "scope": "Namespaced",
              "shortNames": [

		})
		if err != nil {
			return err
		}
		if len(deployList.Items) > 0 {
			return fmt.Errorf("workloads still remain in %s", IstioNamespace)
		}
		dsList, err := cs.Kube().AppsV1().DaemonSets(IstioNamespace).List(context.TODO(), metav1.ListOptions{
			LabelSelector: label.IoIstioRev.Name,
		})
		if err != nil {
			return err
		}
		if len(dsList.Items) > 0 {

				{Name: "replicationcontrollers", Namespaced: true, Kind: "ReplicationController"},
			},
		},
		{
			GroupVersion: appsv1.SchemeGroupVersion.String(),
			APIResources: []metav1.APIResource{
				{Name: "daemonsets", Namespaced: true, Kind: "DaemonSet"},
			},
		},
	}
	restMapperRes, err := restmapper.GetAPIGroupResources(fakeDiscoveryClient)
	if err != nil {

		log.Infof("Done with operator logs for %v/%v", namespace, pod)
	}()
}

// getCniLogs fetches Cni logs from istio-cni-node daemonsets inside namespace kube-system and writes the output
// Runs if a goroutine, with errors reported through gErrors
func getCniLogs(runner *kubectlcmd.Runner, config *config.BugReportConfig, resources *cluster2.Resources,

			return err
		}
		return f(configWriter)
	}
}

func PodOnNodeFromDaemonset(node string, name, namespace string, client kube.Client) (types.NamespacedName, error) {
	ds, err := client.Kube().AppsV1().DaemonSets(namespace).Get(context.Background(), name, metav1.GetOptions{})
	if err != nil {
		return types.NamespacedName{}, err
	}
	selector := ds.Spec.Selector
	if selector == nil {

		ValidateProto: validation.EmptyValidate,
	}.MustBuild()

	DaemonSet = resource.Builder{
		Identifier:    "DaemonSet",
		Group:         "apps",
		Kind:          "DaemonSet",
		Plural:        "daemonsets",
		Version:       "v1",
		Proto:         "k8s.io.api.apps.v1.DaemonSetSpec",
		ReflectType:   reflect.TypeOf(&k8sioapiappsv1.DaemonSetSpec{}).Elem(),
		ProtoPackage:  "k8s.io/api/apps/v1",
		ClusterScoped: false,

    echo "${boot_id}"
    return ${kubectl_rc}
  fi

  # Drain node
  echo "== Draining ${instance}. == " >&2
  local drain_rc
  "${KUBE_ROOT}/cluster/kubectl.sh" drain --delete-emptydir-data --force --ignore-daemonsets "${instance}" \
    && drain_rc=$? || drain_rc=$?
  if [[ "${drain_rc}" != 0 ]]; then
    echo "== FAILED to drain ${instance} =="
    return ${drain_rc}
  fi

  # Recreate instance

		controllerContext.InformerFactory.Coordination().V1().Leases(),
		controllerContext.InformerFactory.Core().V1().Pods(),
		controllerContext.InformerFactory.Core().V1().Nodes(),
		controllerContext.InformerFactory.Apps().V1().DaemonSets(),
		// node lifecycle controller uses existing cluster role from node-controller
		controllerContext.ClientBuilder.ClientOrDie("node-controller"),
		controllerContext.ComponentConfig.KubeCloudShared.NodeMonitorPeriod.Duration,

}

func (RollingUpdateDaemonSet) SwaggerDoc() map[string]string {
	return map_RollingUpdateDaemonSet
}

  // Allowing surge implies the possibility that the resources consumed by the
  // daemonset on any given node can double if the readiness check fails, and
  // so resource intensive daemonsets should take into account that they may
  // cause evictions during disruption.
  // +optional
  optional k8s.io.apimachinery.pkg.util.intstr.IntOrString maxSurge = 2;
}