actions := client.Actions()
				numExtraActions := len(actions) - numInitialActions
				if numExtraActions != tc.expectedNumActions {
					t.Logf("Expected %d additional client actions, got %d: %#v. Will retry", tc.expectedNumActions, numExtraActions, actions[numInitialActions:])
					return false, nil
				}
				return true, nil
			})

        try {
            final SearchEngineClient esClient = ComponentUtil.getSearchEngineClient();
            final ClusterHealthResponse response =
                    esClient.admin().cluster().prepareHealth().execute().actionGet(fessConfig.getIndexHealthTimeout());
            engineObj.clusterName = response.getClusterName();
            engineObj.numberOfNodes = response.getNumberOfNodes();

        }
    }

    /**
     * A file copy action that collects plugin descriptors as they are added to the jar.
     */
    static class PluginDescriptorCollectorAction implements Action<FileCopyDetails> {
        private final PluginValidationActionsState actionsState;

                }
            }
        }
    }

    def "applies withXml actions"() {
        when:
        descriptor.withXml(new Action<XmlProvider>() {
            void execute(XmlProvider t) {
                t.asNode().info[0].@revision = "3"
            }
        })
        descriptor.withXml(new Action<XmlProvider>() {
            void execute(XmlProvider t) {

// WithAction returns a Shell identical to sh, but bound to Action a.
func (sh *Shell) WithAction(a *Action) *Shell {
	sh2 := *sh
	sh2.action = a
	return &sh2
}

// Shell returns a shell for running commands on behalf of Action a.
func (b *Builder) Shell(a *Action) *Shell {
	if a == nil {
		// The root shell has a nil Action. The point of this method is to
		// create a Shell bound to an Action, so disallow nil Actions here.
		panic("nil Action")

====
include::sample[dir="snippets/buildCache/conditional-action/kotlin",files="build.gradle.kts[tags=conditionalAction]"]
include::sample[dir="snippets/buildCache/conditional-action/groovy",files="build.gradle[tags=conditionalAction]"]
====

You should always add the action unconditionally:

====

        outputContains("printing from action")

        when:
        buildFile << """
            tasks.register('other')
        """
        run ':myTask', '--info'
        then:
        executedAndNotSkipped(':myTask')
        outputContains("printing from action")
        outputContains("One or more additional actions for task ':myTask' have changed.")

        when:

                    }
                }).rethrow();
            } finally {
                // Replace the entire container, rather than clear it, to discard all the service instances and because it may contain configuration actions and
                // other state that can affect the service instances when they are registered again
                this.registrations = uncheckedCast(collectionFactory.newNamedDomainObjectSet(BuildServiceRegistration.class));

[[sec:implementing-artifact-transforms]]
== Implementing artifact transforms

Similar to task types, an artifact transform consists of an action and some parameters.
The major difference to custom task types is that the action and the parameters are implemented as two separate classes.

The implementation of the artifact transform action is a class implementing link:{groovyDslPath}/org.gradle.api.artifacts.transform.TransformAction.html[TransformAction].

				actions := sets.NewString()
				for _, operation := range []*spec.Operation{path.Get, path.Post, path.Put, path.Patch, path.Delete} {
					if operation != nil {
						action, ok := operation.VendorExtensible.Extensions.GetString(endpoints.RouteMetaAction)
						if ok {
							actions.Insert(action)
						}
						if action == "patch" {