Resources:   []string{"*"},
				},
			}},
			FailurePolicy: ptr.Of(admission.Ignore),
		}, {
			Name: "hook1",
			ClientConfig: admission.WebhookClientConfig{Service: &admission.ServiceReference{
				Namespace: namespace,
				Name:      istiod,
				Path:      &[]string{"/hook1"}[0],
			}},
			Rules: []admission.RuleWithOperations{{
				Operations: []admission.OperationType{admission.Create, admission.Update},

	if len(hooks) == 0 {
		fmt.Fprintf(writer, "No Istio injection hooks present.\n")
		return nil
	}

	w := new(tabwriter.Writer).Init(writer, 0, 8, 1, ' ', 0)
	fmt.Fprintln(w, "NAMESPACES\tINJECTOR-HOOK\tISTIO-REVISION\tSIDECAR-IMAGE")
	for _, hook := range hooks {

			// policy itself
			relevantHooks = append(relevantHooks, PolicyInvocation[P, B, E]{
				Policy:   hook.Policy,
				Error:    hook.ConfigurationError,
				Resource: matchGVR,
				Kind:     matchGVK,
			})
			utilruntime.HandleError(hook.ConfigurationError)
			continue
		}

		for _, binding := range hook.Bindings {
			bindingAccessor := d.newBindingAccessor(binding)

				},
			)

			hook, ok := invocation.Webhook.GetValidatingWebhook()
			if !ok {
				utilruntime.HandleError(fmt.Errorf("validating webhook dispatch requires v1.ValidatingWebhook, but got %T", hook))
				return
			}
			hookName = hook.Name
			ignoreClientCallFailures = hook.FailurePolicy != nil && *hook.FailurePolicy == v1.Ignore
			t := time.Now()

apply plugin: 'eclipse'

ext.hooks = []

eclipse {

  jdt {
    file {
      beforeMerged {
        hooks << 'beforeMerged'
      }
      whenMerged {
        hooks << 'whenMerged'
        assert '1.1' != it.targetCompatibility.toString()
        it.targetCompatibility = JavaVersion.toVersion('1.1')
      }
      withProperties {
        hooks << 'withProperties'

. The `beforeMerged` hook is executed with a domain object representing the existing file
. The existing content is merged with the configuration inferred from the Gradle build or defined explicitly in the eclipse DSL
. The `whenMerged` hook is executed with a domain object representing contents of the file to be persisted
. The `withXml` hook is executed with a raw representation of the XML that will be persisted

		objectInterfaces: o,
	}
	for i, hook := range hooks {
		attrForCheck := attr
		if v.versionedAttr != nil {
			attrForCheck = v.versionedAttr
		}

		invocation, statusErr := a.plugin.ShouldCallHook(ctx, hook, attrForCheck, o, v)
		if statusErr != nil {
			return statusErr
		}
		if invocation == nil {
			continue
		}

		hook, ok := invocation.Webhook.GetMutatingWebhook()
		if !ok {

 2. The `beforeMerged` hook is executed with a domain object representing the existing file
 3. The existing content is merged with the configuration inferred from the Gradle build or defined explicitly in the eclipse DSL
 4. The `whenMerged` hook is executed with a domain object representing contents of the file to be persisted
 5. The `withXml` hook is executed with a raw representation of the XML that will be persisted

				continue
			}
			if !matches {
				continue
			}

			params, err := generic.CollectParams(
				hook.Policy.Spec.ParamKind,
				hook.ParamInformer,
				hook.ParamScope,
				binding.Spec.ParamRef,
				a.GetNamespace(),
			)

			if err != nil {
				addConfigError(err, definition, binding)
				continue
			} else if versionedAttr == nil && len(params) > 0 {

    private final List<Thread> hooks = Lists.newArrayList();

    @Override
    synchronized void addShutdownHook(Thread hook) {
      hooks.add(hook);
    }

    synchronized void shutdown() throws InterruptedException {
      for (Thread hook : hooks) {
        hook.start();
      }
      for (Thread hook : hooks) {
        hook.join();
      }
    }
  }