boolean force = PlatformSupport.hasForcedDependencies(variant);
        List<? extends ModuleDependencyMetadata> dependencies = variantMetadataRules.applyDependencyMetadataRules(variant, convertDependencies(variant.getDependencies(), variant.getDependencyConstraints(), force));

	EnableClusterSpecific bool

	// Set is a string with element format "path=value" where path is an IstioOperator path and the value is a
	// value to set the node at that path to.
	Set []string
	// Force proceeds even if there are validation errors
	Force bool
	// ManifestsPath is a path to a charts and profiles directory in the local filesystem with a release tgz.
	ManifestsPath string
	// Revision is the Istio control plane revision the command targets.

     *
     * @return a new descriptor, equivalent to force
     */
    ComponentSelectionDescriptorInternal markAsEquivalentToForce();

    /**
     * Indicates whether the component selection descriptor is equivalent to a forced dependency
     *
     * @return {@code true} if equivalent to force, {@code false} otherwise
     */
    boolean isEquivalentToForce();

}

type serverArgs struct {
	// force proceeds even if there are validation errors
	force bool
	// maxConcurrentReconciles defines the concurrency limit for operator to reconcile IstioOperatorSpec in parallel
	maxConcurrentReconciles int

	monitoring monitoringArgs
}

func addServerFlags(cmd *cobra.Command, args *serverArgs) {
	cmd.PersistentFlags().BoolVar(&args.force, "force", false, root.ForceFlagHelpStr)

import org.gradle.api.attributes.Attribute;
import org.gradle.api.attributes.AttributeContainer;

import java.util.Map;

/**
 * Common base class for {@link AttributeContainerInternal} which enforces implementation of
 * {@link #hashCode} and {@link #equals}.
 */
public abstract class AbstractAttributeContainer implements AttributeContainerInternal {

    @Override
    public Map<Attribute<?>, ?> asMap() {

    protected
    fun <T : Any> assertDeferredEvaluationOf(deferred: T, force: T.() -> Any?) {
        Runtime.value = "before"
        val value = configurationCacheRoundtripOf(deferred)

        Runtime.value = "after"
        assertThat(
            force(value),
            equalTo("after")
        )
    }

    protected

	// wait between successive executions. Is set to 60 sec by default.
	ReconcilerSyncLoopPeriod metav1.Duration
	// DisableForceDetachOnTimeout disables force detach when the maximum unmount
	// time is exceeded. Is false by default, and thus force detach on unmount is
	// enabled.
	DisableForceDetachOnTimeout bool

            throws TransferFailedException, ResourceDoesNotExistException;

    void getArtifact(
            Artifact artifact,
            List<ArtifactRepository> remoteRepositories,
            TransferListener transferListener,
            boolean force)
            throws TransferFailedException, ResourceDoesNotExistException;

	s.rejectCSR = reject
	s.faultInjectLock.Unlock()
	if reject {
		caServerLog.Info("force CA server to return error to CSR")
	}
}

func (s *CAServer) shouldReject() bool {
	var reject bool
	s.faultInjectLock.Lock()
	reject = s.rejectCSR
	s.faultInjectLock.Unlock()
	return reject
}

// SendEmptyCert force CA server send empty cert chain.
func (s *CAServer) SendEmptyCert() {
	s.faultInjectLock.Lock()

	fs.BoolVar(&o.DisableForceDetachOnTimeout, "disable-force-detach-on-timeout", false, "Prevent force detaching volumes based on maximum unmount time and node status. If this flag is set to true, the non-graceful node shutdown feature must be used to recover from node failure. See https://k8s.io/docs/storage-disable-force-detach-on-timeout/.")
}

// ApplyTo fills up AttachDetachController config with options.