core/oc-deploy
5
0
Fork 0
Code Issues 2 Pull Requests Packages Projects Releases 1 Wiki Activity

Compare commits

base: core:11a4d5cc9014f64f5187581ed2581c907ab4b8b1
Branches Tags
core:main
core:feat/bin
core:feat/chart
core:develop
core:v0.1.0
..
compare: core:4ae5926b0190878807ce6d81abe1ba64bef82ef1
Branches Tags
core:feat/bin
core:feat/chart
core:main
core:develop
core:v0.1.0

No commits in common. "11a4d5cc9014f64f5187581ed2581c907ab4b8b1" and "4ae5926b0190878807ce6d81abe1ba64bef82ef1" have entirely different histories.
11a4d5cc90 ... 4ae5926b01

31 changed files with 1111 additions and 1242 deletions
Show Stats Expand all files Collapse all files

4
src/Makefile
View File

@ -35,9 +35,6 @@ help:
${BIN_DIR}/${BIN_NAME}: ${SOURCES} $(OBJS) ${BIN_DIR}/${BIN_NAME}: ${SOURCES} $(OBJS)
go build -o ${BIN_DIR}/${BIN_NAME} go build -o ${BIN_DIR}/${BIN_NAME}
get-deps:
@go mod tidy
build: ${BIN_DIR}/${BIN_NAME} build: ${BIN_DIR}/${BIN_NAME}
run: $(OBJS) run: $(OBJS)
@ -68,6 +65,7 @@ clean:
@test ! -e go.sum || rm go.sum @test ! -e go.sum || rm go.sum
@test ! -e .oc-deploy.log || rm .oc-deploy.log @test ! -e .oc-deploy.log || rm .oc-deploy.log
@rm -rf workspace_* @rm -rf workspace_*
@go mod tidy
.PHONY: test .PHONY: test
test: test:

71
src/chart/conf.go
View File

@ -1,37 +1,34 @@
package chart package chart
import ( import (
"os" "os"
"gopkg.in/yaml.v2" "gopkg.in/yaml.v2"
) )
type ChartData struct { type ChartData struct {
Name string `yaml:"name"` Name string `yaml:"name"`
Chart string `yaml:"chart"` Chart string `yaml:"chart"`
Version string `yaml:"version"` Version string `yaml:"version"`
Opts string `yaml:"helm_opts"` Opts string `yaml:"helm_opts"`
Values string `yaml:"helm_values"` Values string `yaml:"helm_values"`
FileValues string `yaml:"helm_filevalues"` FileValues string `yaml:"helm_filevalues"`
} }
type ChartRepoData struct { type ChartRepoData struct {
Name string `yaml:"name"` Name string `yaml:"name"`
Repository string `yaml:"repository"` Repository string `yaml:"repository"`
Charts []ChartData `yaml:"charts"` Charts []ChartData `yaml:"charts"`
} }
type chartsRepoData struct { type chartsRepoData struct {
Charts []ChartRepoData `yaml:"opencloud"` Charts []ChartRepoData `yaml:"opencloud"`
} }
func FromConfigFile(filename string) ([]ChartRepoData, error) { func FromConfigFile(filename string) ([]ChartRepoData) {
yamlFile, _ := os.ReadFile(filename) yamlFile, _ := os.ReadFile(filename)
var data chartsRepoData var data chartsRepoData
err := yaml.Unmarshal(yamlFile, &data) yaml.Unmarshal(yamlFile, &data)
if err != nil { return data.Charts
return data.Charts, err }
}
return data.Charts, nil
}

60
src/chart/conf_test.go
View File

@ -1,30 +1,30 @@
package chart package chart
// https://pkg.go.dev/github.com/stretchr/testify/assert // https://pkg.go.dev/github.com/stretchr/testify/assert
import ( import (
"testing" "testing"
"path/filepath" "path/filepath"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
) )
func TestReadConfChart(t *testing.T){ func TestReadConfChart(t *testing.T){
src := filepath.Join(TEST_SRC_DIR, "oc.yml") src := filepath.Join(TEST_SRC_DIR, "oc.yml")
assert.FileExists(t, src, "FromConfigFile error") assert.FileExists(t, src, "FromConfigFile error")
data, _ := FromConfigFile(src) data := FromConfigFile(src)
assert.Equal(t, data[0].Name, "bitnami", "FromConfigFile error") assert.Equal(t, data[0].Name, "bitnami", "FromConfigFile error")
assert.Equal(t, data[0].Repository, "https://charts.bitnami.com/bitnami", "FromConfigFile error") assert.Equal(t, data[0].Repository, "https://charts.bitnami.com/bitnami", "FromConfigFile error")
wordpress := data[0].Charts[0] wordpress := data[0].Charts[0]
assert.Equal(t, wordpress.Name, "wordpress", "FromConfigFile error") assert.Equal(t, wordpress.Name, "wordpress", "FromConfigFile error")
assert.Equal(t, wordpress.Chart, "bitnami/wordpress", "FromConfigFile error") assert.Equal(t, wordpress.Chart, "bitnami/wordpress", "FromConfigFile error")
assert.Equal(t, wordpress.Version, "23.1.0", "FromConfigFile error") assert.Equal(t, wordpress.Version, "23.1.0", "FromConfigFile error")
phpmyadmin := data[0].Charts[1] phpmyadmin := data[0].Charts[1]
assert.Equal(t, phpmyadmin.Name, "phpmyadmin", "FromConfigFile error") assert.Equal(t, phpmyadmin.Name, "phpmyadmin", "FromConfigFile error")
assert.Equal(t, phpmyadmin.Chart, "bitnami/phpmyadmin", "FromConfigFile error") assert.Equal(t, phpmyadmin.Chart, "bitnami/phpmyadmin", "FromConfigFile error")
assert.Equal(t, phpmyadmin.Version, "17.0.4", "FromConfigFile error") assert.Equal(t, phpmyadmin.Version, "17.0.4", "FromConfigFile error")
} }

44
src/chart/main_test.go
View File

@ -1,23 +1,23 @@
package chart package chart
import ( import (
"os" "os"
"testing" "testing"
"path/filepath" "path/filepath"
) )
var TEST_DEST_DIR = "../wrk_chart" var TEST_DEST_DIR = "../wrk_chart"
var TEST_SRC_DIR = filepath.Join("../../test", "chart") var TEST_SRC_DIR = filepath.Join("../../test", "chart")
func TestMain(m *testing.M) { func TestMain(m *testing.M) {
folderPath := TEST_DEST_DIR folderPath := TEST_DEST_DIR
os.RemoveAll(folderPath) os.RemoveAll(folderPath)
os.MkdirAll(folderPath, os.ModePerm) os.MkdirAll(folderPath, os.ModePerm)
// call flag.Parse() here if TestMain uses flags // call flag.Parse() here if TestMain uses flags
exitCode := m.Run() exitCode := m.Run()
os.RemoveAll(folderPath) os.RemoveAll(folderPath)
os.Exit(exitCode) os.Exit(exitCode)
} }

2
src/cmd/args.go
View File

@ -38,7 +38,7 @@ func Execute() {
Long: `Undeploy`, Long: `Undeploy`,
Args: cobra.MaximumNArgs(0), Args: cobra.MaximumNArgs(0),
Run: func(cmd *cobra.Command, args []string) { Run: func(cmd *cobra.Command, args []string) {
UninstallCmd(context) UninstallCmd(context, version)
}, },
Example: "oc-deploy uninstall --context ex1", Example: "oc-deploy uninstall --context ex1",
} }

52
src/cmd/generateCmd.go
View File

