Publishing metadata for artifact defined in custom plugin

tudortimi · March 2, 2024, 9:51pm

I’m developing a plugin for a programming language that I use. I’d like to be able to publish metadata together with artifacts (e.g. what RedHat release, what version of the compiler, etc.). I was reading up on the topic in the user guide: Publishing a project as module

It seems that I need a “component”, which would describe the variant that’s being produced and use the metadata from that. I can’t find a way to create an object of type SoftwareComponent. I tried the following:

def sv = project.objects.newInstance(SoftwareComponent, "sv")
components.add(sv)

I get:

class org.gradle.api.component.SoftwareComponent_Decorated cannot be cast to class org.gradle.api.internal.component.SoftwareComponentInternal (org.gradle.api.component.SoftwareComponent_Decorated and org.gradle.api.internal.component.SoftwareComponentInternal are in unnamed module of loader org.gradle.internal.classloader.VisitableURLClassLoader @5eb5c224)

I have the feeling that there’s no public API for doing what I want. I can also be on the completely wrong track. How would I go about implementing metadata for artifacts in a custom plugin?

tudortimi · March 3, 2024, 9:42am

First, I noticed that I’m running a pretty old Gradle version (7.4.2), so stuff might have changed in the implementation. I’m switching to Gradle 8.6 to see whether this got fixed.

tudortimi · March 3, 2024, 10:57am

Still the same even after upgrading to Gradle 8.6. I had a look at how the native plugins register components. I haven’t found SoftwareComponentInternal anywhere in the type hierarchy. For example, a C++ library:

github.com

