oc-deploy/src/install/install.go

package install

import (
    "fmt"
    "sync"

    log "oc-deploy/log_wrapper"
    "oc-deploy/utils"
    "oc-deploy/tool"
    "oc-deploy/chart"
    "oc-deploy/helm"
    "oc-deploy/kubectl"
)

func (this *InstallClass) NewInstall() (string, error) {

    // Extraction du fichier de la version
    dst, err := this.extractVersion()
    if err != nil {
        return "", err
    }

    // Lecture du fichier de conf
    this.tools, err = tool.FromConfigFile(dst)
    if err != nil {
        return dst, err
    }
    this.charts, _ = chart.FromConfigFile(dst)
    if err != nil {
        return dst, err
    }

    return dst, nil
}


func (this *InstallClass) ChartRepo() (error) {

    for _, v := range this.charts {
        if v.Repository.Name != "" {
            log.Log().Info().Msg(fmt.Sprintf("  >> Helm Repo : %s", v.Repository.Name))
            repo := helm.HelmRepo{Name: v.Repository.Name,
                                  Repository: v.Repository.Url,
                                  ForceUpdate: v.Repository.ForceUpdate,
                                  Opts: v.Repository.Opts}
            res, err := this.commandHelm.AddRepository(repo)
            if err != nil {
                log.Log().Info().Msg(fmt.Sprintf("  <<             %s ", err))
                return err
            }
            log.Log().Info().Msg(fmt.Sprintf("  <<             %s ", res))
        }
    }
    return nil
}


func (this *InstallClass) InstallCharts(modules []string) (error) {

    var wg sync.WaitGroup

    for _, v := range this.charts {
        for _, v1 := range v.Charts {
            if len(modules) == 0 || utils.StringInSlice(v1.Name, modules) {
                wg.Add(1)

                go func() {
                    defer wg.Done()
                    this.installChart(v1)
                } ()
            }
        }
    }
    wg.Wait()
    return nil
}

func (this *InstallClass) installChart(chart chart.ChartData) {

    log.Log().Info().Msg(fmt.Sprintf("  << Chart     : %s ", chart.Name))

    data := helm.HelmChart{Name: chart.Name,
                           Chart: chart.Chart,
                           Url: chart.Url,
                           Version: chart.Version,
                           Workspace: this.Workspace,
                           Opts: chart.Opts,
                           Values: chart.Values,
                           FileValues: chart.FileValues}

    res, err := this.commandHelm.ChartInstall(data)
    if err != nil {
        log.Log().Error().Msg(fmt.Sprintf("  >>             %s %s (%s)", data.Name, "KO", err))
        return
    }
    log.Log().Info().Msg(fmt.Sprintf("  >>             %s (%s)", data.Name, res))

    ressources, _ := this.commandHelm.GetRessources(data)

    for key, value := range ressources {
        obj := kubectl.KubectlObject{Name: key, Kind: value}
        err := this.commandKubectl.Wait(obj)
        if err != nil {
            log.Log().Error().Msg(fmt.Sprintf("  >>             %s/%s KO (%s)", chart.Name, key, err))
        } else {
            log.Log().Info().Msg(fmt.Sprintf("  >>             %s/%s OK", chart.Name, key))
        }

    }
    
}