@ -1,27 +1,27 @@
package cmd package cmd
import ( import (
log "oc-deploy/log_wrapper" log "oc-deploy/log_wrapper"
"oc-deploy/versionOc" "oc-deploy/versionOc"
"oc-deploy/generate" "oc-deploy/generate"
) )
func GenerateCmd(project string, version string) { func GenerateCmd(project string, version string) {
log.Log().Info().Msg("Generate >> ") log.Log().Info().Msg("Generate >> ")
version, err := versionOc.Get(version) version, err := versionOc.Get(version)
if err != nil { if err != nil {
log.Log().Fatal().Msg("OpenCloud >> " + err.Error()) log.Log().Fatal().Msg("OpenCloud >> " + err.Error())
} }
log.Log().Info().Msg(" >> Version : " + version) log.Log().Info().Msg(" >> Version : " + version)
obj := generate.GenerateClass{Workspace: "workspace_" + project, Version: version} obj := generate.GenerateClass{Workspace: "workspace_" + project, Version: version}
fic, err := obj.New() fic, err := obj.New()
if err != nil { if err != nil {
log.Log().Fatal().Msg(" >> " + err.Error()) log.Log().Fatal().Msg(" >> " + err.Error())
} }
log.Log().Info().Msg(" >> Value : " + fic) log.Log().Info().Msg(" >> Value : " + fic)
} }

94
src/cmd/installCmd.go
View File

@ -1,45 +1,51 @@
package cmd package cmd
import ( import (
"fmt" "fmt"
log "oc-deploy/log_wrapper" log "oc-deploy/log_wrapper"
"oc-deploy/install" "oc-deploy/versionOc"
) "oc-deploy/install"
)
func InstallCmd(context string, version string) {
log.Log().Info().Msg("Install >> ") func InstallCmd(context string, version string) {
log.Log().Info().Msg("Install >> ")
log.Log().Info().Msg(" << Contexte : " + context)
log.Log().Info().Msg(" << Contexte : " + context)
workspace := fmt.Sprintf("workspace_%s", context)
obj := install.InstallClass{Workspace: workspace, Version: version} version, err := versionOc.Get(version)
log.Log().Info().Msg(" << Version : " + version)
file, err := obj.NewInstall() if err != nil {
if err != nil { log.Log().Fatal().Msg(" >> " + err.Error())
log.Log().Fatal().Msg(" >> " + err.Error()) }
}
log.Log().Info().Msg(fmt.Sprintf(" << Version : %s", obj.Version)) workspace := fmt.Sprintf("workspace_%s", context)
log.Log().Info().Msg(fmt.Sprintf(" >> Config : %s", file)) obj := install.InstallClass{Workspace: workspace, Version: version}
err = obj.Tools() file, err := obj.New()
if err != nil { if err != nil {
log.Log().Fatal().Msg(" >> " + err.Error()) log.Log().Fatal().Msg(" >> " + err.Error())
} }
log.Log().Info().Msg(" >> Config : " + file )
err = obj.ChartRepo()
if err != nil { err = obj.Tools()
log.Log().Fatal().Msg(" >> " + err.Error()) if err != nil {
} log.Log().Fatal().Msg(" >> " + err.Error())
}
err = obj.K8s(context)
if err != nil { err = obj.ChartRepo()
log.Log().Fatal().Msg(" >> " + err.Error()) if err != nil {
} log.Log().Fatal().Msg(" >> " + err.Error())
}
err = obj.InstallCharts()
if err != nil { err = obj.K8s(context)
log.Log().Fatal().Msg(" >> " + err.Error()) if err != nil {
} log.Log().Fatal().Msg(" >> " + err.Error())
}
err = obj.Charts()
if err != nil {
log.Log().Fatal().Msg(" >> " + err.Error())
}
} }

75
src/cmd/uninstallCmd.go
View File

@ -1,43 +1,34 @@
package cmd package cmd
import ( import (
"fmt" // "fmt"
// "strings" // "strings"
// "github.com/spf13/cobra" // "github.com/spf13/cobra"
log "oc-deploy/log_wrapper" log "oc-deploy/log_wrapper"
// "oc-deploy/versionOc" "oc-deploy/versionOc"
"oc-deploy/install" "oc-deploy/install"
) )
func UninstallCmd(context string) { func UninstallCmd(context string, version string) {
log.Log().Info().Msg("Unnstall >> ") log.Log().Info().Msg("Install >> ")
log.Log().Info().Msg(" << Contexte : " + context) log.Log().Info().Msg(" << Contexte : " + context)
workspace := fmt.Sprintf("workspace_%s", context) version, err := versionOc.Get(version)
obj := install.InstallClass{Workspace: workspace} log.Log().Info().Msg(" << Version : " + version)
if err != nil {
file, err := obj.NewUninstall() log.Log().Fatal().Msg(" >> " + err.Error())
if err != nil { }
log.Log().Fatal().Msg(" >> " + err.Error())
} obj := install.UninstallClass{Workspace: "workspace_" + context, Version: version}
log.Log().Info().Msg(fmt.Sprintf(" << Version : %s", obj.Version)) obj.New()
log.Log().Info().Msg(fmt.Sprintf(" >> Config : %s", file))
// fic, err := obj.New()
err = obj.Tools() // if err != nil {
if err != nil { // log.Log().Fatal().Msg(" >> " + err.Error())
log.Log().Fatal().Msg(" >> " + err.Error()) // }
} // log.Log().Info().Msg(" >> Value : " + fic)
err = obj.K8s(context)
if err != nil {
log.Log().Fatal().Msg(" >> " + err.Error())
}
err = obj.UninstallCharts()
if err != nil {
log.Log().Fatal().Msg(" >> " + err.Error())
}
} }

1
src/generate/generate.go
View File

