-
Notifications
You must be signed in to change notification settings - Fork 0
/
gradlew.go
127 lines (112 loc) · 3.01 KB
/
gradlew.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
package service
import (
"fmt"
"os"
"regexp"
"strings"
"github.com/iantal/dta/internal/domain"
"github.com/iantal/dta/internal/utils"
"github.com/sirupsen/logrus"
)
// Gradlew handles execution of various gradlew comands
type Gradlew struct {
log *utils.StandardLogger
projectRoot string
}
// NewGradlew created a new Gradlew
func NewGradlew(l *utils.StandardLogger, destPath string) *Gradlew {
return &Gradlew{l, destPath}
}
// Projects parses the output of `gradlew projects`
func (g *Gradlew) Projects() ([]string, error) {
if !g.hasGradlew() {
return nil, fmt.Errorf("Could not execute gradlew")
}
g.log.Info("Started parsing projects")
err, stdout, stderr := utils.CMD("/bin/sh", "gradlew", "projects")
if err != nil {
return nil, fmt.Errorf("Error executing [gradlew projects] command for %s", g.projectRoot)
}
if isFailedCommand(stdout) || len(stderr) != 0 {
return nil, fmt.Errorf("Received build failure for [gradlew projects] for %s", g.projectRoot)
}
return extractProjects(stdout), nil
}
func isFailedCommand(stdout []string) bool {
for _, line := range stdout {
if strings.Contains(line, "BUILD SUCCESSFUL") {
return false
}
}
return true
}
func extractProjects(data []string) []string {
var res []string
for _, out := range data {
p := extractProject(out)
if p != "" {
res = append(res, p)
}
}
return res
}
func extractProject(line string) string {
var re = regexp.MustCompile(`(?m).*Project\s+':(?P<project>.*)'`)
result := make(map[string]string)
match := re.FindStringSubmatch(line)
if match == nil {
return ""
}
for i, name := range re.SubexpNames() {
if i != 0 && name != "" {
result[name] = match[i]
}
}
return result["project"]
}
// Dependencies parses the output of `gradlew [proj]:dependencies`
func (g *Gradlew) Dependencies(p *domain.Project, project string, isSubproject bool) string {
g.log.WithFields(logrus.Fields{
"projectID": p.ProjectID,
"commit": p.CommitHash,
}).Info("Generating dependency tree", "project", project)
if !isSubproject {
err, stdout, serr := utils.CMD("/bin/sh", "gradlew", "dependencies")
if err != nil {
g.log.Info("Root dep error " + strings.Join(serr, "\n"))
g.log.WithFields(logrus.Fields{
"projectName": project,
"error": strings.Join(serr, "\n"),
}).Error("Error executing [gradlew dependencies]")
return ""
}
return strings.Join(stdout, "\n")
}
c := project + ":dependencies"
err, stdout, serr := utils.CMD("/bin/sh", "gradlew", c)
if err != nil {
g.log.WithFields(logrus.Fields{
"projectName": project,
"error": strings.Join(serr, "\n"),
}).Error("Error executing [gradlew project:dependencies]")
return ""
}
return strings.Join(stdout, "\n")
}
func (g *Gradlew) hasGradlew() bool {
os.Chdir(g.projectRoot)
err, stdout, _ := utils.CMD("ls")
if err != nil {
g.log.WithFields(logrus.Fields{
"error": err,
"path": g.projectRoot,
}).Error("gradlew command not found")
return false
}
for _, out := range stdout {
if out == "gradlew" {
return true
}
}
return false
}