github.com/olli-ai/jx/v2@v2.0.400-0.20210921045218-14731b4dd448/pkg/jenkinsfile/gitresolver/resolvers.go (about)

     1  package gitresolver
     2  
     3  import (
     4  	"fmt"
     5  
     6  	"github.com/olli-ai/jx/v2/pkg/gits"
     7  	"github.com/olli-ai/jx/v2/pkg/jenkinsfile"
     8  	"github.com/olli-ai/jx/v2/pkg/util"
     9  	"sigs.k8s.io/yaml"
    10  
    11  	"io/ioutil"
    12  	"path/filepath"
    13  )
    14  
    15  // CreateResolver creates a new module resolver
    16  func CreateResolver(packsDir string, gitter gits.Gitter) (jenkinsfile.ImportFileResolver, error) {
    17  	modules, err := LoadModules(packsDir)
    18  	if err != nil {
    19  		return nil, err
    20  	}
    21  	moduleResolver, err := ResolveModules(modules, gitter)
    22  	if err != nil {
    23  		return nil, err
    24  	}
    25  	return moduleResolver.AsImportResolver(), nil
    26  }
    27  
    28  // Resolve resolves this module to a directory
    29  func Resolve(m *jenkinsfile.Module, gitter gits.Gitter) (*ModuleResolver, error) {
    30  	err := m.Validate()
    31  	if err != nil {
    32  		return nil, err
    33  	}
    34  
    35  	dir, err := InitBuildPack(gitter, m.GitURL, m.GitRef)
    36  	if err != nil {
    37  		return nil, err
    38  	}
    39  
    40  	answer := &ModuleResolver{
    41  		Module:   m,
    42  		PacksDir: dir,
    43  	}
    44  	return answer, nil
    45  }
    46  
    47  // ModulesResolver resolves a number of modules into a structure we can use to resolve imports
    48  type ModulesResolver struct {
    49  	Modules map[string]*ModuleResolver
    50  }
    51  
    52  // ModuleResolver a resolver for a single module
    53  type ModuleResolver struct {
    54  	Module   *jenkinsfile.Module
    55  	PacksDir string
    56  }
    57  
    58  // LoadModules loads the modules in the given build pack directory if there are any
    59  func LoadModules(dir string) (*jenkinsfile.Modules, error) {
    60  	fileName := filepath.Join(dir, jenkinsfile.ModuleFileName)
    61  	config := jenkinsfile.Modules{}
    62  	exists, err := util.FileExists(fileName)
    63  	if err != nil || !exists {
    64  		return &config, err
    65  	}
    66  	data, err := ioutil.ReadFile(fileName)
    67  	if err != nil {
    68  		return &config, fmt.Errorf("Failed to load file %s due to %s", fileName, err)
    69  	}
    70  	err = yaml.Unmarshal(data, &config)
    71  	if err != nil {
    72  		return &config, fmt.Errorf("Failed to unmarshal YAML file %s due to %s", fileName, err)
    73  	}
    74  	return &config, err
    75  }
    76  
    77  // ResolveModules Resolve the modules into a module resolver
    78  func ResolveModules(m *jenkinsfile.Modules, gitter gits.Gitter) (*ModulesResolver, error) {
    79  	answer := &ModulesResolver{
    80  		Modules: map[string]*ModuleResolver{},
    81  	}
    82  	for _, mod := range m.Modules {
    83  		resolver, err := Resolve(mod, gitter)
    84  		if err != nil {
    85  			return answer, err
    86  		}
    87  		answer.Modules[mod.Name] = resolver
    88  	}
    89  	return answer, nil
    90  }
    91  
    92  // AsImportResolver returns an ImportFileResolver for these modules
    93  func (m *ModulesResolver) AsImportResolver() jenkinsfile.ImportFileResolver {
    94  	return m.ResolveImport
    95  }
    96  
    97  // ResolveImport resolves an import relative to the local git clone of the import
    98  func (m *ModulesResolver) ResolveImport(importFile *jenkinsfile.ImportFile) (string, error) {
    99  	resolver := m.Modules[importFile.Import]
   100  	if resolver == nil {
   101  		return "", nil
   102  	}
   103  	return filepath.Join(resolver.PacksDir, importFile.File), nil
   104  }