@ -8,6 +8,7 @@ import (
type GenerateClass struct { type GenerateClass struct {
Version string Version string
Workspace string Workspace string
url string
} }
func (this GenerateClass) New() (string, error) { func (this GenerateClass) New() (string, error) {

253
src/helm/chart.go
View File

@ -1,132 +1,121 @@
package helm package helm
import ( import (
"fmt" "fmt"
"os" "os"
"os/exec" "os/exec"
"strings" "strings"
"errors" "errors"
"path/filepath" "path/filepath"
"encoding/json" "encoding/json"
log "oc-deploy/log_wrapper" log "oc-deploy/log_wrapper"
) )
type HelmChart struct { type HelmChart struct {
Bin string Bin string
Name string Name string
Chart string Chart string
Version string Version string
Workspace string Workspace string
Opts string Opts string
Values string Values string
FileValues string FileValues string
} }
type installInfoOutput struct { type installInfoOutput struct {
Description string `json:"description"` Description string `json:"description"`
Notes string `json:"notes"` Notes string `json:"notes"`
Status string `json:"status"` Status string `json:"status"`
} }
type installOutput struct { type installOutput struct {
Info installInfoOutput `json:"info"` Info installInfoOutput `json:"info"`
} }
func (this HelmChart) Install() (string, error) { func (this HelmChart) Install() (string, error) {
bin := this.Bin bin := this.Bin
existe, err := this.exists() existe, err := this.exists()
if err != nil { if err != nil {
return "", err return "", err
} }
if existe { if existe {
return "Existe déjà", nil return "Existe déjà", nil
} }
msg := fmt.Sprintf("%s install %s %s %s --output json", bin, this.Name, this.Chart, this.Opts) msg := fmt.Sprintf("%s install %s %s %s --output json", bin, this.Name, this.Chart, this.Opts)
if this.Version != "" { if this.Version != "" {
msg = fmt.Sprintf("%s --version %s", msg, this.Version) msg = fmt.Sprintf("%s --version %s", msg, this.Version)
} }
if this.FileValues != "" { if this.FileValues != "" {
fic := filepath.Join(this.Workspace, this.FileValues) fic := filepath.Join(this.Workspace, this.FileValues)
if _, err := os.Stat(fic); err != nil { if _, err := os.Stat(fic); err != nil {
log.Log().Warn().Msg(fic) log.Log().Warn().Msg(fic)
} else { } else {
msg = fmt.Sprintf("%s --values %s", msg, fic) msg = fmt.Sprintf("%s --values %s", msg, fic)
} }
} }
msg = strings.Replace(msg, " ", " ", -1) msg = strings.Replace(msg, " ", " ", -1)
log.Log().Debug().Msg(msg) log.Log().Debug().Msg(msg)
cmd_args := strings.Split(msg, " ") cmd_args := strings.Split(msg, " ")
cmd := exec.Command(cmd_args[0], cmd_args[1:]...) cmd := exec.Command(cmd_args[0], cmd_args[1:]...)
stdout, err := cmd.CombinedOutput() stdout, err := cmd.CombinedOutput()
if err != nil { if err != nil {
res := string(stdout) res := string(stdout)
res = strings.TrimSuffix(res, "\n") res = strings.TrimSuffix(res, "\n")
return "", errors.New(res) return "", errors.New(res)
} }
var objmap installOutput var objmap installOutput
err = json.Unmarshal(stdout, &objmap) json.Unmarshal(stdout, &objmap)
if err != nil {
return "", err res := objmap.Info.Status
}
return res, nil
res := objmap.Info.Status }
return res, nil func (this HelmChart) Uninstall() (string, error) {
} bin := this.Bin
func (this HelmChart) Uninstall() (string, error) { log.Log().Info().Msg(" >> Chart : " + this.Name)
bin := this.Bin
msg := fmt.Sprintf("%s uninstall %s", bin, this.Name)
log.Log().Info().Msg(" >> Chart : " + this.Name) log.Log().Debug().Msg(msg)
existe, err := this.exists() cmd := exec.Command(bin, "uninstall", this.Name)
if err != nil { stdout, err := cmd.CombinedOutput()
return "", err
} return string(stdout), err
if ! existe { }
return "Non présent", nil
} // ../bin/helm list --filter phpmyadminm --short
func (this HelmChart) exists() (bool, error) {
msg := fmt.Sprintf("%s uninstall %s", bin, this.Name) bin := this.Bin
log.Log().Debug().Msg(msg)
msg := fmt.Sprintf("%s list --filter %s --no-headers", bin, this.Name)
cmd := exec.Command(bin, "uninstall", this.Name) log.Log().Debug().Msg(msg)
stdout, err := cmd.CombinedOutput()
cmd_args := strings.Split(msg, " ")
return string(stdout), err
} cmd := exec.Command(cmd_args[0], cmd_args[1:]...)
stdout, err := cmd.CombinedOutput()
// ../bin/helm list --filter phpmyadminm --short if err != nil {
func (this HelmChart) exists() (bool, error) { return false, errors.New(string(stdout))
bin := this.Bin }
msg := fmt.Sprintf("%s list --filter %s --no-headers", bin, this.Name) res := string(stdout)
log.Log().Debug().Msg(msg) res = strings.TrimSuffix(res, "\n")
cmd_args := strings.Split(msg, " ") log.Log().Debug().Msg(string(stdout))
cmd := exec.Command(cmd_args[0], cmd_args[1:]...) return res != "", nil
stdout, err := cmd.CombinedOutput() }
if err != nil {
return false, errors.New(string(stdout))
}
res := string(stdout)
res = strings.TrimSuffix(res, "\n")
log.Log().Debug().Msg(string(stdout))
return res != "", nil
}

46
src/helm/main_test.go
View File

@ -1,24 +1,24 @@
package helm package helm
import ( import (
"os" "os"
"testing" "testing"
"path/filepath" "path/filepath"
) )
var TEST_DEST_DIR = "../wrk_helm" var TEST_DEST_DIR = "../wrk_helm"
var TEST_SRC_DIR = filepath.Join("../../test", "helm") var TEST_SRC_DIR = filepath.Join("../../test", "helm")
var TEST_BIN_DIR = filepath.Join("../../test", "bin") var TEST_BIN_DIR = filepath.Join("../../test", "bin")
func TestMain(m *testing.M) { func TestMain(m *testing.M) {
folderPath := TEST_DEST_DIR folderPath := TEST_DEST_DIR
os.RemoveAll(folderPath) os.RemoveAll(folderPath)
os.MkdirAll(folderPath, os.ModePerm) os.MkdirAll(folderPath, os.ModePerm)
// call flag.Parse() here if TestMain uses flags // call flag.Parse() here if TestMain uses flags
exitCode := m.Run() exitCode := m.Run()
os.RemoveAll(folderPath) os.RemoveAll(folderPath)
os.Exit(exitCode) os.Exit(exitCode)
} }

106
src/helm/repo.go
View File

@ -1,53 +1,53 @@
package helm package helm
import ( import (
"fmt" "fmt"
"strings" "strings"
"os/exec" "os/exec"
log "oc-deploy/log_wrapper" log "oc-deploy/log_wrapper"
) )
type HelmRepo struct { type HelmRepo struct {
Bin string // Chemin vers le binaire Bin string // Chemin vers le binaire
Name string Name string
Repository string // Url du dépôt Repository string // Url du dépôt
ForceUpdate bool ForceUpdate bool
Opts string Opts string
} }
func (this HelmRepo) AddRepository() (string, error) { func (this HelmRepo) AddRepository() (string, error) {
helm_bin := this.Bin helm_bin := this.Bin
force_update := "--force-update=false" force_update := "--force-update=false"
if this.ForceUpdate { if this.ForceUpdate {
force_update = "--force-update=true" force_update = "--force-update=true"
} }
msg := fmt.Sprintf("%s repo add %s %s %s %s", helm_bin, this.Name, this.Repository, force_update, this.Opts) msg := fmt.Sprintf("%s repo add %s %s %s %s", helm_bin, this.Name, this.Repository, force_update, this.Opts)
log.Log().Debug().Msg(msg) log.Log().Debug().Msg(msg)
cmd := exec.Command(helm_bin, "repo", "add", this.Name, this.Repository, force_update) cmd := exec.Command(helm_bin, "repo", "add", this.Name, this.Repository, force_update)
stdout, err := cmd.CombinedOutput() stdout, err := cmd.CombinedOutput()
res := string(stdout) res := string(stdout)
res = strings.TrimSuffix(res, "\n") res = strings.TrimSuffix(res, "\n")
return res, err return res, err
} }
// helm repo remove [NAME] // helm repo remove [NAME]
func (this HelmRepo) RemoveRepository() (string, error) { func (this HelmRepo) RemoveRepository() (string, error) {
helm_bin := this.Bin helm_bin := this.Bin
msg := fmt.Sprintf("%s repo remove %s", helm_bin, this.Name) msg := fmt.Sprintf("%s repo remove %s", helm_bin, this.Name)
log.Log().Debug().Msg(msg) log.Log().Debug().Msg(msg)
cmd := exec.Command(helm_bin, "repo", "remove", this.Name) cmd := exec.Command(helm_bin, "repo", "remove", this.Name)
stdout, err := cmd.CombinedOutput() stdout, err := cmd.CombinedOutput()
res := string(stdout) res := string(stdout)
res = strings.TrimSuffix(res, "\n") res = strings.TrimSuffix(res, "\n")
return res, err return res, err
} }

44
src/helm/repo_test.go
View File

@ -1,23 +1,23 @@
package helm package helm
import ( import (
// "os" // "os"
// "path/filepath" // "path/filepath"
"testing" "testing"
// "github.com/stretchr/testify/assert" // "github.com/stretchr/testify/assert"
) )
func TestHelmRepoAdd(t *testing.T){ func TestHelmRepoAdd(t *testing.T){
// fmt.Println(" TestVersion ", TEST_BIN_DIR) // fmt.Println(" TestVersion ", TEST_BIN_DIR)
// bin := filepath.Join(TEST_BIN_DIR, "helm") // bin := filepath.Join(TEST_BIN_DIR, "helm")
// os.Chmod(bin, 0700) // os.Chmod(bin, 0700)
// assert.FileExists(t, bin, "TestHelmVersion error") // assert.FileExists(t, bin, "TestHelmVersion error")
// version, err := Version(bin) // version, err := Version(bin)
// assert.Nilf(t, err, "error message %s", bin) // assert.Nilf(t, err, "error message %s", bin)
// assert.Equal(t, version, "v3.15.4+gfa9efb0", "TestHelmVersion error") // assert.Equal(t, version, "v3.15.4+gfa9efb0", "TestHelmVersion error")
} }

40
src/helm/version.go
View File

@ -1,20 +1,20 @@
package helm package helm
import ( import (
"strings" "strings"
"os/exec" "os/exec"
) )
func Version(path string) (string, error) { func Version(path string) (string, error) {
cmd := exec.Command(path, "version", "--short") cmd := exec.Command(path, "version", "--short")
stdout, err := cmd.CombinedOutput() stdout, err := cmd.CombinedOutput()
if err != nil { if err != nil {
return "", err return "", err
} }
res := string(stdout) res := string(stdout)
res = strings.TrimSuffix(res, "\n") res = strings.TrimSuffix(res, "\n")
return res, nil return res, nil
} }

42
src/helm/version_test.go
View File

@ -1,22 +1,22 @@
package helm package helm
import ( import (
"os" "os"
"path/filepath" "path/filepath"
"testing" "testing"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
) )
func TestHelmVersion(t *testing.T){ func TestHelmVersion(t *testing.T){
bin := filepath.Join(TEST_BIN_DIR, "helm") bin := filepath.Join(TEST_BIN_DIR, "helm")
os.Chmod(bin, 0700) os.Chmod(bin, 0700)
assert.FileExists(t, bin, "TestHelmVersion error") assert.FileExists(t, bin, "TestHelmVersion error")
version, err := Version(bin) version, err := Version(bin)
assert.Nilf(t, err, "error message %s", bin) assert.Nilf(t, err, "error message %s", bin)
assert.Equal(t, version, "v3.15.4+gfa9efb0", "TestHelmVersion error") assert.Equal(t, version, "v3.15.4+gfa9efb0", "TestHelmVersion error")
} }

90
src/install/common.go
View File

@ -1,90 +0,0 @@
package install
import (
"fmt"
"errors"
log "oc-deploy/log_wrapper"
"oc-deploy/tool"
"oc-deploy/kubectl"
)
func (this *InstallClass) Tools() (error) {
var mem []tool.ToolClass
for _, v := range this.tools {
tool2 := tool.ToolClass{}
v.Bin = this.Workspace
err := tool2.New(v)
if err != nil {
return err
}
mem = append(mem,tool2)
}
this.toolsBin = make(map[string]string)
for _, p := range mem {
data := p.Obj.Get()
log.Log().Info().Msg(fmt.Sprintf(" >> Outils : %s", data.Name))
err := p.Locate()
if err != nil {
log.Log().Info().Msg(fmt.Sprintf(" << %s ", err))
return err
}
log.Log().Info().Msg(fmt.Sprintf(" << %s ", p.Path))
version, err1 := p.Version()
if err1 != nil {
log.Log().Info().Msg(fmt.Sprintf(" << %s ", err1))
return err1
}
log.Log().Info().Msg(fmt.Sprintf(" << %s ", version))
this.toolsBin[data.Name] = p.Path
}
return nil
}
func (this *InstallClass) getToolBin(name string) (string, error) {
for key, value := range this.toolsBin {
if key == name {
return value, nil
}
}
return "", errors.New("Error")
}
func (this *InstallClass) K8s(context string) (error) {
bin_path, _ := this.getToolBin("kubectl")
kube := kubectl.KubeContext{Bin: bin_path}
err := kube.UseContext(context)
if err != nil {
log.Log().Info().Msg(fmt.Sprintf(" << Kube : %s ", err))
return err
}
currentcontext, namespace, server, err := kube.GetContext()
if err != nil {
log.Log().Info().Msg(fmt.Sprintf(" << Kube : %s ", err))
return err
}
log.Log().Info().Msg(fmt.Sprintf(" << Kube : %s ", currentcontext))
log.Log().Info().Msg(fmt.Sprintf(" << : %s ", namespace))
log.Log().Info().Msg(fmt.Sprintf(" << : %s ", server))
err = kube.Check()
if err != nil {
log.Log().Info().Msg(fmt.Sprintf(" << : %s ", err))
return err
}
log.Log().Info().Msg(fmt.Sprintf(" << : %s ", "OK"))
return nil
}

135
src/install/install.go
View File

@ -2,69 +2,98 @@ package install
import ( import (
"fmt" "fmt"
"errors"
"sync" "sync"
"os" // "time"
log "oc-deploy/log_wrapper" log "oc-deploy/log_wrapper"
"oc-deploy/utils" "oc-deploy/utils"
"oc-deploy/tool" "oc-deploy/tool"
"oc-deploy/chart"
"oc-deploy/helm" "oc-deploy/helm"
"oc-deploy/chart"
"oc-deploy/kubectl" "oc-deploy/kubectl"
"oc-deploy/versionOc"
) )
type InstallClass struct { type InstallClass struct {
Version string Version string
Workspace string Workspace string
// versionFile string versionFile string
tools []tool.ToolData tools []tool.ToolData
toolsBin map[string]string toolsBin map[string]string
charts []chart.ChartRepoData charts []chart.ChartRepoData
} }
func (this *InstallClass) NewInstall() (string, error) { func (this *InstallClass) New() (string, error) {
// Extraction du fichier de version // Extraction du fichier de version
log.Log().Debug().Msg("Téléchargement du fichier de version")
src := fmt.Sprintf("../offline/oc_%s.yml", this.Version)
dst := fmt.Sprintf("%s/oc.yml", this.Workspace) 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 { err := utils.CopyFile(src, dst)
log.Log().Debug().Msg("Existe déjà") if err != nil {
version, err := versionOc.GetFromFile(dst) return "", err
if err != nil {
return "", err
}
this.Version = version
} else {
log.Log().Debug().Msg("Téléchargement du fichier de version")
version, err := versionOc.Get(this.Version)
if err != nil {
return "", err
}
src := fmt.Sprintf("../offline/oc_%s.yml", version)
err = utils.CopyFile(src, dst)
if err != nil {
return "", err
}
} }
// Lecture du fichier de conf // Lecture du fichier de conf
// this.versionFile = dst this.versionFile = dst
var err error this.tools = tool.FromConfigFile(this.versionFile)
this.tools, err = tool.FromConfigFile(dst)
if err != nil { this.charts = chart.FromConfigFile(this.versionFile)
return dst, err
}
this.charts, _ = chart.FromConfigFile(dst)
if err != nil {
return dst, err
}
return dst, nil return dst, nil
} }
func (this *InstallClass) Tools() (error) {
var mem []tool.ToolClass
for _, v := range this.tools {
tool2 := tool.ToolClass{}
v.Bin = this.Workspace
err := tool2.New(v)
if err != nil {
return err
}
mem = append(mem,tool2)
}
this.toolsBin = make(map[string]string)
for _, p := range mem {
data := p.Obj.Get()
log.Log().Info().Msg(fmt.Sprintf(" >> Outils : %s", data.Name))
err := p.Locate()
if err != nil {
log.Log().Info().Msg(fmt.Sprintf(" << %s ", err))
return err
}
log.Log().Info().Msg(fmt.Sprintf(" << %s ", p.Path))
version, err1 := p.Version()
if err1 != nil {
log.Log().Info().Msg(fmt.Sprintf(" << %s ", err1))
return err1
}
log.Log().Info().Msg(fmt.Sprintf(" << %s ", version))
this.toolsBin[data.Name] = p.Path
}
return nil
}
func (this *InstallClass) getToolBin(name string) (string, error) {
for key, value := range this.toolsBin {
if key == name {
return value, nil
}
}
return "", errors.New("Error")
}
func (this *InstallClass) ChartRepo() (error) { func (this *InstallClass) ChartRepo() (error) {
@ -87,8 +116,38 @@ func (this *InstallClass) ChartRepo() (error) {
return nil return nil
} }
func (this *InstallClass) K8s(context string) (error) {
bin_path, _ := this.getToolBin("kubectl")
func (this *InstallClass) InstallCharts() (error) { kube := kubectl.KubeContext{Bin: bin_path}
err := kube.UseContext(context)
if err != nil {
log.Log().Info().Msg(fmt.Sprintf(" << Kube : %s ", err))
return err
}
currentcontext, namespace, server, err := kube.GetContext()
if err != nil {
log.Log().Info().Msg(fmt.Sprintf(" << Kube : %s ", err))
return err
}
log.Log().Info().Msg(fmt.Sprintf(" << Kube : %s ", currentcontext))
log.Log().Info().Msg(fmt.Sprintf(" << : %s ", namespace))
log.Log().Info().Msg(fmt.Sprintf(" << : %s ", server))
err = kube.Check()
if err != nil {
log.Log().Info().Msg(fmt.Sprintf(" << : %s ", err))
return err
}
log.Log().Info().Msg(fmt.Sprintf(" << : %s ", "OK"))
return nil
}
func (this *InstallClass) Charts() (error) {
helm_bin, _ := this.getToolBin("helm") helm_bin, _ := this.getToolBin("helm")
kubectl_bin, _ := this.getToolBin("kubectl") kubectl_bin, _ := this.getToolBin("kubectl")
@ -100,7 +159,7 @@ func (this *InstallClass) InstallCharts() (error) {
go func() { go func() {
defer wg.Done() defer wg.Done()
this.installChart(helm_bin, kubectl_bin, v1) this.worker(helm_bin, kubectl_bin, v1)
} () } ()
} }
@ -109,7 +168,7 @@ func (this *InstallClass) InstallCharts() (error) {
return nil return nil
} }
func (this *InstallClass) installChart(helm_bin string, kubectl_bin string, chart chart.ChartData) { func (this *InstallClass) worker(helm_bin string, kubectl_bin string, chart chart.ChartData) {
log.Log().Info().Msg(fmt.Sprintf(" << Chart : %s ", chart.Name)) log.Log().Info().Msg(fmt.Sprintf(" << Chart : %s ", chart.Name))
@ -118,7 +177,7 @@ func (this *InstallClass) installChart(helm_bin string, kubectl_bin string, char
Chart: chart.Chart, Chart: chart.Chart,
Version: chart.Version, Version: chart.Version,
Workspace: this.Workspace, Workspace: this.Workspace,
Opts: chart.Opts, Opts: chart.Opts,
Values: chart.Values, Values: chart.Values,
FileValues: chart.FileValues} FileValues: chart.FileValues}

75
src/install/uninstall.go
View File

@ -1,75 +1,18 @@
package install package install
import ( import (
"fmt" // "fmt"
"os" // "os"
"sync" // "io"
// "path/filepath"
log "oc-deploy/log_wrapper" // log "oc-deploy/log_wrapper"
"oc-deploy/versionOc"
"oc-deploy/tool"
"oc-deploy/chart"
"oc-deploy/helm"
) )
func (this *InstallClass) NewUninstall() (string, error) { type UninstallClass struct {
dst := fmt.Sprintf("%s/oc.yml", this.Workspace) Version string
Workspace string
if _, err := os.Stat(dst); err != nil {
return dst, err
}
version, err := versionOc.GetFromFile(dst)
if err != nil {
return "", err
}
this.Version = version
// 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) UninstallCharts() (error) { func (this UninstallClass) New() {
helm_bin, _ := this.getToolBin("helm")
kubectl_bin, _ := this.getToolBin("kubectl")
var wg sync.WaitGroup
for _, v := range this.charts {
for _, v1 := range v.Charts {
wg.Add(1)
go func() {
defer wg.Done()
this.uninstallChart(helm_bin, kubectl_bin, v1)
} ()
}
}
wg.Wait()
return nil
}
func (this *InstallClass) uninstallChart(helm_bin string, kubectl_bin string, chart chart.ChartData) {
log.Log().Info().Msg(fmt.Sprintf(" << Chart : %s ", chart.Name))
helmchart := helm.HelmChart{Bin: helm_bin,
Name: chart.Name}
res, err := helmchart.Uninstall()
if err != nil {
log.Log().Error().Msg(fmt.Sprintf(" >> %s %s (%s)", helmchart.Name, "KO", err))
return
}
log.Log().Info().Msg(fmt.Sprintf(" >> %s (%s)", helmchart.Name, res))
} }

219
src/kubectl/context.go
View File

@ -1,111 +1,108 @@
package kubectl package kubectl
import ( import (
// "fmt" // "fmt"
"strings" "strings"
"errors" "errors"
"os/exec" "os/exec"
"encoding/json" "encoding/json"
log "oc-deploy/log_wrapper" log "oc-deploy/log_wrapper"
) )
type KubeContext struct { type KubeContext struct {
Bin string // Chemin vers le binaire Bin string // Chemin vers le binaire
} }
type kubeConfig struct { type kubeConfig struct {
CurrentContext string `json:"current-context"` CurrentContext string `json:"current-context"`
Contexts [] kubeConfigContexts `json:"contexts"` Contexts [] kubeConfigContexts `json:"contexts"`
Clusters [] kubeConfigClusters `json:"clusters"` Clusters [] kubeConfigClusters `json:"clusters"`
} }
type kubeConfigContexts struct { type kubeConfigContexts struct {
Name string `json:"name"` Name string `json:"name"`
Context kubeConfigContext `json:"context"` Context kubeConfigContext `json:"context"`
} }
type kubeConfigContext struct { type kubeConfigContext struct {
Cluster string `json:"cluster"` Cluster string `json:"cluster"`
User string `json:"user"` User string `json:"user"`
Namespace string `json:"namespace"` Namespace string `json:"namespace"`
} }
type kubeConfigCluster struct { type kubeConfigCluster struct {
Server string `json:"server"` Server string `json:"server"`
} }
type kubeConfigClusters struct { type kubeConfigClusters struct {
Name string `json:"name"` Name string `json:"name"`
Cluster kubeConfigCluster `json:"cluster"` Cluster kubeConfigCluster `json:"cluster"`
} }
func (this KubeContext) GetCurrentContext() (string, error) { func (this KubeContext) GetCurrentContext() (string, error) {
cmd := exec.Command(this.Bin, "config", "current-context") cmd := exec.Command(this.Bin, "config", "current-context")
stdout, err := cmd.CombinedOutput() stdout, err := cmd.CombinedOutput()
res := string(stdout) res := string(stdout)
res = strings.TrimSuffix(res, "\n") res = strings.TrimSuffix(res, "\n")
return res, err return res, err
} }
// Current Context // Current Context
// namespace, server // namespace, server
func (this KubeContext) GetContext() (string, string, string, error) { func (this KubeContext) GetContext() (string, string, string, error) {
cmd := exec.Command(this.Bin, "config", "view", "-o", "json") cmd := exec.Command(this.Bin, "config", "view", "-o", "json")
stdout, _ := cmd.CombinedOutput() stdout, _ := cmd.CombinedOutput()
var objmap kubeConfig var objmap kubeConfig
err := json.Unmarshal(stdout, &objmap) json.Unmarshal(stdout, &objmap)
if err != nil { currentContext := objmap.CurrentContext
return "", "", "", err
} currentCluster := ""
currentContext := objmap.CurrentContext currentNamespace := ""
for _, v := range objmap.Contexts {
currentCluster := "" if v.Name == currentContext {
currentNamespace := "" currentNamespace = v.Context.Namespace
for _, v := range objmap.Contexts { currentCluster = v.Context.Cluster
if v.Name == currentContext { }
currentNamespace = v.Context.Namespace }
currentCluster = v.Context.Cluster
} currentServer := ""
} for _, v := range objmap.Clusters {
if v.Name == currentCluster {
currentServer := "" currentServer = v.Cluster.Server
for _, v := range objmap.Clusters { }
if v.Name == currentCluster { }
currentServer = v.Cluster.Server
} return currentContext, currentNamespace, currentServer, nil
} }
return currentContext, currentNamespace, currentServer, nil func (this KubeContext) UseContext(newContext string) (error) {
}
cmd := exec.Command(this.Bin, "config", "use-context", newContext)
func (this KubeContext) UseContext(newContext string) (error) { stdout, err := cmd.CombinedOutput()
cmd := exec.Command(this.Bin, "config", "use-context", newContext) if err != nil {
stdout, err := cmd.CombinedOutput() log.Log().Debug().Msg(string(stdout))
return errors.New(string(stdout))
if err != nil { }
log.Log().Debug().Msg(string(stdout))
return errors.New(string(stdout)) return nil
} }
return nil func (this KubeContext) Check() (error) {
}
cmd := exec.Command(this.Bin, "cluster-info")
func (this KubeContext) Check() (error) { stdout, err := cmd.CombinedOutput()
if err != nil {
cmd := exec.Command(this.Bin, "cluster-info") log.Log().Debug().Msg(string(stdout))
stdout, err := cmd.CombinedOutput() return errors.New("Kube non disponible")
if err != nil { }
log.Log().Debug().Msg(string(stdout))
return errors.New("Kube non disponible") return nil
} }
return nil
}

162
src/kubectl/object.go
View File

@ -1,82 +1,82 @@
package kubectl package kubectl
import ( import (
"fmt" "fmt"
"strings" "strings"
"errors" "errors"
"time" "time"
"os/exec" "os/exec"
"encoding/json" "encoding/json"
log "oc-deploy/log_wrapper" log "oc-deploy/log_wrapper"
) )
type KubeObject struct { type KubeObject struct {
Bin string // Chemin vers le binaire Bin string // Chemin vers le binaire
Name string Name string
} }
type getOutput struct { type getOutput struct {
Kind string `json:"kind"` Kind string `json:"kind"`
Status getStatusOutput `json:"status"` Status getStatusOutput `json:"status"`
} }
type getStatusOutput struct { type getStatusOutput struct {
Replicas int `json:"replicas"` Replicas int `json:"replicas"`
UnavailableReplicas int `json:"unavailableReplicas"` UnavailableReplicas int `json:"unavailableReplicas"`
} }
func (this KubeObject) Get() (map[string]any, error) { func (this KubeObject) Get() (map[string]any, error) {
bin := this.Bin bin := this.Bin
name := this.Name name := this.Name
msg := fmt.Sprintf("%s get deployment %s -o json", bin, name) msg := fmt.Sprintf("%s get deployment %s -o json", bin, name)
log.Log().Debug().Msg(msg) log.Log().Debug().Msg(msg)
m := make(map[string]any) m := make(map[string]any)
cmd_args := strings.Split(msg, " ") cmd_args := strings.Split(msg, " ")
cmd := exec.Command(cmd_args[0], cmd_args[1:]...) cmd := exec.Command(cmd_args[0], cmd_args[1:]...)
stdout, err := cmd.CombinedOutput() stdout, err := cmd.CombinedOutput()
if err != nil { if err != nil {
return m, errors.New(string(stdout)) return m, errors.New(string(stdout))
} }
var objmap getOutput var objmap getOutput
json.Unmarshal(stdout, &objmap) json.Unmarshal(stdout, &objmap)
kind := objmap.Kind kind := objmap.Kind
status := objmap.Status status := objmap.Status
m["name"] = name m["name"] = name
m["kind"] = kind m["kind"] = kind
m["replicas"] = status.Replicas m["replicas"] = status.Replicas
m["UnavailableReplicas"] = status.UnavailableReplicas m["UnavailableReplicas"] = status.UnavailableReplicas
return m, nil return m, nil
} }
func (this KubeObject) Wait() (error) { func (this KubeObject) Wait() (error) {
boucle := 10 boucle := 10
sleep := 10000 * time.Millisecond sleep := 10000 * time.Millisecond
for _ = range boucle { for _ = range boucle {
log.Log().Debug().Msg(fmt.Sprintf("Check Deployement %s", this.Name)) log.Log().Debug().Msg(fmt.Sprintf("Check Deployement %s", this.Name))
m, err := this.Get() m, err := this.Get()
if err != nil { if err != nil {
return err return err
} }
ko := m["UnavailableReplicas"].(int) ko := m["UnavailableReplicas"].(int)
if ko == 0 { if ko == 0 {
return nil return nil
} }
time.Sleep(sleep) time.Sleep(sleep)
} }
return errors.New("Temps d'attente dépassé") return errors.New("Temps d'attente dépassé")
} }

62
src/kubectl/version.go
View File

@ -1,31 +1,31 @@
package kubectl package kubectl
import ( import (
"os/exec" "os/exec"
"encoding/json" "encoding/json"
) )
type toolClientVersion struct { type toolClientVersion struct {
GitVersion string `json:"gitVersion"` GitVersion string `json:"gitVersion"`
} }
type toolVersion struct { type toolVersion struct {
ClientVersion toolClientVersion `json:"clientVersion"` ClientVersion toolClientVersion `json:"clientVersion"`
} }
func Version(path string) (string, error) { func Version(path string) (string, error) {
cmd := exec.Command(path, "version", "-o", "json", "--client=true") cmd := exec.Command(path, "version", "-o", "json", "--client=true")
stdout, err := cmd.CombinedOutput() stdout, err := cmd.CombinedOutput()
if err != nil { if err != nil {
return "", err return "", err
} }
var objmap toolVersion var objmap toolVersion
json.Unmarshal(stdout, &objmap) json.Unmarshal(stdout, &objmap)
res := objmap.ClientVersion.GitVersion res := objmap.ClientVersion.GitVersion
return res, nil return res, nil
} }

37
src/tool/conf.go
View File

@ -1,20 +1,17 @@
package tool package tool
import ( import (
"os" "os"
"gopkg.in/yaml.v2" "gopkg.in/yaml.v2"
) )
type toolsData struct { type toolsData struct {
Tools []ToolData `yaml:"tools"` Tools []ToolData `yaml:"tools"`
} }
func FromConfigFile(filename string) ([]ToolData, error) { func FromConfigFile(filename string) ([]ToolData) {
yamlFile, _ := os.ReadFile(filename) yamlFile, _ := os.ReadFile(filename)
var data toolsData var data toolsData
err := yaml.Unmarshal(yamlFile, &data) yaml.Unmarshal(yamlFile, &data)
if err != nil { return data.Tools
return data.Tools, nil }
}
return data.Tools, nil
}

105
src/tool/helm.go
View File

@ -1,54 +1,53 @@
package tool package tool
import ( import (
"fmt" "fmt"
"os" "os"
"oc-deploy/utils" // log "oc-deploy/log_wrapper"
"oc-deploy/helm" "oc-deploy/utils"
) "oc-deploy/helm"
)
type HelmInstallData struct {
obj ToolData type HelmInstallData struct {
tmp string obj ToolData
} tmp string
}
func (this HelmInstallData) Get() (ToolData) {
return this.obj func (this HelmInstallData) Get() (ToolData) {
} return this.obj
}
func (this HelmInstallData) Download() (error) {
func (this HelmInstallData) Download() (error) {
bin_dir := this.obj.Bin
err2 := os.MkdirAll(bin_dir, os.ModePerm) bin_dir := this.obj.Bin
if err2 != nil { err2 := os.MkdirAll(bin_dir, os.ModePerm)
fmt.Println(err2) if err2 != nil {
return err2 fmt.Println(err2)
} return err2
}
tmp_file := fmt.Sprintf("%s/oc-deploy-%s", this.tmp, this.obj.Name)
url := fmt.Sprintf(this.obj.Url, this.obj.Version) tmp_file := fmt.Sprintf("%s/oc-deploy-%s", this.tmp, this.obj.Name)
url := fmt.Sprintf(this.obj.Url, this.obj.Version)
err := utils.DownloadFromUrl(tmp_file, url, 0777)
if err != nil { err := utils.DownloadFromUrl(tmp_file, url, 0777)
return err if err != nil {
} return err
}
r, _ := os.Open(tmp_file)
err1 := utils.ExtractTarGz(bin_dir, r) r, _ := os.Open(tmp_file)
if err1 != nil {return err1} err1 := utils.ExtractTarGz(bin_dir, r)
os.Remove(tmp_file) os.Remove(tmp_file)
bin_file := fmt.Sprintf("%s/%s", bin_dir, this.obj.Name) bin_file := fmt.Sprintf("%s/%s", bin_dir, this.obj.Name)
errChmod := os.Chmod(bin_file, 0755) os.Chmod(bin_file, 0755)
if errChmod != nil {return errChmod}
return err1
return nil }
}
///////////////
/////////////// func (this HelmInstallData) Version(path string) (string, error) {
func (this HelmInstallData) Version(path string) (string, error) { return helm.Version(path)
return helm.Version(path)
} }

82
src/tool/kubectl.go
View File

@ -1,41 +1,41 @@
package tool package tool
import ( import (
"fmt" "fmt"
"os" "os"
"path/filepath" "path/filepath"
log "oc-deploy/log_wrapper" log "oc-deploy/log_wrapper"
"oc-deploy/utils" "oc-deploy/utils"
"oc-deploy/kubectl" "oc-deploy/kubectl"
) )
type KubecltInstallData struct { type KubecltInstallData struct {
obj ToolData obj ToolData
} }
func (this KubecltInstallData) Get() (ToolData) { func (this KubecltInstallData) Get() (ToolData) {
return this.obj return this.obj
} }
func (this KubecltInstallData) Download() (error) { func (this KubecltInstallData) Download() (error) {
bin_dir := this.obj.Bin bin_dir := this.obj.Bin
bin := filepath.Join(bin_dir, this.obj.Name) bin := filepath.Join(bin_dir, this.obj.Name)
url := fmt.Sprintf(this.obj.Url, this.obj.Version) url := fmt.Sprintf(this.obj.Url, this.obj.Version)
log.Log().Debug().Msg(fmt.Sprintf("Téléchargement : %s, %s", bin, url)) log.Log().Debug().Msg(fmt.Sprintf("Téléchargement : %s, %s", bin, url))
os.MkdirAll(bin_dir, os.ModePerm) os.MkdirAll(bin_dir, os.ModePerm)
err := utils.DownloadFromUrl(bin, url, 0777) err := utils.DownloadFromUrl(bin, url, 0777)
if err != nil {return err} if err != nil {return err}
os.Chmod(bin, 0755) os.Chmod(bin, 0755)
return nil return nil
} }
/////////////// ///////////////
func (this KubecltInstallData) Version(path string) (string, error) { func (this KubecltInstallData) Version(path string) (string, error) {
return kubectl.Version(path) return kubectl.Version(path)
} }

159
src/tool/tool.go
View File

@ -1,79 +1,80 @@
package tool package tool
import ( import (
"fmt" "fmt"
"os" "os"
"os/exec" "os/exec"
"path/filepath" "errors"
) "path/filepath"
)
type ToolData struct {
Name string `yaml:"name"` type ToolData struct {
Url string `yaml:"url"` Name string `yaml:"name"`
Version string `yaml:"version"` Url string `yaml:"url"`
Bin string Version string `yaml:"version"`
} Bin string
}
type ToolClass struct {
Obj Forme type ToolClass struct {
Path string Obj Forme
} Path string
}
type Forme interface {
Download() error type Forme interface {
Version(string) (string, error) Download() error
Get() ToolData Version(string) (string, error)
} Get() ToolData
}
//////////
func (this *ToolClass) New(data ToolData) (error) { //////////
f, err := factory(data) func (this *ToolClass) New(data ToolData) (error) {
if err != nil { f, err := factory(data)
return err if err != nil {
} return err
this.Obj = f }
return nil this.Obj = f
} return nil
}
func (this *ToolClass) Locate() (error) {
func (this *ToolClass) Locate() (error) {
obj := this.Obj
data := obj.Get() obj := this.Obj
path := filepath.Join(data.Bin, data.Name) data := obj.Get()
path := filepath.Join(data.Bin, data.Name)
if _, err := os.Stat(path); err != nil {
path2, _ := exec.LookPath(data.Name) if _, err := os.Stat(path); err != nil {
if path2 != "" { path2, _ := exec.LookPath(data.Name)
path = path2 if path2 != "" {
} else { path = path2
err = obj.Download() } else {
if err != nil { err = obj.Download()
return err if err != nil {
} return err
} }
} }
}
this.Path = path
return nil this.Path = path
} return nil
}
func (this *ToolClass) Version() (string, error) {
obj := (this.Obj) func (this *ToolClass) Version() (string, error) {
return obj.Version(this.Path) obj := (this.Obj)
} return obj.Version(this.Path)
}
//////////
func factory(data ToolData) (Forme, error) { //////////
var f Forme func factory(data ToolData) (Forme, error) {
var f Forme
switch data.Name {
case "kubectl": switch data.Name {
f = KubecltInstallData{obj: data} case "kubectl":
case "helm": f = KubecltInstallData{obj: data}
f = HelmInstallData{obj: data, tmp: "/tmp"} case "helm":
default: f = HelmInstallData{obj: data, tmp: "/tmp"}
return f, fmt.Errorf("Outil Inconnu : %s", data.Name) default:
} return f, errors.New(fmt.Sprintf("Outil Inconnu : %s", data.Name))
}
return f, nil
} return f, nil
}

68
src/utils/copyFile.go
View File

@ -1,35 +1,35 @@
package utils package utils
import ( import (
"os" "os"
"io" "io"
"path/filepath" "path/filepath"
) )
func CopyFile(src string, dst string) (error) { func CopyFile(src string, dst string) (error) {
if _, err := os.Stat(src); err != nil { if _, err := os.Stat(src); err != nil {
return err return err
} }
fin, errOpen := os.Open(src) fin, errOpen := os.Open(src)
if errOpen != nil { if errOpen != nil {
return errOpen return errOpen
} }
defer fin.Close() defer fin.Close()
folderPath := filepath.Dir(dst) folderPath := filepath.Dir(dst)
os.MkdirAll(folderPath, os.ModePerm) os.MkdirAll(folderPath, os.ModePerm)
fout, errCreate := os.Create(dst) fout, errCreate := os.Create(dst)
if errCreate != nil { if errCreate != nil {
return errCreate return errCreate
} }
defer fout.Close() defer fout.Close()
_, errCopy := io.Copy(fout, fin) _, errCopy := io.Copy(fout, fin)
if errCopy != nil { if errCopy != nil {
return errCopy return errCopy
} }
return nil return nil
} }

94
src/utils/copyFile_test.go
View File

@ -1,47 +1,47 @@
package utils package utils
// https://pkg.go.dev/github.com/stretchr/testify/assert#Nilf // https://pkg.go.dev/github.com/stretchr/testify/assert#Nilf
import ( import (
"testing" "testing"
"path/filepath" "path/filepath"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
) )
func TestCopyFileExist(t *testing.T){ func TestCopyFileExist(t *testing.T){
src := filepath.Join(TEST_SRC_DIR, "fichier1") src := filepath.Join(TEST_SRC_DIR, "fichier1")
dest := filepath.Join(TEST_DEST_DIR, "fichier1") dest := filepath.Join(TEST_DEST_DIR, "fichier1")
err := CopyFile(src, dest) err := CopyFile(src, dest)
assert.Nilf(t, err, "error message %s", src) assert.Nilf(t, err, "error message %s", src)
assert.FileExists(t, dest, "CopyFile error") assert.FileExists(t, dest, "CopyFile error")
} }
func TestCopyErrSrcFileNotExist(t *testing.T) { func TestCopyErrSrcFileNotExist(t *testing.T) {
src := filepath.Join(TEST_SRC_DIR, "inconnu") src := filepath.Join(TEST_SRC_DIR, "inconnu")
dest := filepath.Join(TEST_DEST_DIR, "inconnu") dest := filepath.Join(TEST_DEST_DIR, "inconnu")
err := CopyFile(src, dest) err := CopyFile(src, dest)
assert.NotNilf(t, err, "CopyFile error %s", src) assert.NotNilf(t, err, "CopyFile error %s", src)
} }
func TestCopyFileErrCreate(t *testing.T){ func TestCopyFileErrCreate(t *testing.T){
src := filepath.Join(TEST_SRC_DIR, "fichier1") src := filepath.Join(TEST_SRC_DIR, "fichier1")
dest := filepath.Join("/INCONNU", "fichier1") dest := filepath.Join("/INCONNU", "fichier1")
err := CopyFile(src, dest) err := CopyFile(src, dest)
assert.NotNilf(t, err, "error message %s", src) assert.NotNilf(t, err, "error message %s", src)
assert.NoFileExists(t, dest, "CopyFile error") assert.NoFileExists(t, dest, "CopyFile error")
} }
func TestCopyErrSrcWrite(t *testing.T) { func TestCopyErrSrcWrite(t *testing.T) {
src := "/" src := "/"
dest := filepath.Join(TEST_DEST_DIR, "inconnu") dest := filepath.Join(TEST_DEST_DIR, "inconnu")
err := CopyFile(src, dest) err := CopyFile(src, dest)
assert.NotNilf(t, err, "CopyFile error %s", src) assert.NotNilf(t, err, "CopyFile error %s", src)
} }

2
src/utils/download.go
View File

@ -43,7 +43,7 @@ func ExtractTarGz(dest string, gzipStream io.Reader) error {
tarReader := tar.NewReader(uncompressedStream) tarReader := tar.NewReader(uncompressedStream)
for { for true {
header, err := tarReader.Next() header, err := tarReader.Next()
if err == io.EOF { if err == io.EOF {

56
src/utils/download_test.go
View File

@ -1,28 +1,28 @@
package utils package utils
// https://pkg.go.dev/github.com/stretchr/testify/assert#Nilf // https://pkg.go.dev/github.com/stretchr/testify/assert#Nilf
import ( import (
"path/filepath" "path/filepath"
"testing" "testing"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/jarcoal/httpmock" "github.com/jarcoal/httpmock"
) )
func TestDownload(t *testing.T){ func TestDownload(t *testing.T){
httpmock.Activate() httpmock.Activate()
defer httpmock.DeactivateAndReset() defer httpmock.DeactivateAndReset()
url := "http://test.download.com" url := "http://test.download.com"
httpmock.RegisterResponder("GET", url, httpmock.RegisterResponder("GET", url,
httpmock.NewStringResponder(200, `CONTENU_URL`)) httpmock.NewStringResponder(200, `CONTENU_URL`))
dest := filepath.Join(TEST_DEST_DIR, "url") dest := filepath.Join(TEST_DEST_DIR, "url")
err := DownloadFromUrl(dest, url, 777) err := DownloadFromUrl(dest, url, 777)
assert.Nilf(t, err, "error message %s", url) assert.Nilf(t, err, "error message %s", url)
assert.FileExists(t, dest, "DownloadFromUrl error") assert.FileExists(t, dest, "DownloadFromUrl error")
} }

44
src/utils/main_test.go
View File

@ -1,23 +1,23 @@
package utils package utils
import ( import (
"os" "os"
"testing" "testing"
"path/filepath" "path/filepath"
) )
var TEST_DEST_DIR = "../wrk_utils" var TEST_DEST_DIR = "../wrk_utils"
var TEST_SRC_DIR = filepath.Join("../../test", "utils") var TEST_SRC_DIR = filepath.Join("../../test", "utils")
func TestMain(m *testing.M) { func TestMain(m *testing.M) {
folderPath := TEST_DEST_DIR folderPath := TEST_DEST_DIR
os.RemoveAll(folderPath) os.RemoveAll(folderPath)
os.MkdirAll(folderPath, os.ModePerm) os.MkdirAll(folderPath, os.ModePerm)
// call flag.Parse() here if TestMain uses flags // call flag.Parse() here if TestMain uses flags
exitCode := m.Run() exitCode := m.Run()
os.RemoveAll(folderPath) os.RemoveAll(folderPath)
os.Exit(exitCode) os.Exit(exitCode)
} }

29
src/versionOc/versionOc.go
View File

@ -5,7 +5,7 @@ import (
"fmt" "fmt"
"os" "os"
"errors" "errors"
"io" "io/ioutil"
"gopkg.in/yaml.v2" "gopkg.in/yaml.v2"
log "oc-deploy/log_wrapper" log "oc-deploy/log_wrapper"
) )
@ -14,25 +14,6 @@ type versionInput struct {
Version string `yaml:"version"` Version string `yaml:"version"`
} }
func GetFromFile(fileversion string) (string, error) {
fin, err := os.Open(fileversion)
if err != nil {
return "", err
}
defer fin.Close()
byteValue, err := io.ReadAll(fin)
if err != nil {
return "", err
}
var objmap versionInput
yaml.Unmarshal(byteValue, &objmap)
return objmap.Version, nil
}
// Get : Retourne la version // Get : Retourne la version
func Get(version string) (string, error) { func Get(version string) (string, error) {
@ -64,14 +45,14 @@ func readLatestFile() (string, error) {
} }
defer fin.Close() defer fin.Close()
byteValue, err := io.ReadAll(fin) byteValue, err := ioutil.ReadAll(fin)
if err != nil { if err != nil {
return "", err return "", err
} }
var objmap versionInput var objmap versionInput
yaml.Unmarshal(byteValue, &objmap) yaml.Unmarshal(byteValue, &objmap)
return objmap.Version, nil return objmap.Version, nil
} }