gradle/gradle/blob/423f1299e2bf615666a0165bd2e12b87b76a0f1e/platforms/native/language-native/src/main/java/org/gradle/language/cpp/internal/DefaultCppLibrary.java#L49


      
          import org.gradle.language.cpp.CppPlatform;
          import org.gradle.language.internal.DefaultLibraryDependencies;
          import org.gradle.language.nativeplatform.internal.PublicationAwareComponent;
          import org.gradle.nativeplatform.Linkage;
          import org.gradle.nativeplatform.toolchain.internal.NativeToolChainInternal;
          import org.gradle.nativeplatform.toolchain.internal.PlatformToolProvider;
          
          import javax.inject.Inject;
          import java.util.Collections;
          
          public class DefaultCppLibrary extends DefaultCppComponent implements CppLibrary, PublicationAwareComponent {
              private final ObjectFactory objectFactory;
              private final ConfigurableFileCollection publicHeaders;
              private final FileCollection publicHeadersWithConvention;
              private final SetProperty<Linkage> linkage;
              private final Property<CppBinary> developmentBinary;
              private final Configuration apiElements;
              private final MainLibraryVariant mainVariant;
              private final DefaultLibraryDependencies dependencies;
          
              @Inject

github.com

gradle/gradle/blob/master/platforms/native/language-native/src/main/java/org/gradle/language/cpp/internal/DefaultCppComponent.java#L40


      
          import org.gradle.language.internal.DefaultBinaryCollection;
          import org.gradle.language.nativeplatform.internal.ComponentWithNames;
          import org.gradle.language.nativeplatform.internal.DefaultNativeComponent;
          import org.gradle.language.nativeplatform.internal.Names;
          import org.gradle.nativeplatform.TargetMachine;
          
          import javax.inject.Inject;
          import java.util.Arrays;
          import java.util.concurrent.Callable;
          
          public abstract class DefaultCppComponent extends DefaultNativeComponent implements CppComponent, ComponentWithNames {
              private final FileCollection cppSource;
              private final String name;
              private final ConfigurableFileCollection privateHeaders;
              private final FileCollection privateHeadersWithConvention;
              private final Property<String> baseName;
              private final Names names;
              private final DefaultBinaryCollection<CppBinary> binaries;
              private final SetProperty<TargetMachine> targetMachines;
          
              @Inject

github.com

gradle/gradle/blob/master/platforms/native/language-native/src/main/java/org/gradle/language/nativeplatform/internal/DefaultNativeComponent.java#L32


      
          import org.gradle.api.file.FileTree;
          import org.gradle.api.file.ProjectLayout;
          import org.gradle.api.model.ObjectFactory;
          import org.gradle.api.tasks.util.PatternSet;
          import org.gradle.internal.DisplayName;
          
          import javax.inject.Inject;
          import java.util.List;
          import java.util.concurrent.Callable;
          
          public abstract class DefaultNativeComponent {
              private final ConfigurableFileCollection source;
          
              public DefaultNativeComponent(ObjectFactory objectFactory) {
                  // TODO - introduce a new 'var' data structure that allows these conventions to be configured explicitly
                  source = objectFactory.fileCollection();
              }
          
              public abstract DisplayName getDisplayName();
          
              @Override

Then, this is how it gets created:

github.com

gradle/gradle/blob/423f1299e2bf615666a0165bd2e12b87b76a0f1e/platforms/native/language-native/src/main/java/org/gradle/language/cpp/plugins/CppLibraryPlugin.java#L92


      
          
          @Override
          public void apply(final Project project) {
              project.getPluginManager().apply(CppBasePlugin.class);
          
              final TaskContainer tasks = project.getTasks();
              final ObjectFactory objectFactory = project.getObjects();
              final ProviderFactory providers = project.getProviders();
          
              // Add the library and extension
              final DefaultCppLibrary library = componentFactory.newInstance(CppLibrary.class, DefaultCppLibrary.class, "main");
              project.getExtensions().add(CppLibrary.class, "library", library);
              project.getComponents().add(library);
          
              // Configure the component
              library.getBaseName().convention(project.getName());
              library.getTargetMachines().convention(useHostAsDefaultTargetMachine(targetMachineFactory));
              library.getDevelopmentBinary().convention(project.provider(new Callable<CppBinary>() {
                  @Override
                  public CppBinary call() throws Exception {
                      return getDebugSharedHostStream().findFirst().orElseGet(

The native component factory is:

github.com

gradle/gradle/blob/423f1299e2bf615666a0165bd2e12b87b76a0f1e/platforms/native/language-native/src/main/java/org/gradle/language/internal/DefaultNativeComponentFactory.java#L22


      
          * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
          * See the License for the specific language governing permissions and
          * limitations under the License.
          */
          
          package org.gradle.language.internal;
          
          import org.gradle.api.component.SoftwareComponent;
          import org.gradle.api.model.ObjectFactory;
          
          public class DefaultNativeComponentFactory implements NativeComponentFactory {
             private final ObjectFactory objectFactory;
          
             public DefaultNativeComponentFactory(ObjectFactory objectFactory) {
                 this.objectFactory = objectFactory;
             }
          
             @Override
             public <P extends SoftwareComponent, I extends P> I newInstance(Class<P> publicType, Class<I> implementationType, String name) {
                 return objectFactory.newInstance(implementationType, name);
             }

I don’t see SoftwareComponentInternal anywhere.

tudortimi · March 3, 2024, 1:42pm

I had a deeper look and it seems that this comes from somewhere in the code for Maven publishing. Not all components that are added to the project are used for publishing. For a C++ library, sub-components get defined, which are used for the publishing. The objects are of this type, which does implement SoftwareComponentInternal:

github.com

gradle/gradle/blob/423f1299e2bf615666a0165bd2e12b87b76a0f1e/platforms/native/language-native/src/main/java/org/gradle/language/cpp/internal/MainLibraryVariant.java#L34


      
          import org.gradle.api.component.ComponentWithVariants;
          import org.gradle.api.component.SoftwareComponent;
          import org.gradle.api.internal.component.SoftwareComponentInternal;
          import org.gradle.api.internal.component.UsageContext;
          import org.gradle.api.model.ObjectFactory;
          import org.gradle.api.publish.internal.component.ConfigurationSoftwareComponentVariant;
          
          import java.util.LinkedHashSet;
          import java.util.Set;
          
          public class MainLibraryVariant implements ComponentWithVariants, SoftwareComponentInternal {
              private final String name;
              private final Set<PublishArtifact> artifacts = new LinkedHashSet<PublishArtifact>();
              private final Configuration dependencies;
              private final DomainObjectSet<SoftwareComponent> variants;
              private final AttributeContainer attributeContainer;
          
              public MainLibraryVariant(String name, Configuration dependencies, AttributeContainer attributeContainer, ObjectFactory objectFactory) {
                  this.name = name;
                  this.dependencies = dependencies;
                  this.attributeContainer = attributeContainer;

This is probably the line that causes the cast error:

github.com

gradle/gradle/blob/423f1299e2bf615666a0165bd2e12b87b76a0f1e/platforms/software/maven/src/main/java/org/gradle/api/publish/maven/internal/publication/DefaultMavenPublication.java#L250


      
          @Override
          public void setAlias(boolean alias) {
              this.alias = alias;
          }
          
          @Override
          public void from(SoftwareComponent component) {
              if (getComponent().isPresent()) {
                  throw new InvalidUserDataException(String.format("Maven publication '%s' cannot include multiple components", name));
              }
              getComponent().set((SoftwareComponentInternal) component);
              getComponent().finalizeValue();
              artifactsOverridden = false;
          
              updateModuleDescriptorArtifact();
          }
          
          // TODO: This method should be removed in favor of lazily adding artifacts to the publication state.
          // This is currently blocked by Signing eagerly realizing the publication artifacts.
          private void populateFromComponent() {
              if (populated) {

To interface with the Maven publishing plugin, implementing this interface seems to be required.

Vampire · March 3, 2024, 10:14pm

To create a custom component for publishing, you should use the respective factory as documented at: Customizing publishing

But if what you build is da normal Java artifact to which you just want to add a metadata file to the plublication, you probably just publish the java component as usual and define your additional artifact as variant like the source jar or the javadoc jar are added.

tudortimi · March 3, 2024, 11:10pm

I must have read through those pages a couple of times while trying to wrap my head around the concepts, but somehow I missed the SoftwareComponentFactory. I started implementing internal APIs and managed to get it working, but wasn’t 100% happy. I’ll give the approach on that page a try, thanks!

tudortimi · March 5, 2024, 10:52pm

Worked like a charm!

Topic		Replies	Views
[Feedback needed] Gradle Module Metadata Help/Discuss	16	4345	March 26, 2021
Custom software component publishing Help/Discuss	0	295	April 1, 2019
Adding artifact to web component Help/Discuss	0	294	March 26, 2020
Gradle Module Metadata for Non-Java Projects Help/Discuss	2	1365	November 13, 2019
What is "components.java" Help/Discuss	2	17027	June 6, 2019

Related topics