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

71
src/chart/conf.go
View File

@ -1,34 +1,37 @@
package chart
import (
"os"
"gopkg.in/yaml.v2"
)
type ChartData struct {
Name string `yaml:"name"`
Chart string `yaml:"chart"`
Version string `yaml:"version"`
Opts string `yaml:"helm_opts"`
Values string `yaml:"helm_values"`
FileValues string `yaml:"helm_filevalues"`
}
type ChartRepoData struct {
Name string `yaml:"name"`
Repository string `yaml:"repository"`
Charts []ChartData `yaml:"charts"`
}
type chartsRepoData struct {
Charts []ChartRepoData `yaml:"opencloud"`
}
func FromConfigFile(filename string) ([]ChartRepoData) {
yamlFile, _ := os.ReadFile(filename)
var data chartsRepoData
yaml.Unmarshal(yamlFile, &data)
return data.Charts
}
package chart
import (
"os"
"gopkg.in/yaml.v2"
)
type ChartData struct {
Name string `yaml:"name"`
Chart string `yaml:"chart"`
Version string `yaml:"version"`
Opts string `yaml:"helm_opts"`
Values string `yaml:"helm_values"`
FileValues string `yaml:"helm_filevalues"`
}
type ChartRepoData struct {
Name string `yaml:"name"`
Repository string `yaml:"repository"`
Charts []ChartData `yaml:"charts"`
}
type chartsRepoData struct {
Charts []ChartRepoData `yaml:"opencloud"`
}
func FromConfigFile(filename string) ([]ChartRepoData, error) {
yamlFile, _ := os.ReadFile(filename)
var data chartsRepoData
err := yaml.Unmarshal(yamlFile, &data)
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
// https://pkg.go.dev/github.com/stretchr/testify/assert
import (
"testing"
"path/filepath"
"github.com/stretchr/testify/assert"
)
func TestReadConfChart(t *testing.T){
src := filepath.Join(TEST_SRC_DIR, "oc.yml")
assert.FileExists(t, src, "FromConfigFile error")
data := FromConfigFile(src)
assert.Equal(t, data[0].Name, "bitnami", "FromConfigFile error")
assert.Equal(t, data[0].Repository, "https://charts.bitnami.com/bitnami", "FromConfigFile error")
wordpress := data[0].Charts[0]
assert.Equal(t, wordpress.Name, "wordpress", "FromConfigFile error")
assert.Equal(t, wordpress.Chart, "bitnami/wordpress", "FromConfigFile error")
assert.Equal(t, wordpress.Version, "23.1.0", "FromConfigFile error")
phpmyadmin := data[0].Charts[1]
assert.Equal(t, phpmyadmin.Name, "phpmyadmin", "FromConfigFile error")
assert.Equal(t, phpmyadmin.Chart, "bitnami/phpmyadmin", "FromConfigFile error")
assert.Equal(t, phpmyadmin.Version, "17.0.4", "FromConfigFile error")
}
package chart
// https://pkg.go.dev/github.com/stretchr/testify/assert
import (
"testing"
"path/filepath"
"github.com/stretchr/testify/assert"
)
func TestReadConfChart(t *testing.T){
src := filepath.Join(TEST_SRC_DIR, "oc.yml")
assert.FileExists(t, src, "FromConfigFile error")
data, _ := FromConfigFile(src)
assert.Equal(t, data[0].Name, "bitnami", "FromConfigFile error")
assert.Equal(t, data[0].Repository, "https://charts.bitnami.com/bitnami", "FromConfigFile error")
wordpress := data[0].Charts[0]
assert.Equal(t, wordpress.Name, "wordpress", "FromConfigFile error")
assert.Equal(t, wordpress.Chart, "bitnami/wordpress", "FromConfigFile error")
assert.Equal(t, wordpress.Version, "23.1.0", "FromConfigFile error")
phpmyadmin := data[0].Charts[1]
assert.Equal(t, phpmyadmin.Name, "phpmyadmin", "FromConfigFile error")
assert.Equal(t, phpmyadmin.Chart, "bitnami/phpmyadmin", "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
import (
"os"
"testing"
"path/filepath"
)
var TEST_DEST_DIR = "../wrk_chart"
var TEST_SRC_DIR = filepath.Join("../../test", "chart")
func TestMain(m *testing.M) {
folderPath := TEST_DEST_DIR
os.RemoveAll(folderPath)
os.MkdirAll(folderPath, os.ModePerm)
// call flag.Parse() here if TestMain uses flags
exitCode := m.Run()
os.RemoveAll(folderPath)
os.Exit(exitCode)
package chart
import (
"os"
"testing"
"path/filepath"
)
var TEST_DEST_DIR = "../wrk_chart"
var TEST_SRC_DIR = filepath.Join("../../test", "chart")
func TestMain(m *testing.M) {
folderPath := TEST_DEST_DIR
os.RemoveAll(folderPath)
os.MkdirAll(folderPath, os.ModePerm)
// call flag.Parse() here if TestMain uses flags
exitCode := m.Run()
os.RemoveAll(folderPath)
os.Exit(exitCode)
}

2
src/cmd/args.go
View File

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

52
src/cmd/generateCmd.go
View File

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

94
src/cmd/installCmd.go
View File

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

75
src/cmd/uninstallCmd.go
View File

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

253
src/helm/chart.go
View File

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

106
src/helm/repo.go
View File

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

44
src/helm/repo_test.go
View File

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

40
src/helm/version.go
View File

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

42
src/helm/version_test.go
View File

@ -1,22 +1,22 @@
package helm
import (
"os"
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
)
func TestHelmVersion(t *testing.T){
bin := filepath.Join(TEST_BIN_DIR, "helm")
os.Chmod(bin, 0700)
assert.FileExists(t, bin, "TestHelmVersion error")
version, err := Version(bin)
assert.Nilf(t, err, "error message %s", bin)
assert.Equal(t, version, "v3.15.4+gfa9efb0", "TestHelmVersion error")
package helm
import (
"os"
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
)
func TestHelmVersion(t *testing.T){
bin := filepath.Join(TEST_BIN_DIR, "helm")
os.Chmod(bin, 0700)
assert.FileExists(t, bin, "TestHelmVersion error")
version, err := Version(bin)
assert.Nilf(t, err, "error message %s", bin)
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 (
"fmt"
"errors"
"sync"
// "time"
"os"
log "oc-deploy/log_wrapper"
"oc-deploy/utils"
"oc-deploy/tool"
"oc-deploy/helm"
"oc-deploy/chart"
"oc-deploy/helm"
"oc-deploy/kubectl"
"oc-deploy/versionOc"
)
type InstallClass struct {
Version string
Workspace string
versionFile string
// versionFile string
tools []tool.ToolData
toolsBin map[string]string
charts []chart.ChartRepoData
}
func (this *InstallClass) New() (string, error) {
func (this *InstallClass) NewInstall() (string, error) {
// 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)
err := utils.CopyFile(src, dst)
if err != nil {
return "", err
log.Log().Debug().Msg(fmt.Sprintf("Check du fichier de version : %s", dst))
if _, err := os.Stat(dst); err == nil {
log.Log().Debug().Msg("Existe déjà")
version, err := versionOc.GetFromFile(dst)
if err != nil {
return "", err
}
this.Version = version
} else {
log.Log().Debug().Msg("Téléchargement du fichier de version")
version, 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
this.versionFile = dst
// this.versionFile = dst
this.tools = tool.FromConfigFile(this.versionFile)
this.charts = chart.FromConfigFile(this.versionFile)
var err error
this.tools, err = tool.FromConfigFile(dst)
if err != nil {
return dst, err
}
this.charts, _ = chart.FromConfigFile(dst)
if err != nil {
return dst, err
}
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) {
@ -116,38 +87,8 @@ func (this *InstallClass) ChartRepo() (error) {
return nil
}
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
}
func (this *InstallClass) Charts() (error) {
func (this *InstallClass) InstallCharts() (error) {
helm_bin, _ := this.getToolBin("helm")
kubectl_bin, _ := this.getToolBin("kubectl")
@ -159,7 +100,7 @@ func (this *InstallClass) Charts() (error) {
go func() {
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
}
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))
@ -177,7 +118,7 @@ func (this *InstallClass) worker(helm_bin string, kubectl_bin string, chart char
Chart: chart.Chart,
Version: chart.Version,
Workspace: this.Workspace,
Opts: chart.Opts,
Opts: chart.Opts,
Values: chart.Values,
FileValues: chart.FileValues}

75
src/install/uninstall.go
View File

@ -1,18 +1,75 @@
package install
import (
// "fmt"
// "os"
// "io"
// "path/filepath"
// log "oc-deploy/log_wrapper"
"fmt"
"os"
"sync"
log "oc-deploy/log_wrapper"
"oc-deploy/versionOc"
"oc-deploy/tool"
"oc-deploy/chart"
"oc-deploy/helm"
)
type UninstallClass struct {
Version string
Workspace string
func (this *InstallClass) NewUninstall() (string, error) {
dst := fmt.Sprintf("%s/oc.yml", this.Workspace)
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
import (
// "fmt"
"strings"
"errors"
"os/exec"
"encoding/json"
log "oc-deploy/log_wrapper"
)
type KubeContext struct {
Bin string // Chemin vers le binaire
}
type kubeConfig struct {
CurrentContext string `json:"current-context"`
Contexts [] kubeConfigContexts `json:"contexts"`
Clusters [] kubeConfigClusters `json:"clusters"`
}
type kubeConfigContexts struct {
Name string `json:"name"`
Context kubeConfigContext `json:"context"`
}
type kubeConfigContext struct {
Cluster string `json:"cluster"`
User string `json:"user"`
Namespace string `json:"namespace"`
}
type kubeConfigCluster struct {
Server string `json:"server"`
}
type kubeConfigClusters struct {
Name string `json:"name"`
Cluster kubeConfigCluster `json:"cluster"`
}
func (this KubeContext) GetCurrentContext() (string, error) {
cmd := exec.Command(this.Bin, "config", "current-context")
stdout, err := cmd.CombinedOutput()
res := string(stdout)
res = strings.TrimSuffix(res, "\n")
return res, err
}
// Current Context
// namespace, server
func (this KubeContext) GetContext() (string, string, string, error) {
cmd := exec.Command(this.Bin, "config", "view", "-o", "json")
stdout, _ := cmd.CombinedOutput()
var objmap kubeConfig
json.Unmarshal(stdout, &objmap)
currentContext := objmap.CurrentContext
currentCluster := ""
currentNamespace := ""
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
}
}
return currentContext, currentNamespace, currentServer, nil
}
func (this KubeContext) UseContext(newContext string) (error) {
cmd := exec.Command(this.Bin, "config", "use-context", newContext)
stdout, err := cmd.CombinedOutput()
if err != nil {
log.Log().Debug().Msg(string(stdout))
return errors.New(string(stdout))
}
return nil
}
func (this KubeContext) Check() (error) {
cmd := exec.Command(this.Bin, "cluster-info")
stdout, err := cmd.CombinedOutput()
if err != nil {
log.Log().Debug().Msg(string(stdout))
return errors.New("Kube non disponible")
}
return nil
}
package kubectl
import (
// "fmt"
"strings"
"errors"
"os/exec"
"encoding/json"
log "oc-deploy/log_wrapper"
)
type KubeContext struct {
Bin string // Chemin vers le binaire
}
type kubeConfig struct {
CurrentContext string `json:"current-context"`
Contexts [] kubeConfigContexts `json:"contexts"`
Clusters [] kubeConfigClusters `json:"clusters"`
}
type kubeConfigContexts struct {
Name string `json:"name"`
Context kubeConfigContext `json:"context"`
}
type kubeConfigContext struct {
Cluster string `json:"cluster"`
User string `json:"user"`
Namespace string `json:"namespace"`
}
type kubeConfigCluster struct {
Server string `json:"server"`
}
type kubeConfigClusters struct {
Name string `json:"name"`
Cluster kubeConfigCluster `json:"cluster"`
}
func (this KubeContext) GetCurrentContext() (string, error) {
cmd := exec.Command(this.Bin, "config", "current-context")
stdout, err := cmd.CombinedOutput()
res := string(stdout)
res = strings.TrimSuffix(res, "\n")
return res, err
}
// Current Context
// namespace, server
func (this KubeContext) GetContext() (string, string, string, error) {
cmd := exec.Command(this.Bin, "config", "view", "-o", "json")
stdout, _ := cmd.CombinedOutput()
var objmap kubeConfig
err := json.Unmarshal(stdout, &objmap)
if err != nil {
return "", "", "", err
}
currentContext := objmap.CurrentContext
currentCluster := ""
currentNamespace := ""
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
}
}
return currentContext, currentNamespace, currentServer, nil
}
func (this KubeContext) UseContext(newContext string) (error) {
cmd := exec.Command(this.Bin, "config", "use-context", newContext)
stdout, err := cmd.CombinedOutput()
if err != nil {
log.Log().Debug().Msg(string(stdout))
return errors.New(string(stdout))
}
return nil
}
func (this KubeContext) Check() (error) {
cmd := exec.Command(this.Bin, "cluster-info")
stdout, err := cmd.CombinedOutput()
if err != nil {
log.Log().Debug().Msg(string(stdout))
return errors.New("Kube non disponible")
}
return nil
}

162
src/kubectl/object.go
View File

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

62
src/kubectl/version.go
View File

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

37
src/tool/conf.go
View File

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

105
src/tool/helm.go
View File

@ -1,53 +1,54 @@
package tool
import (
"fmt"
"os"
// log "oc-deploy/log_wrapper"
"oc-deploy/utils"
"oc-deploy/helm"
)
type HelmInstallData struct {
obj ToolData
tmp string
}
func (this HelmInstallData) Get() (ToolData) {
return this.obj
}
func (this HelmInstallData) Download() (error) {
bin_dir := this.obj.Bin
err2 := os.MkdirAll(bin_dir, os.ModePerm)
if err2 != nil {
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)
err := utils.DownloadFromUrl(tmp_file, url, 0777)
if err != nil {
return err
}
r, _ := os.Open(tmp_file)
err1 := utils.ExtractTarGz(bin_dir, r)
os.Remove(tmp_file)
bin_file := fmt.Sprintf("%s/%s", bin_dir, this.obj.Name)
os.Chmod(bin_file, 0755)
return err1
}
///////////////
func (this HelmInstallData) Version(path string) (string, error) {
return helm.Version(path)
package tool
import (
"fmt"
"os"
"oc-deploy/utils"
"oc-deploy/helm"
)
type HelmInstallData struct {
obj ToolData
tmp string
}
func (this HelmInstallData) Get() (ToolData) {
return this.obj
}
func (this HelmInstallData) Download() (error) {
bin_dir := this.obj.Bin
err2 := os.MkdirAll(bin_dir, os.ModePerm)
if err2 != nil {
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)
err := utils.DownloadFromUrl(tmp_file, url, 0777)
if err != nil {
return err
}
r, _ := os.Open(tmp_file)
err1 := utils.ExtractTarGz(bin_dir, r)
if err1 != nil {return err1}
os.Remove(tmp_file)
bin_file := fmt.Sprintf("%s/%s", bin_dir, this.obj.Name)
errChmod := os.Chmod(bin_file, 0755)
if errChmod != nil {return errChmod}
return nil
}
///////////////
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
import (
"fmt"
"os"
"path/filepath"
log "oc-deploy/log_wrapper"
"oc-deploy/utils"
"oc-deploy/kubectl"
)
type KubecltInstallData struct {
obj ToolData
}
func (this KubecltInstallData) Get() (ToolData) {
return this.obj
}
func (this KubecltInstallData) Download() (error) {
bin_dir := this.obj.Bin
bin := filepath.Join(bin_dir, this.obj.Name)
url := fmt.Sprintf(this.obj.Url, this.obj.Version)
log.Log().Debug().Msg(fmt.Sprintf("Téléchargement : %s, %s", bin, url))
os.MkdirAll(bin_dir, os.ModePerm)
err := utils.DownloadFromUrl(bin, url, 0777)
if err != nil {return err}
os.Chmod(bin, 0755)
return nil
}
///////////////
func (this KubecltInstallData) Version(path string) (string, error) {
return kubectl.Version(path)
}
package tool
import (
"fmt"
"os"
"path/filepath"
log "oc-deploy/log_wrapper"
"oc-deploy/utils"
"oc-deploy/kubectl"
)
type KubecltInstallData struct {
obj ToolData
}
func (this KubecltInstallData) Get() (ToolData) {
return this.obj
}
func (this KubecltInstallData) Download() (error) {
bin_dir := this.obj.Bin
bin := filepath.Join(bin_dir, this.obj.Name)
url := fmt.Sprintf(this.obj.Url, this.obj.Version)
log.Log().Debug().Msg(fmt.Sprintf("Téléchargement : %s, %s", bin, url))
os.MkdirAll(bin_dir, os.ModePerm)
err := utils.DownloadFromUrl(bin, url, 0777)
if err != nil {return err}
os.Chmod(bin, 0755)
return nil
}
///////////////
func (this KubecltInstallData) Version(path string) (string, error) {
return kubectl.Version(path)
}

159
src/tool/tool.go
View File

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

68
src/utils/copyFile.go
View File

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

94
src/utils/copyFile_test.go
View File

@ -1,47 +1,47 @@
package utils
// https://pkg.go.dev/github.com/stretchr/testify/assert#Nilf
import (
"testing"
"path/filepath"
"github.com/stretchr/testify/assert"
)
func TestCopyFileExist(t *testing.T){
src := filepath.Join(TEST_SRC_DIR, "fichier1")
dest := filepath.Join(TEST_DEST_DIR, "fichier1")
err := CopyFile(src, dest)
assert.Nilf(t, err, "error message %s", src)
assert.FileExists(t, dest, "CopyFile error")
}
func TestCopyErrSrcFileNotExist(t *testing.T) {
src := filepath.Join(TEST_SRC_DIR, "inconnu")
dest := filepath.Join(TEST_DEST_DIR, "inconnu")
err := CopyFile(src, dest)
assert.NotNilf(t, err, "CopyFile error %s", src)
}
func TestCopyFileErrCreate(t *testing.T){
src := filepath.Join(TEST_SRC_DIR, "fichier1")
dest := filepath.Join("/INCONNU", "fichier1")
err := CopyFile(src, dest)
assert.NotNilf(t, err, "error message %s", src)
assert.NoFileExists(t, dest, "CopyFile error")
}
func TestCopyErrSrcWrite(t *testing.T) {
src := "/"
dest := filepath.Join(TEST_DEST_DIR, "inconnu")
err := CopyFile(src, dest)
assert.NotNilf(t, err, "CopyFile error %s", src)
}
package utils
// https://pkg.go.dev/github.com/stretchr/testify/assert#Nilf
import (
"testing"
"path/filepath"
"github.com/stretchr/testify/assert"
)
func TestCopyFileExist(t *testing.T){
src := filepath.Join(TEST_SRC_DIR, "fichier1")
dest := filepath.Join(TEST_DEST_DIR, "fichier1")
err := CopyFile(src, dest)
assert.Nilf(t, err, "error message %s", src)
assert.FileExists(t, dest, "CopyFile error")
}
func TestCopyErrSrcFileNotExist(t *testing.T) {
src := filepath.Join(TEST_SRC_DIR, "inconnu")
dest := filepath.Join(TEST_DEST_DIR, "inconnu")
err := CopyFile(src, dest)
assert.NotNilf(t, err, "CopyFile error %s", src)
}
func TestCopyFileErrCreate(t *testing.T){
src := filepath.Join(TEST_SRC_DIR, "fichier1")
dest := filepath.Join("/INCONNU", "fichier1")
err := CopyFile(src, dest)
assert.NotNilf(t, err, "error message %s", src)
assert.NoFileExists(t, dest, "CopyFile error")
}
func TestCopyErrSrcWrite(t *testing.T) {
src := "/"
dest := filepath.Join(TEST_DEST_DIR, "inconnu")
err := CopyFile(src, dest)
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)
for true {
for {
header, err := tarReader.Next()
if err == io.EOF {

56
src/utils/download_test.go
View File

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

44
src/utils/main_test.go
View File

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

29
src/versionOc/versionOc.go
View File

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