sanitize

type Cluster struct {
	*issues.Collector
	ClusterLister
}

type ClusterLister interface {
	ListVersion() (string, string)
}

type ClusterMetricsLister interface {
	ListClusterMetrics() v1.ResourceList
}

type ClusterRoleBindingLister interface {
	ListClusterRoleBindings() map[string]*rbacv1.ClusterRoleBinding
}

type Collector interface {
	Outcome() issues.Outcome
	AddSubCode(id issues.ID, p, s string, args ...interface{})
}

type ConfigLister interface {
	CPUResourceLimits() config.Allocations
	MEMResourceLimits() config.Allocations
}

type ConfigMap struct {
	*issues.Collector
	ConfigMapLister
}

type ConfigMapLister interface {
	PodRefs
	ListConfigMaps() map[string]*v1.ConfigMap
}

type ConsumptionMetrics struct {
	QOS                    v1.PodQOSClass
	CurrentCPU, CurrentMEM resource.Quantity
	RequestCPU, RequestMEM resource.Quantity
	LimitCPU, LimitMEM     resource.Quantity
	RequestedStorage       resource.Quantity
}

type Container struct {
	LimitCollector
	// contains filtered or unexported fields
}

type DaemonLister interface {
	ListDaemonSets() map[string]*appsv1.DaemonSet
}

type DaemonSet struct {
	*issues.Collector
	DaemonSetLister
}

type DaemonSetLister interface {
	PodLimiter
	PodsMetricsLister
	PodSelectorLister
	ConfigLister
	DaemonLister
}

type DeployLister interface {
	ListDeployments() map[string]*appsv1.Deployment
}

type Deployment struct {
	*issues.Collector
	DeploymentLister
}

type DeploymentLister interface {
	PodLimiter
	PodsMetricsLister
	PodSelectorLister
	ConfigLister
	DeployLister
}

type EndPointLister interface {
	GetEndpoints(string) *v1.Endpoints
}

type HorizontalPodAutoscaler struct {
	*issues.Collector
	HpaLister
}

type HpaLister interface {
	DeployLister
	StatefulSetLister
	ClusterMetricsLister
	NodeMetricsLister
	ListHorizontalPodAutoscalers() map[string]*autoscalingv1.HorizontalPodAutoscaler
}

type IngLister interface {
	ListIngresses() map[string]*nv1beta1.Ingress
}

type Ingress struct {
	*issues.Collector
	IngressLister
}

type IngressLister interface {
	IngLister
}

type LimitCollector interface {
	Collector
	PodLimiter
}

type Namespace struct {
	*issues.Collector
	NamespaceLister
}

type NamespaceLister interface {
	NamespaceRefs
	ListNamespaces() map[string]*v1.Namespace
}

type NamespaceRefs interface {
	ReferencedNamespaces(map[string]struct{})
}

type NamespaceSelectorLister interface {
	ListNamespacesBySelector(sel *metav1.LabelSelector) map[string]*v1.Namespace
}

type NetworkPolicy struct {
	*issues.Collector
	NetworkPolicyLister
}

type NetworkPolicyLister interface {
	PodSelectorLister
	NamespaceSelectorLister
	ListNetworkPolicies() map[string]*nv1.NetworkPolicy
}

type Node struct {
	*issues.Collector
	NodeLister
}

type NodeLimiter interface {
	NodeCPULimit() float64
	NodeMEMLimit() float64
}

type NodeLister interface {
	NodeMetricsLister
	PodLister
	NodeLimiter
	ListNodes() map[string]*v1.Node
}

type NodeMetricsLister interface {
	ListNodesMetrics() map[string]*mv1beta1.NodeMetrics
}

type PdbLister interface {
	ListPodDisruptionBudgets() map[string]*pv1beta1.PodDisruptionBudget
	ForLabels(labels map[string]string) *pv1beta1.PodDisruptionBudget
}

type PersistentVolume struct {
	*issues.Collector
	PersistentVolumeLister
}

type PersistentVolumeClaim struct {
	*issues.Collector
	PersistentVolumeClaimLister
}

type PersistentVolumeClaimLister interface {
	ListPersistentVolumeClaims() map[string]*v1.PersistentVolumeClaim
	PodLister
}

type PersistentVolumeLister interface {
	ListPersistentVolumes() map[string]*v1.PersistentVolume
}

type Pod struct {
	*issues.Collector
	PodMXLister
}

type PodDisruptionBudget struct {
	*issues.Collector
	PodDisruptionBudgetLister
}

type PodDisruptionBudgetLister interface {
	PodLister
	ListPodDisruptionBudgets() map[string]*pv1beta1.PodDisruptionBudget
}

type PodGetter interface {
	GetPod(map[string]string) *v1.Pod
}

type PodLimiter interface {
	PodCPULimit() float64
	PodMEMLimit() float64
	RestartsLimit() int
}

type PodLister interface {
	ListPods() map[string]*v1.Pod
	GetPod(sel map[string]string) *v1.Pod
}

type PodMXLister interface {
	PodLimiter
	PodMetricsLister
	PodLister
	PdbLister
}

type PodMetric interface {
	CurrentCPU() int64
	CurrentMEM() int64
	Empty() bool
}

type PodMetricsLister interface {
	ListPodsMetrics() map[string]*mv1beta1.PodMetrics
}

type PodRefs interface {
	PodRefs(cache.ObjReferences)
}

type PodSecurityPolicy struct {
	*issues.Collector
	PodSecurityPolicyLister
}

type PodSecurityPolicyLister interface {
	ListPodSecurityPolicies() map[string]*pv1beta1.PodSecurityPolicy
}

type PodSelectorLister interface {
	ListPodsBySelector(sel *metav1.LabelSelector) map[string]*v1.Pod
}

type PodsMetricsLister interface {
	ListPodsMetrics() map[string]*mv1beta1.PodMetrics
}

type PopeyeKey string

type ReplicaLister interface {
	ListReplicaSets() map[string]*appsv1.ReplicaSet
}

type ReplicaSet struct {
	*issues.Collector
	ReplicaSetLister
}

type ReplicaSetLister interface {
	ReplicaLister
}

type RoleBindingLister interface {
	ListRoleBindings() map[string]*rbacv1.RoleBinding
}

type SARefs interface {
	ServiceAccountRefs(cache.ObjReferences)
}

type Secret struct {
	*issues.Collector
	SecretLister
}

type SecretLister interface {
	PodRefs
	SARefs
	ListSecrets() map[string]*v1.Secret
}

type Service struct {
	*issues.Collector
	ServiceLister
}

type ServiceAccount struct {
	*issues.Collector

	ServiceAccountLister
}

type ServiceAccountLister interface {
	PodLister
	ClusterRoleBindingLister
	RoleBindingLister
	SecretLister

	ListServiceAccounts() map[string]*v1.ServiceAccount
}

type ServiceLister interface {
	PodGetter
	EndPointLister
	ListServices() map[string]*v1.Service
}

type StatefulSet struct {
	*issues.Collector
	StatefulSetLister
}

type StatefulSetLister interface {
	PodLimiter
	ConfigLister
	PodSelectorLister
	PodsMetricsLister

	ListStatefulSets() map[string]*appsv1.StatefulSet
}