github.com/caos/orbos@v1.5.14-0.20221103111702-e6cd0cea7ad4/internal/operator/boom/templator/helm/template.go (about)

     1  package helm
     2  
     3  import (
     4  	"fmt"
     5  	"os"
     6  	"path/filepath"
     7  
     8  	"github.com/caos/orbos/internal/operator/boom/api/latest"
     9  	"github.com/caos/orbos/internal/operator/boom/templator"
    10  	"github.com/caos/orbos/internal/operator/boom/templator/helm/helmcommand"
    11  	"github.com/caos/orbos/internal/utils/helper"
    12  	helper2 "github.com/caos/orbos/internal/utils/helper"
    13  	"github.com/caos/orbos/internal/utils/yaml"
    14  )
    15  
    16  func (h *Helm) Template(appInterface interface{}, spec *latest.ToolsetSpec, resultFunc func(resultFilePath, namespace string) error) error {
    17  	app, err := checkTemplatorInterface(appInterface)
    18  	if err != nil {
    19  		return err
    20  	}
    21  
    22  	logFields := map[string]interface{}{
    23  		"application": app.GetName().String(),
    24  		"overlay":     h.overlay,
    25  	}
    26  
    27  	monitor := h.monitor.WithFields(logFields)
    28  
    29  	monitor.Debug("Deleting old results")
    30  	err = h.deleteResults(app)
    31  	if err != nil {
    32  		return err
    33  	}
    34  
    35  	var resultAbsFilePath string
    36  	resultfilepath := h.GetResultsFilePath(app.GetName(), h.overlay, h.templatorDirectoryPath)
    37  
    38  	resultAbsFilePath, err = filepath.Abs(resultfilepath)
    39  	if err != nil {
    40  		return err
    41  	}
    42  
    43  	valuesAbsFilePath, err := helper2.GetAbsPath(h.templatorDirectoryPath, app.GetName().String(), h.overlay, "values.yaml")
    44  	if err != nil {
    45  		monitor.Error(err)
    46  		return err
    47  	}
    48  
    49  	if err := h.prepareHelmTemplate(h.overlay, app, spec, valuesAbsFilePath); err != nil {
    50  		monitor.Error(err)
    51  		return err
    52  	}
    53  
    54  	if err := h.mutateValue(app, spec, valuesAbsFilePath); err != nil {
    55  		monitor.Error(err)
    56  		return err
    57  	}
    58  
    59  	if err := h.runHelmTemplate(h.overlay, app, valuesAbsFilePath, resultAbsFilePath); err != nil {
    60  		monitor.Error(err)
    61  		return err
    62  	}
    63  
    64  	deleteKind := "Namespace"
    65  	err = helper.DeleteKindFromYaml(resultAbsFilePath, deleteKind)
    66  	if err != nil {
    67  		return fmt.Errorf("error while trying to delete kind %s from results: %w", deleteKind, err)
    68  	}
    69  
    70  	// mutate templated results
    71  	if err := h.mutate(app, spec); err != nil {
    72  		return err
    73  	}
    74  
    75  	// pre apply steps
    76  	if err := h.preApplySteps(app, spec); err != nil {
    77  		return err
    78  	}
    79  
    80  	// func to apply
    81  	return resultFunc(resultAbsFilePath, app.GetNamespace())
    82  }
    83  
    84  func (h *Helm) prepareHelmTemplate(overlay string, app templator.HelmApplication, spec *latest.ToolsetSpec, valuesAbsFilePath string) error {
    85  
    86  	logFields := map[string]interface{}{
    87  		"application": app.GetName().String(),
    88  		"overlay":     overlay,
    89  		"action":      "preparetemplating",
    90  	}
    91  	monitor := h.monitor.WithFields(logFields)
    92  
    93  	monitor.Debug("Generate values with toolsetSpec")
    94  	values := app.SpecToHelmValues(monitor, spec)
    95  
    96  	if helper2.FileExists(valuesAbsFilePath) {
    97  		if err := os.Remove(valuesAbsFilePath); err != nil {
    98  			monitor.Error(err)
    99  			return err
   100  		}
   101  	}
   102  
   103  	if err := yaml.New(valuesAbsFilePath).AddStruct(values); err != nil {
   104  		monitor.Error(err)
   105  		return err
   106  	}
   107  	return nil
   108  }
   109  
   110  func (h *Helm) runHelmTemplate(overlay string, app templator.HelmApplication, valuesAbsFilePath, resultAbsFilePath string) error {
   111  	logFields := map[string]interface{}{
   112  		"application": app.GetName().String(),
   113  		"overlay":     overlay,
   114  		"action":      "templating",
   115  	}
   116  	monitor := h.monitor.WithFields(logFields)
   117  
   118  	chartInfo := app.GetChartInfo()
   119  
   120  	monitor.Debug("Generate result through helm template")
   121  	out, err := helmcommand.Template(&helmcommand.TemplateConfig{
   122  		TempFolderPath:   h.templatorDirectoryPath,
   123  		ChartName:        chartInfo.Name,
   124  		ReleaseName:      app.GetName().String(),
   125  		ReleaseNamespace: app.GetNamespace(),
   126  		ValuesFilePath:   valuesAbsFilePath,
   127  	})
   128  	if err != nil {
   129  		return fmt.Errorf("helm templating failed: %w: %s", err, string(out))
   130  	}
   131  
   132  	return yaml.New(resultAbsFilePath).AddString(string(out))
   133  }