github.com/jaylevin/jenkins-library@v1.230.4/cmd/gradleExecuteBuild.go (about)

     1  package cmd
     2  
     3  import (
     4  	"bytes"
     5  	"fmt"
     6  	"text/template"
     7  
     8  	"github.com/SAP/jenkins-library/pkg/command"
     9  	"github.com/SAP/jenkins-library/pkg/gradle"
    10  	"github.com/SAP/jenkins-library/pkg/log"
    11  	"github.com/SAP/jenkins-library/pkg/piperutils"
    12  	"github.com/SAP/jenkins-library/pkg/telemetry"
    13  )
    14  
    15  var (
    16  	bomGradleTaskName = "cyclonedxBom"
    17  	publishTaskName   = "publish"
    18  )
    19  
    20  const publishInitScriptContentTemplate = `
    21  rootProject {
    22      apply plugin: 'maven-publish'
    23      apply plugin: 'java'
    24  
    25      publishing {
    26          publications {
    27              maven(MavenPublication) {
    28                  versionMapping {
    29                      usage('java-api') {
    30                          fromResolutionOf('runtimeClasspath')
    31                      }
    32                      usage('java-runtime') {
    33                          fromResolutionResult()
    34                      }
    35                  }
    36  				{{- if .ArtifactGroupID}}
    37  				groupId = '{{.ArtifactGroupID}}'
    38  				{{- end }}
    39  				{{- if .ArtifactID}}
    40  				artifactId = '{{.ArtifactID}}'
    41  				{{- end }}
    42  				{{- if .ArtifactVersion}}
    43  				version = '{{.ArtifactVersion}}'
    44  				{{- end }}
    45                  from components.java
    46              }
    47          }
    48          repositories {
    49              maven {
    50                  credentials {
    51                      username = "{{.RepositoryUsername}}"
    52                      password = "{{.RepositoryPassword}}"
    53                  }
    54                  url = "{{.RepositoryURL}}"
    55              }
    56          }
    57      }
    58  }
    59  `
    60  
    61  const bomInitScriptContent = `
    62  initscript {
    63    repositories {
    64      mavenCentral()
    65      maven {
    66        url "https://plugins.gradle.org/m2/"
    67      }
    68    }
    69    dependencies {
    70      classpath "com.cyclonedx:cyclonedx-gradle-plugin:1.5.0"
    71    }
    72  }
    73  
    74  rootProject {
    75      apply plugin: 'java'
    76      apply plugin: 'maven'
    77      apply plugin: org.cyclonedx.gradle.CycloneDxPlugin
    78  }
    79  `
    80  
    81  type gradleExecuteBuildUtils interface {
    82  	command.ExecRunner
    83  	piperutils.FileUtils
    84  }
    85  
    86  type gradleExecuteBuildUtilsBundle struct {
    87  	*command.Command
    88  	*piperutils.Files
    89  }
    90  
    91  func newGradleExecuteBuildUtils() gradleExecuteBuildUtils {
    92  	utils := gradleExecuteBuildUtilsBundle{
    93  		Command: &command.Command{},
    94  		Files:   &piperutils.Files{},
    95  	}
    96  	utils.Stdout(log.Writer())
    97  	utils.Stderr(log.Writer())
    98  	return &utils
    99  }
   100  
   101  func gradleExecuteBuild(config gradleExecuteBuildOptions, telemetryData *telemetry.CustomData) {
   102  	utils := newGradleExecuteBuildUtils()
   103  	err := runGradleExecuteBuild(&config, telemetryData, utils)
   104  	if err != nil {
   105  		log.Entry().WithError(err).Fatalf("step execution failed: %v", err)
   106  	}
   107  }
   108  
   109  func runGradleExecuteBuild(config *gradleExecuteBuildOptions, telemetryData *telemetry.CustomData, utils gradleExecuteBuildUtils) error {
   110  	log.Entry().Info("BOM file creation...")
   111  	if config.CreateBOM {
   112  		if err := createBOM(config, utils); err != nil {
   113  			return err
   114  		}
   115  	}
   116  
   117  	// gradle build
   118  	gradleOptions := &gradle.ExecuteOptions{
   119  		BuildGradlePath: config.Path,
   120  		Task:            config.Task,
   121  		UseWrapper:      config.UseWrapper,
   122  	}
   123  	if _, err := gradle.Execute(gradleOptions, utils); err != nil {
   124  		log.Entry().WithError(err).Errorf("gradle build execution was failed: %v", err)
   125  		return err
   126  	}
   127  
   128  	log.Entry().Info("Publishing of artifacts to staging repository...")
   129  	if config.Publish {
   130  		if err := publishArtifacts(config, utils); err != nil {
   131  			return err
   132  		}
   133  	}
   134  
   135  	return nil
   136  }
   137  
   138  func createBOM(config *gradleExecuteBuildOptions, utils gradleExecuteBuildUtils) error {
   139  	gradleOptions := &gradle.ExecuteOptions{
   140  		BuildGradlePath:   config.Path,
   141  		Task:              bomGradleTaskName,
   142  		UseWrapper:        config.UseWrapper,
   143  		InitScriptContent: bomInitScriptContent,
   144  	}
   145  	if _, err := gradle.Execute(gradleOptions, utils); err != nil {
   146  		log.Entry().WithError(err).Errorf("failed to create BOM: %v", err)
   147  		return err
   148  	}
   149  	return nil
   150  }
   151  
   152  func publishArtifacts(config *gradleExecuteBuildOptions, utils gradleExecuteBuildUtils) error {
   153  	publishInitScriptContent, err := getPublishInitScriptContent(config)
   154  	if err != nil {
   155  		return fmt.Errorf("failed to get publish init script content: %v", err)
   156  	}
   157  	gradleOptions := &gradle.ExecuteOptions{
   158  		BuildGradlePath:   config.Path,
   159  		Task:              publishTaskName,
   160  		UseWrapper:        config.UseWrapper,
   161  		InitScriptContent: publishInitScriptContent,
   162  	}
   163  	if _, err := gradle.Execute(gradleOptions, utils); err != nil {
   164  		log.Entry().WithError(err).Errorf("failed to publish artifacts: %v", err)
   165  		return err
   166  	}
   167  	return nil
   168  }
   169  
   170  func getPublishInitScriptContent(options *gradleExecuteBuildOptions) (string, error) {
   171  	tmpl, err := template.New("resources").Parse(publishInitScriptContentTemplate)
   172  	if err != nil {
   173  		return "", err
   174  	}
   175  
   176  	var generatedCode bytes.Buffer
   177  	err = tmpl.Execute(&generatedCode, options)
   178  	if err != nil {
   179  		return "", err
   180  	}
   181  
   182  	return string(generatedCode.Bytes()), nil
   183  }