"Metric expiry graceful deletion interval. No-op if METRIC_ROTATION_INTERVAL is disabled.").Get()

	EnableControllerQueueMetrics = env.Register("ISTIO_ENABLE_CONTROLLER_QUEUE_METRICS", false,
		"If enabled, publishes metrics for queue depth, latency and processing times.").Get()

         */
        public String getVersion() {
            return snapshotMetadata.getVersioning().getSnapshotVersions().get(0).getVersion();
        }
    }

    /**
     * Publishes artifacts for a single Maven module.
     */
    private static class ModuleArtifactPublisher {
        private final NetworkOperationBackOffAndRetry<Void> networkOperationCaller = new NetworkOperationBackOffAndRetry<>();

        repositories.all(repository -> tasks.register(publishAllToSingleRepoTaskName(repository), publish -> {
            publish.setDescription("Publishes all Ivy publications produced by this project to the " + repository.getName() + " repository.");
            publish.setGroup(PublishingPlugin.PUBLISH_TASK_GROUP);
        }));

        publications.all(publication -> {

@RequiredFeature(feature = GradleMetadataResolveRunner.REPOSITORY_TYPE, value="maven")
class NativeAlignmentWithJavaPlatformResolveIntegrationTest extends AbstractModuleDependencyResolveTest {
    def "publishes a platform with native alignment"() {
        settingsFile << """
            rootProject.name = 'root'
            include "platform"
            include "core"
            include "lib"
        """

        project.getTasks().register(PUBLISH_LIFECYCLE_TASK_NAME, task -> {
            task.setDescription("Publishes all publications produced by this project.");
            task.setGroup(PUBLISH_TASK_GROUP);
        });
        extension.getPublications().all(publication -> {

     *
     * To react to changes in Kotlin sources, [KaResolveExtension] may subscribe to Analysis API modification topics:
     * `KotlinModificationTopics`. If the [KaResolveExtension] both subscribes to and publishes modification events, care needs to be taken
     * that no cycles are introduced. In general, the [KaResolveExtension] should never publish an event for a module A in a listener for
     * the same module A.
     *

        fixConflict | description
        false       | 'conflict fix not applied'
        true        | 'conflict fix applied'
    }

    /**
     * This use case corresponds to the case where a library maintainer publishes a library
     * either as individual modules, or using a fatjar. It's illegal to have both the fat jar and
     * individual modules on the classpath, so we need a way to declare that we prefer to use
     * the fat jar.

import org.gradle.work.DisableCachingByDefault;

import javax.inject.Inject;
import java.net.URI;
import java.util.Collection;

import static org.gradle.internal.serialization.Transient.varOf;

/**
 * Publishes a {@link org.gradle.api.publish.maven.MavenPublication} to a {@link MavenArtifactRepository}.
 *
 * @since 1.4
 */
@DisableCachingByDefault(because = "Not worth caching")

        and:
        module.assertPublished()
        module.assertArtifactsPublished "${artifactId}-${version}.rpm", "ivy-${version}.xml"
    }

    @UsesSample("ivy-publish/distribution")
    def "publishes distribution archives with #dsl dsl"() {
        given:
        def sampleDir = sampleProject.dir.file(dsl)
        executer.inDirectory(sampleDir)

        and:
        def repo = ivy(sampleDir.file("build/repo"))

                ${signingConfiguration()}
                sign publishing.publications.maven
            }
        """

        then:
        succeeds "signMavenPublication"
    }

    def "publishes signature files for Maven publication"() {
        given:
        buildFile << """
            apply plugin: 'maven-publish'
            ${keyInfo.addAsPropertiesScript()}

            task sourceJar(type: Jar) {