@TaskAction public void publish() { final MavenPublicationInternal publication = getPublicationInternal(); if (publication == null) { throw new InvalidUserDataException("The 'publication' property is required"); } new PublishOperation(publication, "mavenLocal") { @Override protected void publish() throws Exception { MavenPublisher localPublisher = new MavenLocalPublisher(getLoggingManagerFactory(), getMavenRepositoryLocator()); MavenPublisher staticLockingPublisher = new StaticLockingMavenPublisher(localPublisher); MavenPublisher validatingPublisher = new ValidatingMavenPublisher(staticLockingPublisher); validatingPublisher.publish(publication.asNormalisedPublication(), null); } }.run(); }
@Mutate @SuppressWarnings("UnusedDeclaration") public void realizePublishingTasks(ModelMap<Task> tasks, PublishingExtension extension, @Path("buildDir") File buildDir) { // Create generatePom tasks for any Maven publication PublicationContainer publications = extension.getPublications(); Task publishLifecycleTask = tasks.get(PublishingPlugin.PUBLISH_LIFECYCLE_TASK_NAME); Task publishLocalLifecycleTask = tasks.get(PUBLISH_LOCAL_LIFECYCLE_TASK_NAME); for (final MavenPublicationInternal publication : publications.withType(MavenPublicationInternal.class)) { String publicationName = publication.getName(); createGeneratePomTask(tasks, publication, publicationName, buildDir); createLocalInstallTask(tasks, publishLocalLifecycleTask, publication, publicationName); createPublishTasksForEachMavenRepo(tasks, extension, publishLifecycleTask, publication, publicationName); } }
private void createPublishTasksForEachMavenRepo(ModelMap<Task> tasks, PublishingExtension extension, final Task publishLifecycleTask, final MavenPublicationInternal publication, final String publicationName) { for (final MavenArtifactRepository repository : extension.getRepositories().withType(MavenArtifactRepository.class)) { final String repositoryName = repository.getName(); String publishTaskName = "publish" + capitalize(publicationName) + "PublicationTo" + capitalize(repositoryName) + "Repository"; tasks.create(publishTaskName, PublishToMavenRepository.class, new Action<PublishToMavenRepository>() { public void execute(PublishToMavenRepository publishTask) { publishTask.setPublication(publication); publishTask.setRepository(repository); publishTask.setGroup(PublishingPlugin.PUBLISH_TASK_GROUP); publishTask.setDescription("Publishes Maven publication '" + publicationName + "' to Maven repository '" + repositoryName + "'."); } }); publishLifecycleTask.dependsOn(publishTaskName); } }
private void createPublishTasksForEachMavenRepo(CollectionBuilder<Task> tasks, PublishingExtension extension, final Task publishLifecycleTask, final MavenPublicationInternal publication, final String publicationName) { for (final MavenArtifactRepository repository : extension.getRepositories().withType(MavenArtifactRepository.class)) { final String repositoryName = repository.getName(); String publishTaskName = String.format("publish%sPublicationTo%sRepository", capitalize(publicationName), capitalize(repositoryName)); tasks.create(publishTaskName, PublishToMavenRepository.class, new Action<PublishToMavenRepository>() { public void execute(PublishToMavenRepository publishTask) { publishTask.setPublication(publication); publishTask.setRepository(repository); publishTask.setGroup(PublishingPlugin.PUBLISH_TASK_GROUP); publishTask.setDescription(String.format("Publishes Maven publication '%s' to Maven repository '%s'.", publicationName, repositoryName)); //Because dynamic rules are not yet implemented we have to violate input immutability here as an interim step publishLifecycleTask.dependsOn(publishTask); } }); } }
private void createGeneratePomTask(CollectionBuilder<Task> tasks, final MavenPublicationInternal publication, String publicationName) { String descriptorTaskName = String.format("generatePomFileFor%sPublication", capitalize(publicationName)); tasks.create(descriptorTaskName, GenerateMavenPom.class, new Action<GenerateMavenPom>() { public void execute(final GenerateMavenPom generatePomTask) { generatePomTask.setDescription(String.format("Generates the Maven POM file for publication '%s'.", publication.getName())); generatePomTask.setGroup(PublishingPlugin.PUBLISH_TASK_GROUP); generatePomTask.setPom(publication.getPom()); ConventionMapping descriptorTaskConventionMapping = new DslObject(generatePomTask).getConventionMapping(); descriptorTaskConventionMapping.map("destination", new Callable<Object>() { public Object call() throws Exception { return new File(generatePomTask.getProject().getBuildDir(), "publications/" + publication.getName() + "/pom-default.xml"); } }); // Wire the generated pom into the publication. publication.setPomFile(generatePomTask.getOutputs().getFiles()); } }); }
@Inject public PublishToMavenRepository(Factory<LoggingManagerInternal> loggingManagerFactory) { this.loggingManagerFactory = loggingManagerFactory; // Allow the publication to participate in incremental build getInputs().files(new Callable<FileCollection>() { public FileCollection call() throws Exception { MavenPublicationInternal publicationInternal = getPublicationInternal(); return publicationInternal == null ? null : publicationInternal.getPublishableFiles(); } }); // Should repositories be able to participate in incremental? // At the least, they may be able to express themselves as output files // They *might* have input files and other dependencies as well though // Inputs: The credentials they need may be expressed in a file // Dependencies: Can't think of a case here }
private void createGeneratePomTask(final MavenPublicationInternal publication, String publicationName) { String descriptorTaskName = String.format("generatePomFileFor%sPublication", capitalize(publicationName)); GenerateMavenPom generatePomTask = project.getTasks().create(descriptorTaskName, GenerateMavenPom.class); generatePomTask.setDescription(String.format("Generates the Maven POM file for publication '%s'.", publication.getName())); generatePomTask.setGroup(PublishingPlugin.PUBLISH_TASK_GROUP); generatePomTask.setPom(publication.getPom()); ConventionMapping descriptorTaskConventionMapping = new DslObject(generatePomTask).getConventionMapping(); descriptorTaskConventionMapping.map("destination", new Callable<Object>() { public Object call() throws Exception { return new File(project.getBuildDir(), "publications/" + publication.getName() + "/pom-default.xml"); } }); // Wire the generated pom into the publication. publication.setPomFile(generatePomTask.getOutputs().getFiles()); }
@TaskAction public void publish() { MavenPublicationInternal publicationInternal = getPublicationInternal(); if (publicationInternal == null) { throw new InvalidUserDataException("The 'publication' property is required"); } MavenArtifactRepository repository = getRepository(); if (repository == null) { throw new InvalidUserDataException("The 'repository' property is required"); } doPublish(publicationInternal, repository); }
private void doPublish(final MavenPublicationInternal publication, final MavenArtifactRepository repository) { new PublishOperation(publication, repository.getName()) { @Override protected void publish() throws Exception { MavenPublisher remotePublisher = new MavenRemotePublisher(getLoggingManagerFactory(), getMavenRepositoryLocator(), getTemporaryDirFactory(), getRepositoryTransportFactory()); MavenPublisher staticLockingPublisher = new StaticLockingMavenPublisher(remotePublisher); MavenPublisher validatingPublisher = new ValidatingMavenPublisher(staticLockingPublisher); validatingPublisher.publish(publication.asNormalisedPublication(), repository); } }.run(); }
public AbstractPublishToMaven() { // Allow the publication to participate in incremental build getInputs().files(new Callable<FileCollection>() { public FileCollection call() throws Exception { MavenPublicationInternal publicationInternal = getPublicationInternal(); return publicationInternal == null ? null : publicationInternal.getPublishableFiles(); } }).withPropertyName("publication.publishableFiles"); // Should repositories be able to participate in incremental? // At the least, they may be able to express themselves as output files // They *might* have input files and other dependencies as well though // Inputs: The credentials they need may be expressed in a file // Dependencies: Can't think of a case here }
private static MavenPublicationInternal toPublicationInternal(MavenPublication publication) { if (publication == null) { return null; } else if (publication instanceof MavenPublicationInternal) { return (MavenPublicationInternal) publication; } else { throw new InvalidUserDataException( String.format( "publication objects must implement the '%s' interface, implementation '%s' does not", MavenPublicationInternal.class.getName(), publication.getClass().getName() ) ); } }
private void createLocalInstallTask(ModelMap<Task> tasks, final Task publishLocalLifecycleTask, final MavenPublicationInternal publication, final String publicationName) { final String installTaskName = "publish" + capitalize(publicationName) + "PublicationToMavenLocal"; tasks.create(installTaskName, PublishToMavenLocal.class, new Action<PublishToMavenLocal>() { public void execute(PublishToMavenLocal publishLocalTask) { publishLocalTask.setPublication(publication); publishLocalTask.setGroup(PublishingPlugin.PUBLISH_TASK_GROUP); publishLocalTask.setDescription("Publishes Maven publication '" + publicationName + "' to the local Maven repository."); } }); publishLocalLifecycleTask.dependsOn(installTaskName); }
private void createGeneratePomTask(ModelMap<Task> tasks, final MavenPublicationInternal publication, final String publicationName, final File buildDir) { String descriptorTaskName = "generatePomFileFor" + capitalize(publicationName) + "Publication"; tasks.create(descriptorTaskName, GenerateMavenPom.class, new Action<GenerateMavenPom>() { public void execute(final GenerateMavenPom generatePomTask) { generatePomTask.setDescription("Generates the Maven POM file for publication '" + publicationName + "'."); generatePomTask.setGroup(PublishingPlugin.PUBLISH_TASK_GROUP); generatePomTask.setPom(publication.getPom()); generatePomTask.setDestination(new File(buildDir, "publications/" + publication.getName() + "/pom-default.xml")); } }); // Wire the generated pom into the publication. publication.setPomFile(tasks.get(descriptorTaskName).getOutputs().getFiles()); }
@Override protected void doPublish(final MavenPublicationInternal publication, final MavenArtifactRepository repository) { new PublishOperation(publication, repository) { @Override protected void publish() throws Exception { MavenPublisher antBackedPublisher = new AntTaskBackedMavenLocalPublisher(getLoggingManagerFactory(), getTemporaryDirFactory()); MavenPublisher staticLockingPublisher = new StaticLockingMavenPublisher(antBackedPublisher); MavenPublisher validatingPublisher = new ValidatingMavenPublisher(staticLockingPublisher); validatingPublisher.publish(publication.asNormalisedPublication(), repository); } }.run(); }
public PublishToMavenRepository() { // Allow the publication to participate in incremental build getInputs().files(new Callable<FileCollection>() { public FileCollection call() throws Exception { MavenPublicationInternal publicationInternal = getPublicationInternal(); return publicationInternal == null ? null : publicationInternal.getPublishableFiles(); } }); // Should repositories be able to participate in incremental? // At the least, they may be able to express themselves as output files // They *might* have input files and other dependencies as well though // Inputs: The credentials they need may be expressed in a file // Dependencies: Can't think of a case here }
protected void doPublish(final MavenPublicationInternal publication, final MavenArtifactRepository repository) { new PublishOperation(publication, repository) { @Override protected void publish() throws Exception { MavenPublisher antBackedPublisher = new AntTaskBackedMavenPublisher(getLoggingManagerFactory(), getTemporaryDirFactory()); MavenPublisher staticLockingPublisher = new StaticLockingMavenPublisher(antBackedPublisher); MavenPublisher validatingPublisher = new ValidatingMavenPublisher(staticLockingPublisher); validatingPublisher.publish(publication.asNormalisedPublication(), repository); } }.run(); }
@Mutate @SuppressWarnings("UnusedDeclaration") public void realizePublishingTasks(CollectionBuilder<Task> tasks, @Path("tasks.publish") Task publishLifecycleTask, @Path("tasks.publishToMavenLocal") Task publishLocalLifecycleTask, PublishingExtension extension) { // Create generatePom tasks for any Maven publication PublicationContainer publications = extension.getPublications(); for (final MavenPublicationInternal publication : publications.withType(MavenPublicationInternal.class)) { String publicationName = publication.getName(); createGeneratePomTask(tasks, publication, publicationName); createLocalInstallTask(tasks, publishLocalLifecycleTask, publication, publicationName); createPublishTasksForEachMavenRepo(tasks, extension, publishLifecycleTask, publication, publicationName); } }
private void createLocalInstallTask(CollectionBuilder<Task> tasks, final Task publishLocalLifecycleTask, final MavenPublicationInternal publication, final String publicationName) { final String installTaskName = String.format("publish%sPublicationToMavenLocal", capitalize(publicationName)); tasks.create(installTaskName, PublishToMavenLocal.class, new Action<PublishToMavenLocal>() { public void execute(PublishToMavenLocal publishLocalTask) { publishLocalTask.setPublication(publication); publishLocalTask.setGroup(PublishingPlugin.PUBLISH_TASK_GROUP); publishLocalTask.setDescription(String.format("Publishes Maven publication '%s' to the local Maven repository.", publicationName)); //Because dynamic rules are not yet implemented we have to violate input immutability here as an interim step publishLocalLifecycleTask.dependsOn(installTaskName); } }); }
protected void doPublish(final MavenPublicationInternal publication, final MavenArtifactRepository repository) { new PublishOperation(publication, repository) { @Override protected void publish() throws Exception { MavenPublisher antBackedPublisher = new AntTaskBackedMavenPublisher(loggingManagerFactory, getTemporaryDirFactory()); MavenPublisher staticLockingPublisher = new StaticLockingMavenPublisher(antBackedPublisher); MavenPublisher validatingPublisher = new ValidatingMavenPublisher(staticLockingPublisher); validatingPublisher.publish(publication.asNormalisedPublication(), repository); } }.run(); }
@SuppressWarnings("UnusedDeclaration") public void realizePublishingTasks(TaskContainer tasks, PublishingExtension extension) { // Create generatePom tasks for any Maven publication PublicationContainer publications = extension.getPublications(); for (final MavenPublicationInternal publication : publications.withType(MavenPublicationInternal.class)) { String publicationName = publication.getName(); createGeneratePomTask(publication, publicationName); createLocalInstallTask(tasks, publication, publicationName); createPublishTasksForEachMavenRepo(tasks, extension, publication, publicationName); } }
private void createPublishTasksForEachMavenRepo(TaskContainer tasks, PublishingExtension extension, MavenPublicationInternal publication, String publicationName) { for (MavenArtifactRepository repository : extension.getRepositories().withType(MavenArtifactRepository.class)) { String repositoryName = repository.getName(); String publishTaskName = String.format("publish%sPublicationTo%sRepository", capitalize(publicationName), capitalize(repositoryName)); PublishToMavenRepository publishTask = tasks.create(publishTaskName, PublishToMavenRepository.class); publishTask.setPublication(publication); publishTask.setRepository(repository); publishTask.setGroup(PublishingPlugin.PUBLISH_TASK_GROUP); publishTask.setDescription(String.format("Publishes Maven publication '%s' to Maven repository '%s'.", publicationName, repositoryName)); publishLifecycleTask.dependsOn(publishTask); } }
private void createLocalInstallTask(TaskContainer tasks, MavenPublicationInternal publication, String publicationName) { String installTaskName = String.format("publish%sPublicationToMavenLocal", capitalize(publicationName)); PublishToMavenLocal publishLocalTask = tasks.create(installTaskName, PublishToMavenLocal.class); publishLocalTask.setPublication(publication); publishLocalTask.setGroup(PublishingPlugin.PUBLISH_TASK_GROUP); publishLocalTask.setDescription(String.format("Publishes Maven publication '%s' to the local Maven repository.", publicationName)); publishLocalLifecycleTask.dependsOn(installTaskName); }
@Internal protected MavenPublicationInternal getPublicationInternal() { return toPublicationInternal(getPublication()); }
private void doPublish(final MavenPublicationInternal publication, final MavenArtifactRepository repository) { new PublishOperation(publication, repository.getName()) { @Override protected void publish() throws Exception { try { MavenPublisher remotePublisher = new MavenRemotePublisher( getLoggingManagerFactory(), getMavenRepositoryLocator(), getTemporaryDirFactory(), getRepositoryTransportFactory()); MavenPublisher staticLockingPublisher = new StaticLockingMavenPublisher( remotePublisher); MavenPublisher validatingPublisher = new ValidatingMavenPublisher( staticLockingPublisher); validatingPublisher.publish(publication.asNormalisedPublication(), repository); } catch (Throwable e) { String message = e.getMessage(); if (message.contains("Could not write to resource") && !publication.getVersion().endsWith("SNAPSHOT")) { throw new GradleException("Unable to deploy releaseThe release is packaged with the MTL platform",e); } if (message.contains("status code 400") && !publication.getVersion().endsWith("SNAPSHOT")) { throw new GradleException("Your release " + publication.getVersion() + " It already exists in the warehouse",e); } if (message.contains("status code 413")) { throw new GradleException("You post more than 200M, unable to upload",e); } throw e; } } }.run(); }
private MavenPublicationInternal getPublicationInternal() { return toPublicationInternal(getPublication()); }