// Groovy is part of our API
    externalApi(libs.groovy)
    // Required to inject services into tasks and other objects
    externalApi(libs.inject)
    // Moslty used for nullability annotations
    externalApi(libs.jsr305)
    // We use this to annotate type parameters as @Nullable
    externalApi(libs.jetbrainsAnnotations)
    // SLF4J logging is part of our public API
    externalApi(libs.slf4jApi)

// that the public API depends on.
// TODO: We should be able to derive these dependencies automatically.
//       In fact, our public API should have no external dependencies.
val externalApi = configurations.dependencyScope("externalApi") {
    description = "External dependencies that the public Gradle API depends on"
}
val externalRuntimeOnly = configurations.dependencyScope("externalRuntimeOnly") {

import (
	"fmt"
	"io"
	"os"

	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/runtime/serializer"
	api "k8s.io/apiserver/pkg/apis/apiserver"
	"k8s.io/apiserver/pkg/apis/apiserver/install"
	externalapi "k8s.io/apiserver/pkg/apis/apiserver/v1alpha1"
)

var (
	scheme = runtime.NewScheme()
	codecs = serializer.NewCodecFactory(scheme, serializer.EnableStrict)
)

func init() {
	install.Install(scheme)
}

			warnings = append(warnings, getWarningsForIP(field.NewPath("spec").Child("clusterIPs").Index(i), clusterIP)...)
		}
	}

	for i, externalIP := range service.Spec.ExternalIPs {
		warnings = append(warnings, getWarningsForIP(field.NewPath("spec").Child("externalIPs").Index(i), externalIP)...)
	}

	if len(service.Spec.LoadBalancerIP) > 0 {

			}
			for _, extIP := range svcInfo.ExternalIPs() {
				err := ct.ClearEntriesForNAT(extIP.String(), endpointIP, v1.ProtocolUDP)
				if err != nil {
					klog.ErrorS(err, "Failed to delete endpoint connections for externalIP", "servicePortName", epSvcPair.ServicePortName, "externalIP", extIP)
				}
			}
			for _, lbIP := range svcInfo.LoadBalancerVIPs() {

		fail   bool
	}{{
		name:   "create: without externalIPs",
		newSvc: makeSvc(),
	}, {
		name:   "create: with externalIPs",
		newSvc: makeSvc("1.1.1.1"),
		fail:   true,
	}, {
		name:   "update: same externalIPs",
		newSvc: makeSvc("1.1.1.1", "2.2.2.2"),
		oldSvc: makeSvc("1.1.1.1", "2.2.2.2"),
	}, {
		name:   "update: reorder externalIPs",
		newSvc: makeSvc("1.1.1.1", "2.2.2.2"),
		oldSvc: makeSvc("2.2.2.2", "1.1.1.1"),

import (
	"testing"

	api "k8s.io/kubernetes/pkg/apis/core"
	internalapi "k8s.io/kubernetes/plugin/pkg/admission/podtolerationrestriction/apis/podtolerationrestriction"
)

func TestValidateConfiguration(t *testing.T) {

	tests := []struct {
		config     internalapi.Configuration
		testName   string
		testStatus bool
	}{{
		config: internalapi.Configuration{
			Default: []api.Toleration{

      nodePort: {{ .Values.service.nodePort }}
      {{- else }}
      targetPort: {{ .Values.minioAPIPort }}
      {{- end }}
  {{- if .Values.service.externalIPs }}
  externalIPs:
    {{- range $i , $ip := .Values.service.externalIPs }}
    - {{ $ip }}
    {{- end }}
  {{- end }}
  selector:
    app: {{ template "minio.name" . }}

    targetPort: 15012
  - name: tls-webhook
    port: 15017
    targetPort: 15017
{{- else }}
{{ .Values.service.ports | toYaml | indent 4 }}
{{- end }}
{{- if .Values.service.externalIPs }}
  externalIPs: {{- range .Values.service.externalIPs }}
    - {{.}}
  {{- end }}
{{- end }}
  selector:
    {{- include "gateway.selectorLabels" . | nindent 4 }}

		return nil
	}

	klog.V(4).Infof("Denying new use of ExternalIPs on Service %s/%s", newSvc.Namespace, newSvc.Name)
	return admission.NewForbidden(attr, fmt.Errorf("Use of external IPs is denied by admission control"))
}

func isSubset(newSvc, oldSvc *core.Service) bool {
	// If new has none, it's a subset.
	if len(newSvc.Spec.ExternalIPs) == 0 {
		return true
	}