-
Notifications
You must be signed in to change notification settings - Fork 785
/
resolvers.go
102 lines (91 loc) · 2.72 KB
/
resolvers.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
package gitresolver
import (
"fmt"
"github.com/jenkins-x/jx/pkg/gits"
"github.com/jenkins-x/jx/pkg/jenkinsfile"
"github.com/jenkins-x/jx/pkg/util"
"gopkg.in/yaml.v2"
"io/ioutil"
"path/filepath"
)
// CreateResolver creates a new module resolver
func CreateResolver(packsDir string, gitter gits.Gitter) (jenkinsfile.ImportFileResolver, error) {
modules, err := LoadModules(packsDir)
if err != nil {
return nil, err
}
moduleResolver, err := ResolveModules(modules, gitter)
if err != nil {
return nil, err
}
return moduleResolver.AsImportResolver(), nil
}
// Resolve resolves this module to a directory
func Resolve(m *jenkinsfile.Module, gitter gits.Gitter) (*ModuleResolver, error) {
err := m.Validate()
if err != nil {
return nil, err
}
dir, err := InitBuildPack(gitter, m.GitURL, m.GitRef)
if err != nil {
return nil, err
}
answer := &ModuleResolver{
Module: m,
PacksDir: dir,
}
return answer, nil
}
// ModulesResolver resolves a number of modules into a structure we can use to resolve imports
type ModulesResolver struct {
Modules map[string]*ModuleResolver
}
// ModuleResolver a resolver for a single module
type ModuleResolver struct {
Module *jenkinsfile.Module
PacksDir string
}
// LoadModules loads the modules in the given build pack directory if there are any
func LoadModules(dir string) (*jenkinsfile.Modules, error) {
fileName := filepath.Join(dir, jenkinsfile.ModuleFileName)
config := jenkinsfile.Modules{}
exists, err := util.FileExists(fileName)
if err != nil || !exists {
return &config, err
}
data, err := ioutil.ReadFile(fileName)
if err != nil {
return &config, fmt.Errorf("Failed to load file %s due to %s", fileName, err)
}
err = yaml.Unmarshal(data, &config)
if err != nil {
return &config, fmt.Errorf("Failed to unmarshal YAML file %s due to %s", fileName, err)
}
return &config, err
}
// ResolveModules Resolve the modules into a module resolver
func ResolveModules(m *jenkinsfile.Modules, gitter gits.Gitter) (*ModulesResolver, error) {
answer := &ModulesResolver{
Modules: map[string]*ModuleResolver{},
}
for _, mod := range m.Modules {
resolver, err := Resolve(mod, gitter)
if err != nil {
return answer, err
}
answer.Modules[mod.Name] = resolver
}
return answer, nil
}
// AsImportResolver returns an ImportFileResolver for these modules
func (m *ModulesResolver) AsImportResolver() jenkinsfile.ImportFileResolver {
return m.ResolveImport
}
// ResolveImport resolves an import relative to the local git clone of the import
func (m *ModulesResolver) ResolveImport(importFile *jenkinsfile.ImportFile) (string, error) {
resolver := m.Modules[importFile.Import]
if resolver == nil {
return "", nil
}
return filepath.Join(resolver.PacksDir, importFile.File), nil
}