"k8s.io/apiserver/pkg/admission/plugin/namespace/lifecycle"
	validatingadmissionpolicy "k8s.io/apiserver/pkg/admission/plugin/policy/validating"
	mutatingwebhook "k8s.io/apiserver/pkg/admission/plugin/webhook/mutating"
	validatingwebhook "k8s.io/apiserver/pkg/admission/plugin/webhook/validating"
)

// RegisterAllAdmissionPlugins registers all admission plugins
func RegisterAllAdmissionPlugins(plugins *admission.Plugins) {

var (
	_ pflag.Value = &IPVar{}
	_ pflag.Value = &IPPortVar{}
	_ pflag.Value = &PortRangeVar{}
	_ pflag.Value = &ReservedMemoryVar{}
	_ pflag.Value = &RegisterWithTaintsVar{}
)

// IPVar is used for validating a command line option that represents an IP. It implements the pflag.Value interface
type IPVar struct {
	Val *string
}

// Set sets the flag value
func (v *IPVar) Set(s string) error {
	if len(s) == 0 {

		in, out := &in.XMapType, &out.XMapType
		*out = new(string)
		**out = **in
	}

	if in.XValidations != nil {
		inValidations, outValidations := &in.XValidations, &out.XValidations
		*outValidations = make([]ValidationRule, len(*inValidations))
		for i := range *inValidations {
			in.XValidations[i].DeepCopyInto(&out.XValidations[i])
		}
	}

	return out

		expectResult           *metav1.Status
		expectErr              string
	}{
		// Allowed validating
		{
			name: "v1beta1 allowed validating",
			uid:  "123",
			review: &admissionv1beta1.AdmissionReview{
				Response: &admissionv1beta1.AdmissionResponse{Allowed: true},
			},
			expectAllowed: true,
		},
		{
			name: "v1 allowed validating",
			uid:  "123",
			review: &admissionv1.AdmissionReview{

apiVersion: release-notes/v2
kind: bug-fix
area: traffic-management
issue:
  - https://github.com/istio/istio/issues/48534

releaseNotes:
  - |

	if len(errs) != 0 {
		t.Errorf("Unexpected error validating %v", errs)
	}
	storageVersionWithoutName := &apiserverinternal.StorageVersion{
		ObjectMeta: metav1.ObjectMeta{Name: ""},
	}
	Strategy.PrepareForUpdate(ctx, storageVersionWithoutName, storageVersion)
	errs = Strategy.ValidateUpdate(ctx, storageVersionWithoutName, storageVersion)
	if len(errs) != 0 {
		t.Errorf("Unexpected error validating %v", errs)
	}
}

		return true, ""
	}
	// If some validating webhooks does not support dryRun(sideEffects=Unknown or Some), we will get this error.
	// We should assume valdiation is ready because there is no point in retrying this request.
	if strings.Contains(err.Error(), unsupportedDryRunMessageFragment) {

            return updateFunction.update(SnapshotHierarchy.NodeDiffListener.NOOP)
        }
    }

    def "does not store snapshot when invalidation happened in between"() {
        def location = '/my/location/new'
        when:
        start {
            vfs.store(location, { ->
                instant.snapshottingStarted

			}},

			SkipBenchmark: true,
			ExpectAllow:   true,
			ExpectAnnotations: map[string]string{
				"failed-open.validating.webhook.admission.k8s.io/round_0_index_0": "internalErr A",
				"failed-open.validating.webhook.admission.k8s.io/round_0_index_1": "internalErr B",
				"failed-open.validating.webhook.admission.k8s.io/round_0_index_2": "internalErr C",
			},
		},
		{

}

// ObserveWebhookFailOpen records validating or mutating webhook that fail open.
func (m *AdmissionMetrics) ObserveWebhookFailOpen(ctx context.Context, name, stepType string) {
	m.webhookFailOpen.WithContext(ctx).WithLabelValues(name, stepType).Inc()
}

// ObserveMatchConditionEvalError records validating or mutating webhook that are not called due to match conditions