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

Compare commits

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

4 Commits
4ae5926b01 ... 11a4d5cc90

Author SHA1 Message Date
admju
11a4d5cc90 lint 2024-09-03 13:18:20 +00:00
admju
26404e5892 lint 2024-09-03 11:46:45 +00:00
admju
9cf954776f format Unix 2024-09-02 11:44:44 +00:00
admju
11f56722f7 Uninstall 2024-09-02 11:43:39 +00:00
31 changed files with 1242 additions and 1111 deletions
Show Stats Expand all files Collapse all files

4
src/Makefile
View File

@ -35,6 +35,9 @@ 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)
@ -65,7 +68,6 @@ 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,34 +1,37 @@
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) { func FromConfigFile(filename string) ([]ChartRepoData, error) {
yamlFile, _ := os.ReadFile(filename) yamlFile, _ := os.ReadFile(filename)
var data chartsRepoData var data chartsRepoData
yaml.Unmarshal(yamlFile, &data) err := yaml.Unmarshal(yamlFile, &data)
return data.Charts if err != nil {
} 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, version) UninstallCmd(context)
}, },
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,51 +1,45 @@
package cmd package cmd
import ( import (
"fmt" "fmt"
log "oc-deploy/log_wrapper" log "oc-deploy/log_wrapper"
"oc-deploy/versionOc" "oc-deploy/install"
"oc-deploy/install" )
)
func InstallCmd(context string, version string) {
func InstallCmd(context string, version string) { log.Log().Info().Msg("Install >> ")
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, Version: version}
log.Log().Info().Msg(" << Version : " + version)
if err != nil { file, err := obj.NewInstall()
log.Log().Fatal().Msg(" >> " + err.Error()) if err != nil {
} log.Log().Fatal().Msg(" >> " + err.Error())
}
workspace := fmt.Sprintf("workspace_%s", context) log.Log().Info().Msg(fmt.Sprintf(" << Version : %s", obj.Version))
obj := install.InstallClass{Workspace: workspace, Version: version} log.Log().Info().Msg(fmt.Sprintf(" >> Config : %s", file))
file, 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(" >> Config : " + file )
err = obj.ChartRepo()
err = obj.Tools() if err != nil {
if err != nil { log.Log().Fatal().Msg(" >> " + err.Error())
log.Log().Fatal().Msg(" >> " + err.Error()) }
}
err = obj.K8s(context)
err = obj.ChartRepo() if err != nil {
if err != nil { log.Log().Fatal().Msg(" >> " + err.Error())
log.Log().Fatal().Msg(" >> " + err.Error()) }
}
err = obj.InstallCharts()
err = obj.K8s(context) if err != nil {
if err != nil { log.Log().Fatal().Msg(" >> " + err.Error())
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,34 +1,43 @@
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, version string) { func UninstallCmd(context string) {
log.Log().Info().Msg("Install >> ") log.Log().Info().Msg("Unnstall >> ")
log.Log().Info().Msg(" << Contexte : " + context) log.Log().Info().Msg(" << Contexte : " + context)
version, err := versionOc.Get(version) workspace := fmt.Sprintf("workspace_%s", context)
log.Log().Info().Msg(" << Version : " + version) obj := install.InstallClass{Workspace: workspace}
if err != nil {
log.Log().Fatal().Msg(" >> " + err.Error()) file, err := obj.NewUninstall()
} if err != nil {
log.Log().Fatal().Msg(" >> " + err.Error())
obj := install.UninstallClass{Workspace: "workspace_" + context, Version: version} }
obj.New() log.Log().Info().Msg(fmt.Sprintf(" << Version : %s", obj.Version))
log.Log().Info().Msg(fmt.Sprintf(" >> Config : %s", file))
// fic, err := obj.New()
// if err != nil { err = obj.Tools()
// log.Log().Fatal().Msg(" >> " + err.Error()) if err != nil {
// } 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,7 +8,6 @@ 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,121 +1,132 @@
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
json.Unmarshal(stdout, &objmap) err = json.Unmarshal(stdout, &objmap)
if err != nil {
res := objmap.Info.Status return "", err
}
return res, nil
} res := objmap.Info.Status
func (this HelmChart) Uninstall() (string, error) { return res, nil
bin := this.Bin }
log.Log().Info().Msg(" >> Chart : " + this.Name) func (this HelmChart) Uninstall() (string, error) {
bin := this.Bin
msg := fmt.Sprintf("%s uninstall %s", bin, this.Name)
log.Log().Debug().Msg(msg) log.Log().Info().Msg(" >> Chart : " + this.Name)
cmd := exec.Command(bin, "uninstall", this.Name) existe, err := this.exists()
stdout, err := cmd.CombinedOutput() if err != nil {
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) {
bin := this.Bin msg := fmt.Sprintf("%s uninstall %s", bin, this.Name)
log.Log().Debug().Msg(msg)
msg := fmt.Sprintf("%s list --filter %s --no-headers", bin, this.Name)
log.Log().Debug().Msg(msg) cmd := exec.Command(bin, "uninstall", this.Name)
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()
if err != nil { // ../bin/helm list --filter phpmyadminm --short
return false, errors.New(string(stdout)) func (this HelmChart) exists() (bool, error) {
} bin := this.Bin
res := string(stdout) msg := fmt.Sprintf("%s list --filter %s --no-headers", bin, this.Name)
res = strings.TrimSuffix(res, "\n") log.Log().Debug().Msg(msg)
log.Log().Debug().Msg(string(stdout)) cmd_args := strings.Split(msg, " ")
return res != "", nil cmd := exec.Command(cmd_args[0], cmd_args[1:]...)
} 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 Normal file
View File

@ -0,0 +1,90 @@
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,98 +2,69 @@ package install
import ( import (
"fmt" "fmt"
"errors"
"sync" "sync"
// "time" "os"
log "oc-deploy/log_wrapper" log "oc-deploy/log_wrapper"
"oc-deploy/utils" "oc-deploy/utils"
"oc-deploy/tool" "oc-deploy/tool"
"oc-deploy/helm"
"oc-deploy/chart" "oc-deploy/chart"
"oc-deploy/helm"
"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) New() (string, error) { func (this *InstallClass) NewInstall() (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))
err := utils.CopyFile(src, dst) if _, err := os.Stat(dst); err == nil {
if err != nil { log.Log().Debug().Msg("Existe déjà")
return "", err 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, 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
this.tools = tool.FromConfigFile(this.versionFile) var err error
this.tools, err = tool.FromConfigFile(dst)
this.charts = chart.FromConfigFile(this.versionFile) if err != nil {
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) {
@ -116,38 +87,8 @@ func (this *InstallClass) ChartRepo() (error) {
return nil return nil
} }
func (this *InstallClass) K8s(context string) (error) {
bin_path, _ := this.getToolBin("kubectl")
kube := kubectl.KubeContext{Bin: bin_path} func (this *InstallClass) InstallCharts() (error) {
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")
@ -159,7 +100,7 @@ func (this *InstallClass) Charts() (error) {
go func() { go func() {
defer wg.Done() defer wg.Done()
this.worker(helm_bin, kubectl_bin, v1) this.installChart(helm_bin, kubectl_bin, v1)
} () } ()
} }
@ -168,7 +109,7 @@ func (this *InstallClass) Charts() (error) {
return nil return nil
} }
func (this *InstallClass) worker(helm_bin string, kubectl_bin string, chart chart.ChartData) { func (this *InstallClass) installChart(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))
@ -177,7 +118,7 @@ func (this *InstallClass) worker(helm_bin string, kubectl_bin string, chart 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,18 +1,75 @@
package install package install
import ( import (
// "fmt" "fmt"
// "os" "os"
// "io" "sync"
// "path/filepath"
// log "oc-deploy/log_wrapper" log "oc-deploy/log_wrapper"
"oc-deploy/versionOc"
"oc-deploy/tool"
"oc-deploy/chart"
"oc-deploy/helm"
) )
type UninstallClass struct { func (this *InstallClass) NewUninstall() (string, error) {
Version string dst := fmt.Sprintf("%s/oc.yml", this.Workspace)
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 UninstallClass) New() { func (this *InstallClass) UninstallCharts() (error) {
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,108 +1,111 @@
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
json.Unmarshal(stdout, &objmap) err := json.Unmarshal(stdout, &objmap)
currentContext := objmap.CurrentContext if err != nil {
return "", "", "", err
currentCluster := "" }
currentNamespace := "" currentContext := objmap.CurrentContext
for _, v := range objmap.Contexts {
if v.Name == currentContext { currentCluster := ""
currentNamespace = v.Context.Namespace currentNamespace := ""
currentCluster = v.Context.Cluster for _, v := range objmap.Contexts {
} if v.Name == currentContext {
} currentNamespace = v.Context.Namespace
currentCluster = v.Context.Cluster
currentServer := "" }
for _, v := range objmap.Clusters { }
if v.Name == currentCluster {
currentServer = v.Cluster.Server currentServer := ""
} for _, v := range objmap.Clusters {
} if v.Name == currentCluster {
currentServer = v.Cluster.Server
return currentContext, currentNamespace, currentServer, nil }
} }
func (this KubeContext) UseContext(newContext string) (error) { return currentContext, currentNamespace, currentServer, nil
}
cmd := exec.Command(this.Bin, "config", "use-context", newContext)
stdout, err := cmd.CombinedOutput() func (this KubeContext) UseContext(newContext string) (error) {
if err != nil { cmd := exec.Command(this.Bin, "config", "use-context", newContext)
log.Log().Debug().Msg(string(stdout)) stdout, err := cmd.CombinedOutput()
return errors.New(string(stdout))
} if err != nil {
log.Log().Debug().Msg(string(stdout))
return nil return errors.New(string(stdout))
} }
func (this KubeContext) Check() (error) { return nil
}
cmd := exec.Command(this.Bin, "cluster-info")
stdout, err := cmd.CombinedOutput() func (this KubeContext) Check() (error) {
if err != nil {
log.Log().Debug().Msg(string(stdout)) cmd := exec.Command(this.Bin, "cluster-info")
return errors.New("Kube non disponible") stdout, err := cmd.CombinedOutput()
} if err != nil {
log.Log().Debug().Msg(string(stdout))
return nil return errors.New("Kube non disponible")
} }
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,17 +1,20 @@
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) { func FromConfigFile(filename string) ([]ToolData, error) {
yamlFile, _ := os.ReadFile(filename) yamlFile, _ := os.ReadFile(filename)
var data toolsData var data toolsData
yaml.Unmarshal(yamlFile, &data) err := yaml.Unmarshal(yamlFile, &data)
return data.Tools if err != nil {
} return data.Tools, nil
}
return data.Tools, nil
}

105
src/tool/helm.go
View File

@ -1,53 +1,54 @@
package tool package tool
import ( import (
"fmt" "fmt"
"os" "os"
// log "oc-deploy/log_wrapper" "oc-deploy/utils"
"oc-deploy/utils" "oc-deploy/helm"
"oc-deploy/helm" )
)
type HelmInstallData struct {
type HelmInstallData struct { obj ToolData
obj ToolData tmp string
tmp string }
}
func (this HelmInstallData) Get() (ToolData) {
func (this HelmInstallData) Get() (ToolData) { return this.obj
return this.obj }
}
func (this HelmInstallData) Download() (error) {
func (this HelmInstallData) Download() (error) {
bin_dir := this.obj.Bin
bin_dir := this.obj.Bin err2 := os.MkdirAll(bin_dir, os.ModePerm)
err2 := os.MkdirAll(bin_dir, os.ModePerm) if err2 != nil {
if err2 != nil { fmt.Println(err2)
fmt.Println(err2) return err2
return err2 }
}
tmp_file := fmt.Sprintf("%s/oc-deploy-%s", this.tmp, this.obj.Name)
tmp_file := fmt.Sprintf("%s/oc-deploy-%s", this.tmp, this.obj.Name) url := fmt.Sprintf(this.obj.Url, this.obj.Version)
url := fmt.Sprintf(this.obj.Url, this.obj.Version)
err := utils.DownloadFromUrl(tmp_file, url, 0777)
err := utils.DownloadFromUrl(tmp_file, url, 0777) if err != nil {
if err != nil { return err
return err }
}
r, _ := os.Open(tmp_file)
r, _ := os.Open(tmp_file) err1 := utils.ExtractTarGz(bin_dir, r)
err1 := utils.ExtractTarGz(bin_dir, r) if err1 != nil {return err1}
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)
os.Chmod(bin_file, 0755) errChmod := os.Chmod(bin_file, 0755)
if errChmod != nil {return errChmod}
return err1
} return nil
}
///////////////
func (this HelmInstallData) Version(path string) (string, error) { ///////////////
return helm.Version(path) func (this HelmInstallData) Version(path string) (string, error) {
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,80 +1,79 @@
package tool package tool
import ( import (
"fmt" "fmt"
"os" "os"
"os/exec" "os/exec"
"errors" "path/filepath"
"path/filepath" )
)
type ToolData struct {
type ToolData struct { Name string `yaml:"name"`
Name string `yaml:"name"` Url string `yaml:"url"`
Url string `yaml:"url"` Version string `yaml:"version"`
Version string `yaml:"version"` Bin string
Bin string }
}
type ToolClass struct {
type ToolClass struct { Obj Forme
Obj Forme Path string
Path string }
}
type Forme interface {
type Forme interface { Download() error
Download() error Version(string) (string, error)
Version(string) (string, error) Get() ToolData
Get() ToolData }
}
//////////
////////// func (this *ToolClass) New(data ToolData) (error) {
func (this *ToolClass) New(data ToolData) (error) { f, err := factory(data)
f, err := factory(data) if err != nil {
if err != nil { return err
return err }
} this.Obj = f
this.Obj = f return nil
return nil }
}
func (this *ToolClass) Locate() (error) {
func (this *ToolClass) Locate() (error) {
obj := this.Obj
obj := this.Obj data := obj.Get()
data := obj.Get() path := filepath.Join(data.Bin, data.Name)
path := filepath.Join(data.Bin, data.Name)
if _, err := os.Stat(path); err != nil {
if _, err := os.Stat(path); err != nil { path2, _ := exec.LookPath(data.Name)
path2, _ := exec.LookPath(data.Name) if path2 != "" {
if path2 != "" { path = path2
path = path2 } else {
} else { err = obj.Download()
err = obj.Download() if err != nil {
if err != nil { return err
return err }
} }
} }
}
this.Path = path
this.Path = path return nil
return nil }
}
func (this *ToolClass) Version() (string, error) {
func (this *ToolClass) Version() (string, error) { obj := (this.Obj)
obj := (this.Obj) return obj.Version(this.Path)
return obj.Version(this.Path) }
}
//////////
////////// func factory(data ToolData) (Forme, error) {
func factory(data ToolData) (Forme, error) { var f Forme
var f Forme
switch data.Name {
switch data.Name { case "kubectl":
case "kubectl": f = KubecltInstallData{obj: data}
f = KubecltInstallData{obj: data} case "helm":
case "helm": f = HelmInstallData{obj: data, tmp: "/tmp"}
f = HelmInstallData{obj: data, tmp: "/tmp"} default:
default: return f, fmt.Errorf("Outil Inconnu : %s", data.Name)
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 true { for {
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/ioutil" "io"
"gopkg.in/yaml.v2" "gopkg.in/yaml.v2"
log "oc-deploy/log_wrapper" log "oc-deploy/log_wrapper"
) )
@ -14,6 +14,25 @@ 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) {
@ -45,14 +64,14 @@ func readLatestFile() (string, error) {
} }
defer fin.Close() defer fin.Close()
byteValue, err := ioutil.ReadAll(fin) byteValue, err := io.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
} }