oc-deploy/src/install/install.go

package install

import (
    "fmt"
    "sync"
    "os"

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

type InstallClass struct {
    Version string
    Workspace string

    tools []tool.ToolData
    toolsBin map[string]string
    charts []chart.ChartRepoData

    commandHelm helm.HelmCommand
    commandKubectl kubectl.KubectlCommand
}

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

    // Extraction du fichier de version
    dst := fmt.Sprintf("%s/oc.yml", this.Workspace)
    log.Log().Debug().Msg(fmt.Sprintf("Check du fichier de version : %s", dst))
    if _, err := os.Stat(dst); err == nil {
        log.Log().Debug().Msg("Existe déjà")
        version, err := versionOc.GetFromFile(dst)
        if err != nil {
            return "", err
        }
        this.Version = version
    } else {
        log.Log().Debug().Msg("Téléchargement du fichier de version")
        // version, fileversion, err := versionOc.Get(this.Version)
        version, fileversion, err := versionOc.GetFromOnline(this.Version)
        if err != nil {
            return "", err
        }
        this.Version = version

        err = utils.CopyContentFile(fileversion, dst)
        if err != nil {
            return "", err
        }
    }

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

    bin_path, _ := this.getToolBin("helm")
    fmt.Println("Install 67 bin_path", bin_path)

    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}
            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))
        }

    }
    
}